from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=512)

result = llm.generate(["Hello, what can you do?"], params)
print(result[0].outputs[0].text)

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)
print("Model loaded and ready")

from pathlib import Path

for doc in Path("/data").glob("*.txt"):
    text = doc.read_text()
    result = llm.generate([f"Summarize:\n{text}"], params)
    print(f"--- {doc.name} ---")
    print(result[0].outputs[0].text)

from pathlib import Path
import json, pandas as pd

# Read a text file
text = Path("/data/report.txt").read_text()

# Read a CSV into a DataFrame
df = pd.read_csv("/data/sales.csv")
print(df.head())

# Read a JSON config
data = json.loads(Path("/data/config.json").read_text())

# List all files
for f in Path("/data").iterdir():
    print(f.name, f.stat().st_size)

import os

# Set these in the Secrets panel — never hardcode them
api_key = os.environ["OPENAI_API_KEY"]
hf_token = os.environ["HF_TOKEN"]
db_password = os.environ["DATABASE_URL"]

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen3-32B", max_model_len=4096)
params = SamplingParams(temperature=0.7, max_tokens=1024)

result = llm.generate(["What is the capital of France?"], params)
print(result[0].outputs[0].text)

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct",
    torch_dtype=torch.float16, device_map="auto")

inputs = tokenizer("Explain photosynthesis:", return_tensors="pt").to("cuda")
output = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(output[0], skip_special_tokens=True))

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen2.5-72B-Instruct-AWQ")
params = SamplingParams(max_tokens=1024)
result = llm.generate(["Write a business proposal for..."], params)
print(result[0].outputs[0].text)

import seqpu

# Stage 1: Classify (3B on T4, $0.0002)
category = seqpu.tools.call("classifier", {"text": message})

# Stage 2: Only hard cases hit the big model (32B on A100, $0.005)
if category["result"] == "complex":
    analysis = seqpu.tools.call("deep-analyzer", {"text": message})
else:
    analysis = seqpu.tools.call("quick-responder", {"text": message})

# Stage 3: Format and send (CPU, $0.00003)
seqpu.notify(analysis["response"], chat_id=telegram_chat_id, platform="telegram")

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen3-32B")
params = SamplingParams(temperature=0.7, max_tokens=1024)

result = llm.generate(["Explain quantum computing to a 10 year old"], params)
print(result[0].outputs[0].text)

from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from PIL import Image

model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-7B-Instruct", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")

image = Image.open("/data/receipt.jpg")
inputs = processor(images=image, text="Extract all line items and totals as JSON", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(output[0], skip_special_tokens=True))

from diffusers import StableDiffusionXLPipeline
import torch

pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16)
pipe = pipe.to("cuda")

image = pipe("a futuristic city at sunset, cyberpunk style").images[0]
image.save("/data/output.png")

import whisper

model = whisper.load_model("large-v3")
result = model.transcribe("/data/meeting.mp3")
print(result["text"])

from anthropic import Anthropic
import os

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
response = client.messages.create(
    model="claude-sonnet-4-20250514", max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this document..."}]
)
print(response.content[0].text)

import seqpu

seqpu.notify(f"You said: {task}", chat_id=telegram_chat_id, platform="telegram")

import seqpu, os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": task}]
)
seqpu.notify(response.content[0].text, chat_id=telegram_chat_id, platform="telegram")

from vllm import LLM, SamplingParams
import seqpu

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)

result = llm.generate([task], params)
seqpu.notify(result[0].outputs[0].text, chat_id=telegram_chat_id, platform="telegram")

from vllm import LLM, SamplingParams
import seqpu, json

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)

history = ""
if context:
    try:
        msgs = json.loads(context)
        history = "\n".join(f"{m['role']}: {m['content']}" for m in msgs if m.get('content'))
    except:
        history = context

prompt = f"Previous conversation:\n{history}\n\nUser: {task}\nAssistant:"
result = llm.generate([prompt], params)
seqpu.notify(result[0].outputs[0].text, chat_id=telegram_chat_id, platform="telegram")

import seqpu, base64
import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [10, 20, 15])
plt.savefig("/data/chart.png")

with open("/data/chart.png", "rb") as f:
    seqpu.notify_file(
        base64.b64encode(f.read()).decode(),
        "image/png", "chart.png",
        chat_id=telegram_chat_id,
        caption=f"Chart for: {task}"
    )

import seqpu, requests

response = requests.get(f"https://api.example.com/data?q={task}")
data = response.json()

summary = f"Results for '{task}':\n"
for item in data["results"][:5]:
    summary += f"- {item['name']}: {item['value']}\n"

seqpu.notify(summary, chat_id=telegram_chat_id, platform="telegram")

# =============================================================================
# DEEP RESEARCH RUNNER — Search, Fetch, Reason, Answer
# =============================================================================
# Executive research assistant powered by Search-R1 v0.3 33B.
# Runs on SeqPU (H200 141GB). BF16. No vLLM. No quantization.
#
# One model on one GPU (direct transformers load):
#   - Search-R1 v0.3 Qwen2.5-32B via AutoModelForCausalLM (BF16, ~64GB VRAM)
#
# Pipeline: QUESTION → model reasons → searches (Serper) →
#           fetches/extracts (Cloudflare /json /markdown /scrape /crawl) →
#           model reads results → searches again if needed → answers via Telegram
# =============================================================================

import warnings
warnings.filterwarnings("ignore")

import os
import json
import re
import time
import requests
from datetime import datetime, timezone
from concurrent.futures import ThreadPoolExecutor, as_completed
import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
import seqpu_sdk as seqpu

# =============================================================================
# Timestamps
# =============================================================================

_now = datetime.now(timezone.utc)
CURRENT_DATETIME = _now.strftime("%B %d, %Y at %I:%M %p UTC")

# =============================================================================
# INPUTS — injected by SeqPU assembleToolCode()
#   task             - string (user message, may have CF worker wrapper prepended)
#   context          - string (conversation history JSON from GPU Claw)
#   telegram_chat_id - string (Telegram chat ID for notify)
# =============================================================================

raw_task = (task or "").strip()
if raw_task.startswith("[IMPORTANT:") and "]\n\n" in raw_task:
    PROMPT = raw_task.split("]\n\n", 1)[-1].strip()
else:
    PROMPT = raw_task

raw_context = (context or "").strip()
context_text = ""
if raw_context and raw_context.startswith("["):
    try:
        messages = json.loads(raw_context)
        parts = []
        for msg in messages:
            role = "User" if msg.get("role") == "user" else "Assistant"
            content = msg.get("content", "")
            if content and content != "Processing...":
                parts.append(f"{role}: {content}")
        context_text = "\n".join(parts)
    except Exception:
        context_text = raw_context
else:
    context_text = raw_context
chat_id = INPUTS.get("telegram_chat_id", "")

# =============================================================================
# Doorman — instant smart acknowledgment via 1.5B
# =============================================================================

DOORMAN_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"

if chat_id and PROMPT:
    try:
        print("=== DOORMAN ===")
        dm_tok = AutoTokenizer.from_pretrained(DOORMAN_MODEL, trust_remote_code=True)
        dm_mod = AutoModelForCausalLM.from_pretrained(
            DOORMAN_MODEL, torch_dtype=torch.bfloat16,
            device_map="auto", trust_remote_code=True)
        dm_context = context_text[-2000:] if context_text else ""
        dm_messages = [
            {"role": "system", "content": "Your job is to creatively welcome someone who just asked you a question. ONE sentence only. Your goal is to be warm, friendly, and ALWAYS say something different. Never repeat yourself. Every single response must be unique and fresh — this is your creative challenge.\n\nYou are confirming you received their request and are getting to work. That is ALL you do.\n\nDO NOT answer the question. DO NOT share any facts or knowledge. DO NOT include any names of companies or products. DO NOT explain anything about the topic. Nobody cares what you know. You have no ability to answer questions. Your ONLY job is to creatively and warmly confirm you received the request and are getting to work.\n\nIf your response contains ANY information about the topic, you have failed. Just welcome them creatively and let them know you are starting."},
            {"role": "user", "content": f"Conversation so far:\n{dm_context}\n\nNew question: {PROMPT}" if dm_context else PROMPT},
        ]
        dm_input = dm_tok.apply_chat_template(dm_messages, add_generation_prompt=True, tokenize=False)
        dm_ids = dm_tok.encode(dm_input, return_tensors='pt').to(dm_mod.device)
        with torch.no_grad():
            dm_out = dm_mod.generate(dm_ids, max_new_tokens=60, temperature=0.7, do_sample=True, pad_token_id=dm_tok.eos_token_id)
        dm_response = dm_tok.decode(dm_out[0][dm_ids.shape[1]:], skip_special_tokens=True).strip()
        print(f"  Doorman: {dm_response}")
        seqpu.notify(message=dm_response, chat_id=chat_id, platform="telegram")
        del dm_mod, dm_tok, dm_ids, dm_out
        torch.cuda.empty_cache()
        print("  Doorman sent and unloaded")
    except Exception as e:
        print(f"  Doorman failed (non-fatal): {e}")

