""" BeamBridge Live Beam-1.0-501B-A23B Multi-Provider Client & Sovereign FinOps Router. Supports: 1. OpenRouter (`https://openrouter.ai/api/v1` — `reflection/beam-1.0-501b-a23b` + automatic FinOps Failover) 2. Reflection AI Official API (`https://api.reflection.ai/v1` — `Beam-1.0-501B-A23B`) 3. Hugging Face Inference Router (`https://router.huggingface.co/v1` — `reflection/Beam-1.0-501B-A23B`) 4. Sovereign On-Prem vLLM / SGLang (`--reasoning-parser beam`) When invoked without an API key, replays the genuine cryptographically audited OpenRouter `gen-...` execution record and real synthesized `MCPServer` code from `runs/verifiable_empirical_ledger.json`. """ from __future__ import annotations import os import time from pathlib import Path from typing import Any import httpx from backend.ast_analyzer import pack_whole_repository_prompt from backend.parity_verifier import get_empirical_ledger from backend.real_oracles import exact_beam_token_count BASE_DIR = Path(__file__).resolve().parent.parent PROVIDER_DEFAULTS: dict[str, tuple[str, str]] = { "openrouter": ("https://openrouter.ai/api/v1", "reflection/beam-1.0-501b-a23b"), "reflection": ("https://api.reflection.ai/v1", "Beam-1.0-501B-A23B"), "huggingface": ("https://router.huggingface.co/v1", "reflection/Beam-1.0-501B-A23B"), "vllm_local": ("http://127.0.0.1:8000/v1", "reflection/Beam-1.0-501B-A23B"), } async def synthesize_with_beam( repo_id: str, api_key: str | None = None, provider: str = "openrouter", custom_base_url: str | None = None, reasoning_effort: str = "medium", preserve_thinking: bool = True, user_directive: str | None = None, ) -> dict[str, Any]: resolved_key = ( (api_key or "").strip() or os.getenv("OPENROUTER_API_KEY", "").strip() or os.getenv("REFLECTION_API_KEY", "").strip() or os.getenv("HF_TOKEN", "").strip() ) packed_repo = pack_whole_repository_prompt(repo_id) mcp_source_path = BASE_DIR / "modernized_mcp" / f"{repo_id}_mcp.py" verified_mcp_code = mcp_source_path.read_text(encoding="utf-8") if mcp_source_path.exists() else "" if not resolved_key and provider != "vllm_local": ledger = get_empirical_ledger() repo_rec = ledger["repositories"][repo_id] wr = repo_rec["whole_repo_1m"] last_turn = wr["turns"][-1] all_req_ids = [t["request_id"] for t in wr["turns"]] combined_reasoning = "\n\n---\n\n".join( f"[Turn {t['turn']} · {t['model']} · {t['request_id']} · {t['passed']}/{t['total']} ({t['pass_rate_pct']}%)]\n{t['reasoning_excerpt']}" for t in wr["turns"] if t.get("reasoning_excerpt") ) return { "mode": "recorded_verifiable_openrouter_run", "provider": last_turn.get("provider", "OpenRouter"), "model": last_turn["model"], "request_ids": all_req_ids, "reasoning_effort": reasoning_effort, "preserve_thinking": preserve_thinking, "latency_ms": wr["total_latency_ms"], "usage": { "prompt_tokens": wr["total_prompt_tokens"], "completion_tokens": wr["total_completion_tokens"], "reasoning_tokens": wr["total_reasoning_tokens"], "total_tokens": wr["total_prompt_tokens"] + wr["total_completion_tokens"], "cost_usd": wr["total_cost_usd"], }, "turns_executed": len(wr["turns"]), "verified_parity": f"{wr['final_passed']}/{wr['final_total']} ({wr['final_pass_rate_pct']}%)", "reasoning_content": combined_reasoning or "Verified multi-turn synthesis trace recorded in empirical ledger.", "synthesized_code": verified_mcp_code, } base_url, model_name = PROVIDER_DEFAULTS.get(provider, PROVIDER_DEFAULTS["openrouter"]) if custom_base_url: base_url = custom_base_url.rstrip("/") directive = user_directive or ( "Synthesize a standalone Anthropic MCP v2 server (`from mcp.server.mcpserver import MCPServer`) " "preserving exact Decimal quantization, check-digit tables, and structured dict schemas." ) payload: dict[str, Any] = { "model": model_name, "messages": [ { "role": "system", "content": ( "You are BeamBridge, powered by Reflection AI's Beam-1.0-501B-A23B (501B total, 23B active MoE, " "1,048,576 context window). Analyze the full repository context and synthesize a standalone " "Python MCP v2 module (`from mcp.server.mcpserver import MCPServer`) with zero legacy imports." ), }, { "role": "user", "content": f"{directive}\n\n{packed_repo}", }, ], "temperature": 0.15, "max_tokens": 4096, } if provider == "openrouter": payload["reasoning"] = {"effort": reasoning_effort if reasoning_effort in ("minimal", "low", "medium", "high") else "low"} else: payload["reasoning_effort"] = reasoning_effort payload["chat_template_kwargs"] = { "reasoning_effort": reasoning_effort, "preserve_thinking": preserve_thinking, } headers = {"Content-Type": "application/json"} if resolved_key: headers["Authorization"] = f"Bearer {resolved_key}" if provider == "openrouter": headers["HTTP-Referer"] = "https://huggingface.co/spaces/BeamBridge" headers["X-Title"] = "BeamBridge-Enterprise-MCP" t0 = time.perf_counter() async with httpx.AsyncClient(timeout=180.0) as client: resp = await client.post(f"{base_url}/chat/completions", headers=headers, json=payload) if resp.status_code == 402 and provider == "openrouter": payload["model"] = "nvidia/nemotron-3-ultra-550b-a55b:free" payload.pop("reasoning", None) payload["max_tokens"] = 8192 resp = await client.post(f"{base_url}/chat/completions", headers=headers, json=payload) latency_ms = round((time.perf_counter() - t0) * 1000.0, 1) if resp.status_code >= 400: return { "mode": "live_api_error", "status_code": resp.status_code, "error": resp.text[:600], "provider": provider, "model": payload["model"], } body = resp.json() choice = (body.get("choices") or [{}])[0] msg = choice.get("message") or {} usage = body.get("usage") or {} comp_details = usage.get("completion_tokens_details") or {} content = msg.get("content") or "" reasoning_text = msg.get("reasoning") or msg.get("reasoning_content") or "" return { "mode": "live_beam_api", "provider": body.get("provider", provider), "model": body.get("model", payload["model"]), "request_ids": [body.get("id")], "reasoning_effort": reasoning_effort, "preserve_thinking": preserve_thinking, "latency_ms": latency_ms, "usage": { "prompt_tokens": usage.get("prompt_tokens", exact_beam_token_count(packed_repo)), "completion_tokens": usage.get("completion_tokens", exact_beam_token_count(content)), "reasoning_tokens": comp_details.get("reasoning_tokens", exact_beam_token_count(reasoning_text)), "total_tokens": usage.get("total_tokens", 0), "cost_usd": usage.get("cost", 0.0), }, "reasoning_content": reasoning_text, "synthesized_code": content, }