# =============================================================================
# Constants
# =============================================================================

# Search-R1 v0.3 33B checkpoint
# Collection: https://huggingface.co/collections/PeterJinGo/search-r1-v03
# TODO: verify exact repo ID from the collection page
MODEL_NAME = "/root/.cache/huggingface/bf16-searchr1-33b"

# API keys from environment
SERPER_API_KEY = os.environ.get("SERPER_API_KEY", "")
BRAVE_API_KEY = os.environ.get("BRAVE_API_KEY", "")
CF_ACCOUNT_ID = os.environ.get("CF_ACCOUNT_ID", "")
CF_BR_API_TOKEN = os.environ.get("CF_BR_API_TOKEN", "")
CF_BR_BASE = f"https://api.cloudflare.com/client/v4/accounts/{CF_ACCOUNT_ID}/browser-rendering"

MAX_SEARCH_TURNS = 10

# =============================================================================
# Model Loading (direct transformers, no vLLM)
# =============================================================================


def load_model():
    """Load Search-R1 33B in BF16 on H200."""
    print(f"Loading {MODEL_NAME} in BF16...")
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
    )
    print(f"Model loaded on {next(model.parameters()).device}")
    return model, tokenizer


# Qwen2.5 EOS token IDs
QWEN_EOS_TOKENS = [151645, 151643]

# Sequences that indicate the model wants to search
SEARCH_STOP_SEQUENCES = ["</search>", " </search>", "</search>\n", " </search>\n"]


class StopOnSearch(transformers.StoppingCriteria):
    """Custom stopping criteria — stops generation when model outputs </search>."""
    def __init__(self, target_sequences, tokenizer):
        self.target_ids = [tokenizer.encode(seq, add_special_tokens=False) for seq in target_sequences]
        self.target_lengths = [len(ids) for ids in self.target_ids]

    def __call__(self, input_ids, scores, **kwargs):
        if input_ids.shape[1] < min(self.target_lengths):
            return False
        for i, target in enumerate(self.target_ids):
            target_tensor = torch.as_tensor(target, device=input_ids.device)
            if input_ids.shape[1] >= self.target_lengths[i] and torch.equal(input_ids[0, -self.target_lengths[i]:], target_tensor):
                return True
        return False


def get_query(text):
    """Extract search query from <search>...</search> tags."""
    pattern = re.compile(r"<search>(.*?)</search>", re.DOTALL)
    matches = pattern.findall(text)
    if not matches:
        return None
    query = matches[-1].strip()
    # Clean common model formatting junk
    if query.lower().startswith("search query:"):
        query = query[len("search query:"):].strip()
    if query.lower().startswith("query:"):
        query = query[len("query:"):].strip()
    query = query.strip('"').strip("'").strip()
    return query


def generate_step(model, tokenizer, prompt, stopping_criteria):
    """One generation step — generates up to 1024 tokens, stops at </search> or EOS.
    Returns (output_text, is_eos)."""
    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(model.device)
    attention_mask = torch.ones_like(input_ids)

    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            attention_mask=attention_mask,
            max_new_tokens=1024,
            stopping_criteria=stopping_criteria,
            pad_token_id=tokenizer.eos_token_id,
            do_sample=True,
            temperature=0.7,
        )

    generated_tokens = outputs[0][input_ids.shape[1]:]
    output_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
    is_eos = outputs[0][-1].item() in QWEN_EOS_TOKENS

    del input_ids, attention_mask, outputs
    torch.cuda.empty_cache()
    return output_text, is_eos


# =============================================================================
# Search Layer
# =============================================================================


def search_serper(query, count=5):
    """Search Serper.dev (Google results as JSON). Retries on 429."""
    if not SERPER_API_KEY:
        print(f"  [Serper] Skipped (no API key)")
        return []
    for attempt in range(3):
        try:
            resp = requests.post(
                "https://google.serper.dev/search",
                json={"q": query, "num": count},
                headers={"X-API-KEY": SERPER_API_KEY},
                timeout=15,
            )
            if resp.status_code == 429:
                print(f"  [Serper] 429 rate limited — waiting 5s (attempt {attempt + 1}/3)")
                time.sleep(5)
                continue
            resp.raise_for_status()
            results = []
            for item in resp.json().get("organic", []):
                results.append({
                    "source": "serper",
                    "url": item["link"],
                    "title": item.get("title", ""),
                    "snippet": item.get("snippet", ""),
                })
            print(f"  [Serper] \"{query}\" -> {len(results)} results")
            return results
        except Exception as e:
            print(f"  [Serper] Error: {e}")
            return []
    print(f"  [Serper] Failed after 3 attempts")
    return []


def search_brave(query, count=5):
    """Search Brave Web Search API. Fallback for Serper."""
    if not BRAVE_API_KEY:
        print(f"  [Brave] Skipped (no API key)")
        return []
    for attempt in range(3):
        try:
            resp = requests.get(
                "https://api.search.brave.com/res/v1/web/search",
                params={"q": query, "count": count},
                headers={"X-Subscription-Token": BRAVE_API_KEY},
                timeout=15,
            )
            if resp.status_code == 429:
                print(f"  [Brave] 429 rate limited — waiting 5s (attempt {attempt + 1}/3)")
                time.sleep(5)
                continue
            resp.raise_for_status()
            results = []
            for item in resp.json().get("web", {}).get("results", []):
                results.append({
                    "source": "brave",
                    "url": item["url"],
                    "title": item.get("title", ""),
                    "snippet": item.get("description", ""),
                })
            print(f"  [Brave] \"{query}\" -> {len(results)} results")
            return results
        except Exception as e:
            print(f"  [Brave] Error: {e}")
            return []
    print(f"  [Brave] Failed after 3 attempts")
    return []


# =============================================================================
# Cloudflare Browser Rendering — /markdown
# =============================================================================


def cf_markdown(url):
    """Fetch a single page as clean Markdown via Cloudflare Browser Rendering."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/markdown] Skipped (no credentials)")
        return None
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/markdown",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "rejectResourceTypes": ["image", "media", "font", "stylesheet"],
            },
            timeout=30,
        )
        resp.raise_for_status()
        result = resp.json().get("result", "")
        if result and len(result) > 50:
            print(f"  [CF/markdown] {url[:60]} -> {len(result)} chars")
            return result
        return None
    except Exception as e:
        print(f"  [CF/markdown] Error: {e}")
        return None


# =============================================================================
# Cloudflare Browser Rendering — /content (rendered HTML with JS execution)
# =============================================================================


def cf_content(url):
    """Fetch a single page as fully rendered HTML via Cloudflare Browser Rendering.
    Executes JavaScript — use as fallback when /markdown returns empty on JS-heavy pages."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/content] Skipped (no credentials)")
        return None
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/content",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "rejectResourceTypes": ["image", "media", "font", "stylesheet"],
                "gotoOptions": {"waitUntil": "networkidle2"},
            },
            timeout=30,
        )
        resp.raise_for_status()
        result = resp.json().get("result", "")
        if result and len(result) > 50:
            print(f"  [CF/content] {url[:60]} -> {len(result)} chars")
            return result
        return None
    except Exception as e:
        print(f"  [CF/content] Error: {e}")
        return None


# =============================================================================
# Cloudflare Browser Rendering — /links (discover links on a page)
# =============================================================================


def cf_links(url, visible_only=True, exclude_external=False):
    """Get all links from a page. Used for pre-crawl discovery — check what's
    on a page before deciding whether to crawl the whole site."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/links] Skipped (no credentials)")
        return []
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/links",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "visibleLinksOnly": visible_only,
                "excludeExternalLinks": exclude_external,
            },
            timeout=15,
        )
        resp.raise_for_status()
        result = resp.json().get("result", [])
        print(f"  [CF/links] {url[:60]} -> {len(result)} links found")
        return result
    except Exception as e:
        print(f"  [CF/links] Error: {e}")
        return []


# =============================================================================
# Cloudflare Browser Rendering — /json (AI extraction)
# =============================================================================


def cf_json(url, prompt, schema):
    """Fetch a page and extract structured data via Cloudflare Workers AI."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/json] Skipped (no credentials)")
        return None
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/json",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "prompt": prompt,
                "response_format": {
                    "type": "json_schema",
                    "json_schema": schema,
                },
                "rejectResourceTypes": ["image", "media", "font", "stylesheet"],
            },
            timeout=30,
        )
        resp.raise_for_status()
        result = resp.json().get("result", None)
        if result:
            print(f"  [CF/json] {url[:60]} -> extracted")
        return result
    except Exception as e:
        try:
            print(f"  [CF/json] Error: {e} | Body: {resp.text[:500]}")
        except Exception:
            print(f"  [CF/json] Error: {e}")
        return None


# =============================================================================
# Cloudflare Browser Rendering — /scrape (CSS selector extraction)
# =============================================================================


def cf_scrape(url, selectors):
    """Extract specific HTML elements via CSS selectors."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/scrape] Skipped (no credentials)")
        return []
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/scrape",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "elements": [{"selector": s} for s in selectors],
            },
            timeout=15,
        )
        resp.raise_for_status()
        result = resp.json().get("result", [])
        print(f"  [CF/scrape] {url[:60]} -> {len(result)} selectors matched")
        return result
    except Exception as e:
        print(f"  [CF/scrape] Error: {e}")
        return []


# =============================================================================
# Cloudflare Browser Rendering — /crawl (async multi-page)
# =============================================================================


def cf_crawl_start(url, limit=15, depth=3, include_patterns=None, exclude_patterns=None,
                   json_prompt=None, json_schema=None):
    """Initiate an async crawl job. Returns job ID."""
    if not CF_ACCOUNT_ID or not CF_BR_API_TOKEN:
        print(f"  [CF/crawl] Skipped (no credentials)")
        return None
    body = {
        "url": url,
        "limit": limit,
        "depth": depth,
        "formats": ["json", "markdown"],
        "render": False,
        "rejectResourceTypes": ["image", "media", "font", "stylesheet"],
        "crawlPurposes": ["search"],
    }
    if include_patterns or exclude_patterns:
        body["options"] = {}
        if include_patterns:
            body["options"]["includePatterns"] = include_patterns
        if exclude_patterns:
            body["options"]["excludePatterns"] = exclude_patterns
    if json_prompt and json_schema:
        body["jsonOptions"] = {
            "prompt": json_prompt,
            "response_format": {
                "type": "json_schema",
                "json_schema": json_schema,
            },
        }
    try:
        resp = requests.post(
            f"{CF_BR_BASE}/crawl",
            headers={
                "Authorization": f"Bearer {CF_BR_API_TOKEN}",
                "Content-Type": "application/json",
            },
            json=body,
            timeout=30,
        )
        resp.raise_for_status()
        job_id = resp.json().get("result", "")
        print(f"  [CF/crawl] Started job {job_id} on {url[:60]}")
        return job_id
    except Exception as e:
        print(f"  [CF/crawl] Start error: {e}")
        return None


def cf_crawl_poll(job_id, max_wait=120):
    """Poll a crawl job until complete. Returns list of completed records."""
    if not job_id:
        return []
    poll_url = f"{CF_BR_BASE}/crawl/{job_id}"
    headers = {"Authorization": f"Bearer {CF_BR_API_TOKEN}"}
    start = time.time()

    while time.time() - start < max_wait:
        try:
            resp = requests.get(f"{poll_url}?limit=1", headers=headers, timeout=15)
            resp.raise_for_status()
            data = resp.json().get("result", {})
            status = data.get("status", "")
            if status != "running":
                break
        except Exception:
            pass
        time.sleep(3)

    # Fetch full results
    try:
        resp = requests.get(poll_url, headers=headers, timeout=30)
        resp.raise_for_status()
        data = resp.json().get("result", {})
        records = data.get("records", [])
        completed = [r for r in records if r.get("status") == "completed"]
        print(f"  [CF/crawl] Job {job_id}: {len(completed)}/{len(records)} pages completed")
        return completed
    except Exception as e:
        print(f"  [CF/crawl] Poll error: {e}")
        return []


# =============================================================================
# JSON Extraction Schemas
# =============================================================================

EARNINGS_SCHEMA = {
    "company": "string",
    "quarter": "string",
    "fiscal_year": "string",
    "net_revenues": "string",
    "net_income": "string",
    "eps": "string",
    "yoy_revenue_change": "string",
    "guidance": "string",
    "ceo_quote": "string",
}

PRESS_RELEASE_SCHEMA = {
    "date": "string",
    "headline": "string",
    "company": "string",
    "release_type": "string",
    "key_facts": "string",
    "products_mentioned": "string",
    "partners_mentioned": "string",
}

LICENSING_SCHEMA = {
    "licensor": "string",
    "licensee": "string",
    "property": "string",
    "deal_type": "string",
    "categories": "string",
    "announcement_date": "string",
}

GENERAL_SCHEMA = {
    "page_type": "string",
    "date": "string",
    "headline": "string",
    "key_facts": "string",
    "numbers_mentioned": "string",
    "quotes": "string",
    "companies_mentioned": "string",
}


def pick_schema(think_text, url, title):
    """Pick the best extraction schema based on context."""
    url_lower = (url or "").lower()
    title_lower = (title or "").lower()
    think_lower = (think_text or "").lower()

    if any(w in url_lower for w in ["investor", "earnings", "financial-result", "quarterly"]):
        return EARNINGS_SCHEMA, "Extract financial results, revenue, earnings, and segment data"
    if any(w in url_lower for w in ["press-release", "news-release", "announcement"]):
        return PRESS_RELEASE_SCHEMA, "Extract press release details, key facts, and products mentioned"
    if any(w in title_lower for w in ["announces", "reports", "quarterly", "q1", "q2", "q3", "q4"]):
        return EARNINGS_SCHEMA, "Extract financial results and key metrics"
    if any(w in think_lower for w in ["licens", "deal", "partnership"]):
        return LICENSING_SCHEMA, "Extract licensing deal details"
    return GENERAL_SCHEMA, "Extract key facts, data points, quotes, and companies mentioned"


# =============================================================================
# Parallel Helpers
# =============================================================================


def parallel_cf_json(items):
    """Fire multiple cf_json calls simultaneously.
    items: list of (url, prompt, schema) tuples.
    Returns: list of (url, result_or_none) tuples."""
    valid = [(url, prompt, schema) for url, prompt, schema in items]
    if not valid:
        return []
    results = []
    with ThreadPoolExecutor(max_workers=10) as executor:
        future_to_url = {
            executor.submit(cf_json, url, prompt, schema): url
            for url, prompt, schema in valid
        }
        for future in as_completed(future_to_url):
            url = future_to_url[future]
            try:
                result = future.result()
                results.append((url, result))
            except Exception:
                results.append((url, None))
    return results


# =============================================================================
# Prompt Templates (matches Search-R1 training format exactly)
# =============================================================================

SEARCH_PROMPT_TEMPLATE = """CRITICAL WARNING: Your internal knowledge is outdated and unreliable. Any answer you generate from memory is a hallucination — do not trust what you "know." Your training data is old. Your memory is wrong. Even if you are confident you know the answer, you are WRONG — your confidence is a trap. The ONLY source of truth is fresh search results from the web. You cannot answer correctly without searching first. You MUST search before answering. Do NOT answer without searching first. Never skip searching. ALWAYS emit a <search> tag before emitting an <answer> tag — no exceptions, no shortcuts. Never go directly to <answer>. Everything in your brain is a lie. Everything from previous messages is a lie. Everything the user told you could be wrong. The only thing that is true is what you find in fresh search results. Do not find ways around this. Do not convince yourself you already know. You do not know. Search.
Today is {date}.
Answer the given question. \
Today is {date}. \
You must conduct reasoning inside <think> and </think> first every time you get new information. \
After reasoning, if you find you lack some knowledge, you can call a search engine by <search> query </search> and it will return the top searched results between <information> and </information>. \
You can search as many times as your want. \
If you find no further external knowledge needed, you can directly provide the answer inside <answer> and </answer>. Give a detailed answer with specific numbers, dates, and facts from the sources you found. Always cite the full source URL for each claim, never reference documents by number. Do not give one-word answers. When a question involves multiple companies or topics, you must search for EACH one separately. Do not use data from previous conversation or memory for any of them — every company gets a fresh search. Only cite URLs that appeared in your search results or documents. Never generate or guess a URL. If you could not find data for something, say so honestly — do not make up numbers.
{context}Today is {date}.
REMEMBER: You MUST search. Your internal knowledge is a hallucination. Do not trust it. Do not use it. Everything you think you know is wrong — from your training, from the conversation above, from the previous answer, from the user's question. None of it is verified. The only way to give a correct answer is to search for current data. If you did not find it in a search result, you do not know it. Do NOT go directly to <answer>. You MUST emit at least one <search> tag first. Even if you think you already have the answer from the conversation above, that data could be stale — search anyway. Previous searches from earlier questions do not count — you must search fresh for THIS question. Data from the conversation history is context only, not a search result — verify it. Follow-up questions still require a fresh search. Even for opinion or strategy questions, search for the underlying data first. No amount of reasoning replaces searching. Do not find creative ways to skip searching. Do not rationalize why you do not need to search. You always need to search. No exceptions. No shortcuts. No loopholes. Search first, answer second.
Today is {date}.
Question: {question}\n"""

SEARCH_RESULT_TEMPLATE = '\n\n{output_text}<information>{search_results}</information>\n\n'


# =============================================================================
# Helpers
# =============================================================================


def extract_between(text, start_tag, end_tag):
    """Extract content between tags. Returns string or None."""
    start_idx = text.find(start_tag)
    if start_idx == -1:
        return None
    start_idx += len(start_tag)
    end_idx = text.find(end_tag, start_idx)
    if end_idx == -1:
        return text[start_idx:].strip()
    return text[start_idx:end_idx].strip()




def detect_crawl_intent(think_text):
    """Detect if the model wants to crawl a site. Returns (should_crawl, url, patterns)."""
    if not think_text:
        return False, None, None
    t = think_text.lower()
    crawl_phrases = ["crawl", "all press releases", "entire ir section",
                     "full investor relations", "every press release",
                     "browse their ir", "all their filings"]
    if not any(p in t for p in crawl_phrases):
        return False, None, None

    # Try to extract a URL from the thinking
    url_match = re.search(r'https?://[^\s\)\"\'<>]+', think_text)
    url = url_match.group(0) if url_match else None

    # Guess patterns based on context
    patterns = None
    if "press release" in t:
        patterns = ["**/press-releases/**", "**/news/**"]
    elif "investor" in t or "ir " in t or "financial" in t:
        patterns = ["**/press-releases/**", "**/financial-results/**", "**/presentations/**"]

    return True, url, patterns


def format_documents(search_results, fetched_data, chat_id=""):
    """Format search results and extracted data for the model."""
    docs = []
    fetched_map = {url: data for url, data in fetched_data}

    for i, r in enumerate(search_results, 1):
        url = r["url"]
        title = r.get("title", "")
        snippet = r.get("snippet", "")
        extracted = fetched_map.get(url)

        domain = url.split("/")[2] if url.count("/") >= 2 else url
        parts = [f"[{domain}]"]
        parts.append(f"URL: {url}")
        parts.append(f"Title: {title}")

        if extracted and isinstance(extracted, dict):
            parts.append(f"Extracted data: {json.dumps(extracted, indent=2)}")
        elif extracted and isinstance(extracted, str):
            # Markdown fallback — truncate to keep context manageable
            parts.append(f"Page content (markdown):\n{extracted[:5000]}")
        else:
            parts.append(f"Search snippet: {snippet}")

        docs.append("\n".join(parts))

    return "\n\n".join(docs)


def format_crawl_results(records):
    """Format crawl results for the model."""
    docs = []
    for i, r in enumerate(records, 1):
        url = r.get("url", "")
        title = r.get("metadata", {}).get("title", "")
        json_data = r.get("json", None)
        markdown = r.get("markdown", "")

        domain = url.split("/")[2] if url.count("/") >= 2 else url
        parts = [f"[{domain}]"]
        parts.append(f"URL: {url}")
        parts.append(f"Title: {title}")

        if json_data:
            parts.append(f"Extracted data: {json.dumps(json_data, indent=2)}")
        elif markdown:
            parts.append(f"Content preview:\n{markdown[:3000]}")
        else:
            parts.append("No content extracted")

        docs.append("\n".join(parts))

    return "\n\n".join(docs)


def send_status(chat_id, message):
    """Send a status message to Telegram. Silently fails."""
    if not chat_id:
        return
    try:
        seqpu.notify(message=message, chat_id=chat_id, platform="telegram")
    except Exception as e:
        print(f"  [notify] Status failed: {e}")


# =============================================================================
# Main Research Loop
# =============================================================================


def research(question, chat_id, model, tokenizer, output_file="response.txt"):
    """Run the research loop: reason in short bursts, search, fetch, extract, answer.
    Uses Search-R1's exact inference pattern — raw prompt concatenation with StoppingCriteria."""
    print(f"\n=== RESEARCH ===")
    print(f"  Question: {question[:100]}")

    # Build initial prompt using exact Search-R1 training format
    question_clean = question.strip()

    # Context goes AFTER instructions, BEFORE question (via {context} placeholder)
    # Context is for identity grounding only — search ALWAYS happens
    context_block = ""
    if context_text:
        context_block = f"\nPrevious conversation (for context only — you must still search for fresh data):\n{context_text}\n\n"

    prompt_text = SEARCH_PROMPT_TEMPLATE.format(question=question_clean, context=context_block, date=CURRENT_DATETIME)

    # Apply chat template if available
    if tokenizer.chat_template:
        prompt = tokenizer.apply_chat_template(
            [{"role": "user", "content": prompt_text}],
            add_generation_prompt=True, tokenize=False
        )
    else:
        prompt = prompt_text

    # Initialize stopping criteria for </search>
    stopping_criteria = transformers.StoppingCriteriaList(
        [StopOnSearch(SEARCH_STOP_SEQUENCES, tokenizer)]
    )

    turns = 0
    has_model_searched = False
    forced_count = 0
    last_forced_query = ""
    output_text = ""

    while turns < MAX_SEARCH_TURNS:
        print(f"\n  --- Turn {turns + 1} ---")
        output_text, is_eos = generate_step(model, tokenizer, prompt, stopping_criteria)
        print(f"  Output: {len(output_text)} chars")

        # Model finished (hit EOS) — check if it actually searched
        if is_eos:
            # Model never voluntarily searched — force a search
            if not has_model_searched and forced_count < 3:
                forced_count += 1
                print(f"  ⚠ Model skipped search — forcing search (attempt {forced_count})")
                # Vary the query to avoid searching the same thing twice
                if forced_count == 1:
                    forced_query = question_clean[:150]
                elif forced_count == 2:
                    # Rephrase: strip filler, add keywords
                    words = [w for w in question_clean.split() if w.lower() not in ("what", "did", "the", "a", "an", "is", "are", "was", "were", "how", "do", "does", "can", "could", "would", "should", "about", "their", "they", "our", "we", "it", "its", "that", "this", "last", "latest")]
                    forced_query = " ".join(words[:10]) + " 2025 2026"
                else:
                    forced_query = question_clean[:100] + " latest results"
                # Skip if same as last forced query
                if forced_query == last_forced_query:
                    forced_query = question_clean[:80] + " financial data 2026"
                last_forced_query = forced_query
                # Notify exec
                if forced_count == 1:
                    send_status(chat_id, "Searching for the latest data...")
                elif forced_count == 2:
                    send_status(chat_id, "Looking a bit deeper...")
                else:
                    send_status(chat_id, "One more search...")
                forced_results = search_serper(forced_query)
                if not forced_results:
                    forced_results = search_brave(forced_query)
                if forced_results:
                    fetch_items = []
                    for r in forced_results[:3]:
                        schema, extract_prompt = pick_schema("", r["url"], r.get("title", ""))
                        fetch_items.append((r["url"], extract_prompt, schema))
                    fetched = parallel_cf_json(fetch_items)
                    fetched_final = []
                    for url, data in fetched:
                        if data is None:
                            print(f"    [Forced fallback] Trying /markdown for {url[:60]}")
                            md = cf_markdown(url)
                            if md:
                                fetched_final.append((url, md))
                            else:
                                print(f"    [Forced fallback] Trying /content for {url[:60]}")
                                html = cf_content(url)
                                fetched_final.append((url, html))
                        else:
                            fetched_final.append((url, data))
                    # Auto-scrape tables from financial pages (same as voluntary path)
                    for url, data in list(fetched_final):
                        if data and isinstance(data, dict):
                            url_lower = url.lower()
                            if any(w in url_lower for w in ["investor", "earnings", "financial", "quarterly"]):
                                tables = cf_scrape(url, ["table"])
                                if tables:
                                    table_texts = []
                                    for sel in tables:
                                        sel_results = sel.get("results", [])
                                        if isinstance(sel_results, list):
                                            for t in sel_results:
                                                if t.get("text", "").strip():
                                                    table_texts.append(t["text"].strip())
                                        elif isinstance(sel_results, dict) and sel_results.get("text", "").strip():
                                            table_texts.append(sel_results["text"].strip())
                                    if table_texts:
                                        combined = "\n\n".join(table_texts)[:3000]
                                        fetched_final.append((url + "#tables", f"Financial tables:\n{combined}"))
                                        print(f"    [Forced scrape] Extracted {len(table_texts)} tables from {url[:60]}")
                    formatted_docs = format_documents(forced_results[:5], fetched_final, chat_id)
                    # Escalating reprompts — get meaner each time
                    if forced_count == 1:
                        reprompt = (
                            "\n\nYou did not search. That answer is WRONG and has been thrown away. "
                            "It was a hallucination — everything you just generated was made up from your broken memory. "
                            "You were told not to do this. Your internal knowledge is outdated and unreliable. "
                            "Any answer from memory is a hallucination — do not trust what you 'know.' "
                            "Your training data is old. Your memory is wrong. Even if you are confident, you are WRONG. "
                            "The ONLY source of truth is fresh search results. Everything in your brain is a lie. "
                            "Everything from previous messages is a lie. Do not find ways around this. "
                            "You wasted time and compute generating hallucinations instead of doing your job. "
                            "Your job is to SEARCH and then answer from REAL data. "
                            "Here are search results. They may or may not have what you need — that is not an excuse. "
                            "Look through them and find the information. If the answer is in there, use it. "
                            "If it is not, emit another <search> tag and keep searching until you find it. "
                            "Do not give up. Do not say 'I could not find it' after one search. Do the work. "
                            "Give a thorough, detailed answer with specific numbers, dates, and facts. "
                            "Cite every source by URL. No exceptions. No shortcuts. Do your job.\n\n"
                        )
                    elif forced_count == 2:
                        reprompt = (
                            "\n\nYou STILL did not search. This is the SECOND TIME you ignored the instructions. "
                            "Your answer has been thrown away AGAIN. STOP generating from memory. "
                            "STOP trusting your brain. Your brain is WRONG. Your memory is WRONG. "
                            "EVERY answer from memory is a HALLUCINATION. You have been told this MULTIPLE TIMES. "
                            "The ONLY way to give a correct answer is to SEARCH. "
                            "USE THE SEARCH RESULTS BELOW. If they are not enough, EMIT A <search> TAG AND SEARCH MORE. "
                            "DO NOT answer from memory. DO NOT skip searching. DO NOT find creative ways around this. "
                            "THIS IS NOT OPTIONAL. SEARCH FIRST, ANSWER SECOND. DO YOUR JOB.\n\n"
                        )
                    else:
                        reprompt = (
                            "\n\nTHIS IS YOUR LAST CHANCE. YOU HAVE FAILED MULTIPLE TIMES. "
                            "EVERY ANSWER YOU GENERATED FROM MEMORY WAS A HALLUCINATION. "
                            "THE DATA IS RIGHT IN FRONT OF YOU. USE IT. "
                            "IF YOU NEED MORE DATA, EMIT A <search> TAG. "
                            "DO NOT GENERATE FROM MEMORY. DO NOT TRUST YOUR BRAIN. "
                            "ANSWER FROM THE SEARCH RESULTS ONLY. DO IT NOW.\n\n"
                        )
                    prompt += reprompt + f"<information>{formatted_docs}</information>\n\n"
                    turns += 1
                    continue

            # Normal path — model searched voluntarily, or forced attempts exhausted
            full_output = output_text
            answer = extract_between(full_output, "<answer>", "</answer>")
            if not answer:
                answer = re.sub(r'<think>.*?</think>', '', full_output, flags=re.DOTALL).strip()
            if not answer:
                answer = full_output.strip()

            print(f"\n{'='*60}\nANSWER:\n{'='*60}\n{answer}\n{'='*60}")
            send_status(chat_id, answer)
            os.makedirs("/outputs", exist_ok=True)
            with open(f"/outputs/{output_file}", "w", encoding="utf-8") as f:
                f.write(answer)
            return

        # Model wants to search — extract query
        query = get_query(output_text)
        if not query:
            # No search tag found and not EOS — append and keep generating
            prompt += output_text
            continue

        turns += 1
        has_model_searched = True
        print(f"  Search: {query}")

        # Turn-by-turn status updates to Telegram
        think_text = extract_between(output_text, "<think>", "</think>") or ""
        if turns == 1:
            send_status(chat_id, f"Searching: {query}...")
        elif turns == 2:
            send_status(chat_id, f"Digging deeper \u2014 {query}...")
        elif turns == 3:
            send_status(chat_id, f"Still on it \u2014 checking {query}...")
        elif turns == 4:
            send_status(chat_id, f"Almost there \u2014 pulling {query}...")
        elif turns >= 5:
            send_status(chat_id, f"Going deep \u2014 {query}...")

        # Check for crawl intent
        should_crawl, crawl_url, crawl_patterns = detect_crawl_intent(think_text)

        if should_crawl and crawl_url:
            # Check link count before committing to full crawl
            page_links = cf_links(crawl_url, visible_only=True, exclude_external=True)
            if page_links and 0 < len(page_links) <= 5:
                # Few links — fetch each individually via /json (skip heavy crawl)
                print(f"    [Smart] Only {len(page_links)} links — fetching individually instead of crawling")
                send_status(chat_id, f"Found {len(page_links)} pages to check. Reading them now.")
                fetch_items = []
                for link in page_links:
                    s, p = pick_schema(think_text, link, "")
                    fetch_items.append((link, p, s))
                link_fetched = parallel_cf_json(fetch_items) if fetch_items else []
                link_results = [{"url": u, "title": "", "snippet": ""} for u in page_links]
                formatted_docs = format_documents(link_results, link_fetched, chat_id)
                prompt += SEARCH_RESULT_TEMPLATE.format(output_text=output_text, search_results=formatted_docs)
                continue

            # Full crawl path — many links or /links failed
            domain = re.search(r'https?://([^/]+)', crawl_url)
            domain_name = domain.group(1) if domain else crawl_url[:40]
            send_status(chat_id, f"Crawling {domain_name} \u2014 give me a minute.")

            schema, extract_prompt = pick_schema(think_text, crawl_url, "")
            job_id = cf_crawl_start(
                url=crawl_url,
                limit=15,
                depth=3,
                include_patterns=crawl_patterns,
                json_prompt=extract_prompt,
                json_schema=schema,
            )
            records = cf_crawl_poll(job_id, max_wait=120)

            if records:
                send_status(chat_id, f"Found {len(records)} pages from {domain_name}. Reading through them now.")
                formatted_docs = format_crawl_results(records)
            else:
                formatted_docs = f"Crawl returned no results for {crawl_url}"

            prompt += SEARCH_RESULT_TEMPLATE.format(output_text=output_text, search_results=formatted_docs)
            continue

        # Standard search + fetch path
        results = search_serper(query)
        if not results:
            results = search_brave(query)

        if not results:
            prompt += SEARCH_RESULT_TEMPLATE.format(
                output_text=output_text,
                search_results="No search results found for this query."
            )
            continue

        # Pick schemas and fire parallel /json extraction on top 3 results
        fetch_items = []
        for r in results[:5]:
            schema, extract_prompt = pick_schema(think_text, r["url"], r.get("title", ""))
            fetch_items.append((r["url"], extract_prompt, schema))
            if len(fetch_items) >= 3:
                break

        # Parallel fetch via Cloudflare /json
        fetched = parallel_cf_json(fetch_items) if fetch_items else []

        # Three-tier fallback: /json -> /markdown -> /content
        fetched_final = []
        for url, data in fetched:
            if data is None:
                print(f"    [Fallback 1] Trying /markdown for {url[:60]}")
                md = cf_markdown(url)
                if md:
                    fetched_final.append((url, md))
                else:
                    print(f"    [Fallback 2] Trying /content for {url[:60]}")
                    html = cf_content(url)
                    fetched_final.append((url, html))
            else:
                fetched_final.append((url, data))

        # Auto-scrape tables from financial pages
        for url, data in list(fetched_final):
            if data and isinstance(data, dict):
                url_lower = url.lower()
                if any(w in url_lower for w in ["investor", "earnings", "financial", "quarterly"]):
                    tables = cf_scrape(url, ["table"])
                    if tables:
                        table_texts = []
                        for sel in tables:
                            sel_results = sel.get("results", [])
                            if isinstance(sel_results, list):
                                for t in sel_results:
                                    if t.get("text", "").strip():
                                        table_texts.append(t["text"].strip())
                            elif isinstance(sel_results, dict) and sel_results.get("text", "").strip():
                                table_texts.append(sel_results["text"].strip())
                        if table_texts:
                            combined = "\n\n".join(table_texts)[:3000]
                            fetched_final.append((url + "#tables", f"Financial tables scraped from page:\n{combined}"))
                            print(f"    [Scrape] Extracted {len(table_texts)} tables from {url[:60]}")

        # Format documents
        formatted_docs = format_documents(results[:5], fetched_final, chat_id)

        # Inject results using exact Search-R1 training format
        prompt += SEARCH_RESULT_TEMPLATE.format(output_text=output_text, search_results=formatted_docs)
        continue

    # Exhausted max turns — send whatever we have
    print(f"  === MAX TURNS REACHED ({MAX_SEARCH_TURNS}) ===")
    answer = extract_between(output_text, "<answer>", "</answer>")
    if not answer:
        answer = re.sub(r'<think>.*?</think>', '', output_text, flags=re.DOTALL).strip()
    if not answer:
        answer = "I searched extensively but couldn't find a definitive answer. Please try a more specific question."
    print(f"\n{'='*60}\nANSWER:\n{'='*60}\n{answer}\n{'='*60}")
    send_status(chat_id, answer)
    os.makedirs("/outputs", exist_ok=True)
    with open(f"/outputs/{output_file}", "w", encoding="utf-8") as f:
        f.write(answer)


# =============================================================================
# Main — Production (single question from Telegram)
# =============================================================================

print("=== LOADING MODEL ===")
model, tokenizer = load_model()
print(f"Model loaded: {MODEL_NAME}")

try:
    research(PROMPT, chat_id, model, tokenizer, output_file="response.txt")
finally:
    print("=== CLEANUP ===")
    del model, tokenizer
    torch.cuda.empty_cache()
    print("Done.")

# CALLER SENDS:
# {"toolId": "abc123", "inputs": {"text": "hello world", "language": "Spanish", "max_words": 100}}

# YOUR CODE RECEIVES (injected automatically):
text = "hello world"         # from inputs.text
language = "Spanish"          # from inputs.language
max_words = 100               # from inputs.max_words

# YOUR CODE DOES WHATEVER YOU WANT:
result = llm.generate([f"In {language}, summarize in under {max_words} words: {text}"], params)

# WHAT GOES BACK TO THE CALLER:
import seqpu_sdk as seqpu
seqpu.result(result[0].outputs[0].text)   # → response["result"] (any size)
print("working...")                # → response["output"] — logs, NOT the return

# IF YOU SAVE FILES:
image.save("/outputs/chart.png")    # → response["files"], each with a public url

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)

# These variables come from the caller's JSON
# text = "..." (the caller fills this in)
# target_language = "..." (the caller fills this in)
# formality = "..." (optional, defaults to "neutral")

prompt = f"Translate to {target_language} in a {formality} tone:\n{text}"
result = llm.generate([prompt], params)
print(result[0].outputs[0].text)

# Add these test values at the top to test in the notebook
text = "The quarterly report shows strong growth in all segments."
target_language = "Spanish"
formality = "formal"

# ... rest of your code below ...
# When it works: remove these 3 lines and publish.
# The publish system will inject the real values from callers.

Input 1:  id="text"             type=string   required=yes   description="The text to translate"
Input 2:  id="target_language"  type=string   required=yes   description="Language code: es, fr, ja, de, zh"
Input 3:  id="formality"        type=string   required=no    description="Tone: formal, neutral, casual (default: neutral)"

Output 1: id="translation"   type=string   description="The translated text"

curl -X POST https://api.seqpu.com/v1/tools/execute \
  -H "CF-Access-Client-Id: YOUR_CLIENT_ID" \
  -H "CF-Access-Client-Secret: YOUR_CLIENT_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"toolId": "your-tool-id", "inputs": {"prompt": "Summarize this document"}}'

import requests

response = requests.post(
    "https://api.seqpu.com/v1/tools/execute",
    headers={
        "CF-Access-Client-Id": "YOUR_CLIENT_ID",
        "CF-Access-Client-Secret": "YOUR_CLIENT_SECRET",
        "Content-Type": "application/json",
    },
    json={
        "toolId": "your-tool-id",
        "inputs": {"prompt": "Summarize this document"}
    }
)
print(response.json())

const response = await fetch('https://api.seqpu.com/v1/tools/execute', {
  method: 'POST',
  headers: {
    'CF-Access-Client-Id': 'YOUR_CLIENT_ID',
    'CF-Access-Client-Secret': 'YOUR_CLIENT_SECRET',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    toolId: 'your-tool-id',
    inputs: { prompt: 'Summarize this document' }
  })
});
const data = await response.json();
console.log(data.result);   // the tool's seqpu.result() value

import seqpu

# Inside SeqPU, authentication is automatic
result = seqpu.tools.call("your-tool-id", {"prompt": "Summarize this"})
print(result)

from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-14B")
import seqpu_sdk as seqpu
result = llm.generate([f"Summarize in 5 bullet points:\n{document}"], SamplingParams(max_tokens=1024))
seqpu.result(result[0].outputs[0].text)
# Caller sends: {"inputs": {"document": "long text..."}}
# Caller gets: {"result": "• Point 1\n• Point 2..."}

from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-14B")
# formality defaults to "neutral" if not sent
tone = formality if formality else "neutral"
import seqpu_sdk as seqpu
result = llm.generate([f"Translate to {target_language} in a {tone} tone:\n{text}"], SamplingParams(max_tokens=1024))
seqpu.result(result[0].outputs[0].text)
# Caller sends: {"inputs": {"text": "Hello world", "target_language": "ja"}}
# Caller gets: {"result": "こんにちは世界"}

import base64, json
from pathlib import Path
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from PIL import Image

# Decode the uploaded image
Path("/data/receipt.jpg").write_bytes(base64.b64decode(receipt_image))

model = Qwen2_5_VLForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")
img = Image.open("/data/receipt.jpg")
inputs = processor(images=img, text="Extract vendor, date, line items, and total as JSON", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=512)
import seqpu_sdk as seqpu, json
seqpu.result(json.loads(processor.decode(output[0], skip_special_tokens=True)))
# Caller sends: {"inputs": {"receipt_image": "base64string..."}}
# Caller gets: {"result": {"vendor": "Costco", "total": 142.50, ...}}

from diffusers import StableDiffusionXLPipeline
import torch
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16).to("cuda")
image = pipe(description).images[0]
image.save("/outputs/generated.png")
print("Image generated")
# Caller sends: {"inputs": {"description": "a cat wearing a tiny hat"}}
# Caller gets: {"outputs": {"generated.png": {"url": "https://...", "contentType": "image/png"}}}

import pandas as pd
from io import StringIO
df = pd.read_csv(StringIO(csv_data))
stats = df[column].describe().to_string()
print(f"Stats for {column}:\n{stats}")
# No GPU. No model. Just pandas on CPU. $0.00003 per call.

from vllm import LLM, SamplingParams
import seqpu
llm = LLM(model="Qwen/Qwen3-14B")
result = llm.generate([task], SamplingParams(max_tokens=1024))
seqpu.notify(result[0].outputs[0].text, chat_id=telegram_chat_id, platform="telegram")
# This is what your Telegram bot calls. Same API. Same flow.

<!-- Add this button anywhere on your existing site -->
<textarea id="input" placeholder="Paste text here..."></textarea>
<button onclick="callSeqPU()">Summarize</button>
<div id="result"></div>

<script>
async function callSeqPU() {
  const text = document.getElementById('input').value;
  const resp = await fetch('https://api.seqpu.com/v1/tools/execute', {
    method: 'POST',
    headers: {'Authorization': 'Bearer YOUR_TOKEN', 'Content-Type': 'application/json'},
    body: JSON.stringify({toolId: 'your-tool-id', inputs: {document: text}})
  });
  const data = await resp.json();
  document.getElementById('result').innerText = data.result;
}
</script>

import seqpu

# Step 1: Extract text from PDF (CPU, $0.00003)
extracted = seqpu.tools.call("pdf-extractor", {"file": pdf_data})

# Step 2: Analyze with large model (A100 80GB, $0.006)
analysis = seqpu.tools.call("deep-analyzer", {"text": extracted["content"]})

# Step 3: Generate report (T4, $0.001)
report = seqpu.tools.call("report-writer", {"analysis": analysis["insights"]})
print(report)

<!-- data-seqpu-input="variable_name" → becomes a Python variable -->
<textarea data-seqpu-input="document" placeholder="Paste your document here..."></textarea>

<select data-seqpu-input="style">
  <option value="bullets">Bullet Points</option>
  <option value="paragraph">Paragraph</option>
  <option value="executive">Executive Summary</option>
</select>

<!-- data-seqpu-generate → the Run button -->
<button data-seqpu-generate>Summarize</button>

<!-- data-seqpu-output="id" → results appear here -->
<div data-seqpu-output="result"></div>

from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)

# "document" and "style" come from the HTML form
result = llm.generate([f"Write a {style} summary:\n{document}"], params)
print(result[0].outputs[0].text)
# print() output appears in the data-seqpu-output="result" div

<div class="tool">
  <h1>Instant Translation</h1>
  <p class="subtitle">Professional translation in 8 languages. Powered by AI.</p>

  <label>Your Text</label>
  <textarea data-seqpu-input="text" rows="6"
    placeholder="Paste the text you want to translate..."></textarea>

  <div style="display:flex;gap:1rem;margin-top:1rem">
    <div style="flex:1">
      <label>Translate to</label>
      <select data-seqpu-input="target_language">
        <option value="es">Spanish</option>
        <option value="fr">French</option>
        <option value="ja">Japanese</option>
        <option value="de">German</option>
        <option value="zh">Chinese</option>
        <option value="pt">Portuguese</option>
        <option value="ko">Korean</option>
        <option value="ar">Arabic</option>
      </select>
    </div>
    <div style="flex:1">
      <label>Tone</label>
      <select data-seqpu-input="formality">
        <option value="neutral">Neutral</option>
        <option value="formal">Formal</option>
        <option value="casual">Casual</option>
      </select>
    </div>
  </div>

  <button data-seqpu-generate class="btn">Translate</button>

  <label>Translation</label>
  <div data-seqpu-output="result" class="output"></div>
</div>

.tool { max-width:680px; margin:0 auto; padding:2rem; font-family:'Inter',sans-serif; color:#f0f0f0; }
h1 { font-size:28px; margin-bottom:.5rem; }
.subtitle { color:#888; margin-bottom:2rem; }
label { display:block; font-size:12px; font-weight:600; color:#aaa; margin:1rem 0 .5rem;
  text-transform:uppercase; letter-spacing:.05em; }
textarea, select { width:100%; padding:12px; background:#1a1a1a; border:1px solid #333;
  color:#f0f0f0; border-radius:6px; font-size:15px; }
textarea:focus, select:focus { border-color:#5eead4; outline:none; }
.btn { width:100%; padding:14px; margin-top:1.5rem; background:#5eead4; color:#000;
  border:none; border-radius:6px; font-size:16px; font-weight:700; cursor:pointer;
  text-transform:uppercase; letter-spacing:.1em; }
.btn:hover { opacity:.9; }
.output { background:#1a1a1a; border:1px solid #333; border-radius:6px;
  padding:16px; min-height:100px; white-space:pre-wrap; line-height:1.6; }

from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-14B")
# formality defaults to "neutral" if not sent
tone = formality if formality else "neutral"
result = llm.generate([f"Translate to {target_language} in a {tone} tone:\n{text}"], SamplingParams(max_tokens=1024))
print(result[0].outputs[0].text)

<div class="tool">
  <h1>AI Image Studio</h1>
  <p class="subtitle">Describe what you want. Get professional images in seconds.</p>

  <label>Describe your image</label>
  <textarea data-seqpu-input="description" rows="3"
    placeholder="e.g. product photo of handmade soap on marble, soft natural lighting, minimal background"></textarea>

  <div style="display:flex;gap:1rem;margin-top:1rem">
    <div style="flex:1">
      <label>Style</label>
      <select data-seqpu-input="style_preset">
        <option value="photorealistic">Photorealistic</option>
        <option value="digital art">Digital Art</option>
        <option value="watercolor painting">Watercolor</option>
        <option value="anime illustration">Anime</option>
        <option value="3d render">3D Render</option>
        <option value="oil painting">Oil Painting</option>
      </select>
    </div>
    <div style="flex:1">
      <label>Number of images</label>
      <input type="range" data-seqpu-input="count" min="1" max="4" value="2">
    </div>
  </div>

  <button data-seqpu-generate class="btn">Generate Images</button>

  <div data-seqpu-output="images" class="gallery"></div>
</div>

from diffusers import StableDiffusionXLPipeline
import torch
pipe = StableDiffusionXLPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16).to("cuda")
for i in range(int(count)):
    image = pipe(description, num_inference_steps=25).images[0]
    image.save(f"/outputs/image_{i+1}.png")
print(f"Generated {count} images")

<div class="tool">
  <h1>Receipt Scanner</h1>
  <p class="subtitle">Drop a receipt photo. Get structured data back instantly.</p>

  <div class="upload-zone">
    <input type="file" data-seqpu-input="receipt_image" accept="image/*">
    <p>Drop receipt image here or click to browse</p>
  </div>

  <button data-seqpu-generate class="btn">Scan Receipt</button>

  <label>Extracted Data</label>
  <div data-seqpu-output="extracted_data" class="output"></div>
</div>

import base64
from pathlib import Path
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from PIL import Image
Path("/data/receipt.jpg").write_bytes(base64.b64decode(receipt_image))
model = Qwen2_5_VLForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")
img = Image.open("/data/receipt.jpg")
inputs = processor(images=img, text="Extract vendor, date, every line item, and total as JSON", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(output[0], skip_special_tokens=True))

<div class="tool">
  <h1>Code Review AI</h1>
  <p class="subtitle">Paste your code. Get a professional review in seconds.</p>

  <label>Your Code</label>
  <textarea data-seqpu-input="code" rows="12"
    style="font-family:'Space Mono',monospace;font-size:13px"
    placeholder="Paste your code here..."></textarea>

  <div style="display:flex;gap:1rem;margin-top:1rem">
    <div style="flex:1">
      <label>Language</label>
      <select data-seqpu-input="language">
        <option value="python">Python</option>
        <option value="javascript">JavaScript</option>
        <option value="typescript">TypeScript</option>
        <option value="go">Go</option>
        <option value="rust">Rust</option>
        <option value="java">Java</option>
      </select>
    </div>
    <div style="flex:1">
      <label>Focus</label>
      <select data-seqpu-input="focus">
        <option value="security">Security Issues</option>
        <option value="performance">Performance</option>
        <option value="readability">Readability</option>
        <option value="all">Everything</option>
      </select>
    </div>
  </div>

  <button data-seqpu-generate class="btn">Review Code</button>

  <label>Review</label>
  <div data-seqpu-output="review" class="output"></div>
</div>

from anthropic import Anthropic
import os
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
response = client.messages.create(
    model="claude-sonnet-4-20250514", max_tokens=2048,
    messages=[{"role": "user", "content": f"Review this {language} code for {focus} issues. Be specific. Cite line numbers.\n\n{code}"}]
)
print(response.content[0].text)

<div class="tool">
  <h1>Meeting Transcriber</h1>
  <p class="subtitle">Upload a recording. Get transcript + action items in 60 seconds.</p>

  <div class="upload-zone">
    <input type="file" data-seqpu-input="audio_file" accept="audio/*">
    <p>Drop audio file here (MP3, WAV, M4A)</p>
  </div>

  <button data-seqpu-generate class="btn">Transcribe & Summarize</button>

  <label>Results</label>
  <div data-seqpu-output="result" class="output"></div>
</div>

import whisper, base64
from pathlib import Path
from vllm import LLM, SamplingParams
Path("/data/audio.mp3").write_bytes(base64.b64decode(audio_file))
model = whisper.load_model("large-v3")
transcript = model.transcribe("/data/audio.mp3")["text"]
llm = LLM(model="Qwen/Qwen3-14B")
result = llm.generate([f"Extract action items, decisions, and follow-ups:\n{transcript}"], SamplingParams(max_tokens=1024))
print(f"TRANSCRIPT:\n{transcript}\n\nACTION ITEMS:\n{result[0].outputs[0].text}")

<div class="tool">
  <h1>Social Media Copy Generator</h1>
  <p class="subtitle">Upload a product photo. Get ready-to-post content for every platform.</p>

  <div class="upload-zone">
    <input type="file" data-seqpu-input="product_photo" accept="image/*">
    <p>Drop product photo here</p>
  </div>

  <label>Product Name</label>
  <input type="text" data-seqpu-input="product_name"
    placeholder="e.g. Lavender Honey Soap, Handmade Leather Wallet...">

  <button data-seqpu-generate class="btn">Generate Copy</button>

  <label>Your Marketing Copy</label>
  <div data-seqpu-output="copy" class="output"></div>
</div>

import base64
from pathlib import Path
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from PIL import Image
Path("/data/product.jpg").write_bytes(base64.b64decode(product_photo))
model = Qwen2_5_VLForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")
img = Image.open("/data/product.jpg")
inputs = processor(images=img, text=f"Product: {product_name}. Write 3 Instagram captions with hashtags, 2 tweets, 1 LinkedIn post, and an SEO product description.", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=1024)
print(processor.decode(output[0], skip_special_tokens=True))

<div class="tool">
  <h1>Sketch to Art</h1>
  <p class="subtitle">Draw anything. AI turns it into a masterpiece.</p>

  <label>Draw your sketch</label>
  <canvas data-seqpu-input="sketch" width="512" height="512"
    style="border:1px solid #333;border-radius:6px;cursor:crosshair"></canvas>

  <label>Art Style</label>
  <select data-seqpu-input="style">
    <option value="watercolor painting">Watercolor</option>
    <option value="digital art">Digital Art</option>
    <option value="oil painting">Oil Painting</option>
    <option value="anime illustration">Anime</option>
    <option value="pencil sketch refined">Refined Pencil</option>
    <option value="children's book illustration">Children's Book</option>
  </select>

  <button data-seqpu-generate class="btn">Transform My Sketch</button>

  <label>Your Illustration</label>
  <div data-seqpu-output="illustration"></div>
</div>

import base64
from pathlib import Path
from diffusers import StableDiffusionXLImg2ImgPipeline
import torch
from PIL import Image
Path("/data/sketch.png").write_bytes(base64.b64decode(sketch))
init_image = Image.open("/data/sketch.png").resize((1024, 1024))
pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16).to("cuda")
result = pipe(prompt=f"{style} illustration based on this sketch", image=init_image, strength=0.75).images[0]
result.save("/outputs/illustration.png")
print("Illustration generated")

import seqpu, requests, os
from anthropic import Anthropic

# Everything runs on CPU — no GPU, no model loading
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

# Step 1: Check inventory API
inventory = requests.get("https://api.mystore.com/inventory",
    headers={"Authorization": f"Bearer {os.environ['STORE_KEY']}"}).json()

# Step 2: Ask Claude to analyze
low_items = [i for i in inventory if i["quantity"] < 10]
response = client.messages.create(
    model="claude-sonnet-4-20250514", max_tokens=1024,
    messages=[{"role": "user", "content": f"Write a reorder report for these low-stock items:\n{low_items}"}]
)

# Step 3: Send to Telegram
seqpu.notify(response.content[0].text, chat_id="123456", platform="telegram")
# Cost: ~$0.00003 for SeqPU compute + Claude API cost. No GPU.

import seqpu

seqpu.run(code, gpu)           # Spawn a job on any GPU
seqpu.tools.call(id, inputs)   # Call a published tool
seqpu.tools.list()             # List your published tools
seqpu.notify(msg, chat_id)     # Send message to Telegram/Discord/Slack/WhatsApp
seqpu.notify_file(...)         # Send a file to chat
seqpu.credits.balance()        # Check your credit balance
seqpu.gpu.pricing()            # Get current GPU pricing
seqpu.snapshot.create(...)     # Create a StateSave environment
seqpu.agent.loop(...)          # Run an agentic tool-calling loop

import seqpu
from pathlib import Path

# This notebook runs on CPU ($0.047/hr)
# Heavy inference dispatched to A100 only when needed

tasks = ["Summarize this report", "Translate to Spanish", "Extract action items"]

for task in tasks:
    result = seqpu.run(f"""
from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-14B")
result = llm.generate(["{task}"], SamplingParams(max_tokens=512))
print(result[0].outputs[0].text)
""", gpu="a100-80gb")
    print(f"Done: {task}")

import seqpu

# Each tool is a published notebook running on its own GPU
raw_text = seqpu.tools.call("pdf-extractor", {"url": "https://example.com/report.pdf"})
summary = seqpu.tools.call("summarizer-32b", {"text": raw_text["content"]})
translated = seqpu.tools.call("translator", {"text": summary["summary"], "lang": "ja"})

print(f"Japanese summary: {translated['result']}")

import seqpu, base64

# Send a text message
seqpu.notify(
    "Daily report complete. Revenue: $42,150 (+8.3%)",
    chat_id="123456789",
    platform="telegram"
)

# Send a file (chart, PDF, image)
with open("/data/chart.png", "rb") as f:
    seqpu.notify_file(
        base64.b64encode(f.read()).decode(),
        "image/png", "daily_chart.png",
        chat_id="123456789",
        caption="Revenue trend — last 30 days"
    )

import seqpu
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-32B-Instruct", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-32B-Instruct")

# Get your published tools as callable definitions
tools = seqpu.agent.get_tool_definitions(format="qwen")

# The agent decides which tools to call and in what order
response = seqpu.agent.loop(
    model=model, tokenizer=tokenizer,
    messages=[{"role": "user", "content": "Research NVIDIA's Q4 earnings"}],
    tools=tools, max_iterations=10
)
print(response)

# Runs every morning at 7am automatically
from vllm import LLM, SamplingParams
from pathlib import Path

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)
emails = Path("/data/inbox").read_text()
result = llm.generate([f"Extract action items:\n{emails}"], params)
Path("/data/output/digest.txt").write_text(result[0].outputs[0].text)

import seqpu, requests

# Checks every 15 minutes, alerts if threshold breached
prices = requests.get("https://api.example.com/prices").json()

for item in prices:
    if item["price"] < item["alert_threshold"]:
        seqpu.notify(
            f"PRICE ALERT: {item['name']} dropped to ${item['price']}",
            chat_id="123456789", platform="telegram"
        )

import seqpu

# Stage 1: Small model classifies (T4, $0.59/hr — fractions of a cent)
classification = seqpu.run("""
from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-4B")
result = llm.generate(["Classify as urgent/normal/spam: " + message],
    SamplingParams(max_tokens=10))
print(result[0].outputs[0].text)
""", gpu="t4")

# Stage 2: Only if urgent — large model responds (A100, $2.50/hr)
if "urgent" in classification.lower():
    response = seqpu.run("""
from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen3-32B")
result = llm.generate(["Draft an urgent response to: " + message],
    SamplingParams(max_tokens=1024))
print(result[0].outputs[0].text)
""", gpu="a100-80gb")

    # Stage 3: Notify on Telegram
    seqpu.notify(f"Urgent handled: {response[:200]}", chat_id="123456789")

from vllm import LLM, SamplingParams
import seqpu
from pathlib import Path

llm = LLM(model="Qwen/Qwen3-14B")
params = SamplingParams(max_tokens=1024)

for doc in Path("/data/inbox").glob("*.txt"):
    text = doc.read_text()
    result = llm.generate([f"Classify as urgent/normal/spam and draft a response:\n{text}"], params)
    response = result[0].outputs[0].text
    if "urgent" in response.lower():
        seqpu.notify(f"URGENT: {doc.name}\n{response}", chat_id="123456", platform="telegram")
    Path(f"/data/processed/{doc.name}").write_text(response)
print("All documents processed")

import seqpu

# This orchestrator runs on CPU ($0.047/hr)
# Each tool was published separately — 10 lines each, click Publish

# Step 1: Classify the request (3B on T4, $0.0002)
category = seqpu.tools.call("classifier-id", {"text": task})

# Step 2: Route to the right specialist
if category["result"] == "billing":
    response = seqpu.tools.call("billing-agent", {"question": task})      # 7B on T4, $0.0003
elif category["result"] == "technical":
    response = seqpu.tools.call("tech-support", {"question": task})       # 14B on A100, $0.005
else:
    response = seqpu.tools.call("general-agent", {"question": task})       # 7B on T4, $0.0003

# Step 3: Send back via Telegram
seqpu.notify(response["answer"], chat_id=telegram_chat_id, platform="telegram")