Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust
5.5 KB
Raw Blame
# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0

"""Search pipeline configuration: step order, state model, and search-specific constants."""

from __future__ import annotations

import json
import os
from dataclasses import asdict, dataclass, field
from datetime import datetime

# ---------------------------------------------------------------------------
# Search-specific constants (overridable via PipelineProfile)
# ---------------------------------------------------------------------------

CODEX_MODEL = "openai/openai/gpt-5.3-codex"
DEDUP_THRESHOLD = 0.65
DEDUP_EMBEDDING_MODEL = "openai/azure/openai/text-embedding-3-small"
REJECT_THRESHOLD = 0.3  # both Opus + Codex <= this → reject
HAIKU_INVERSION_MARGIN = 0.1  # haiku must beat opus by more than this to trigger
HAIKU_INVERSION_FLOOR = 0.5  # and haiku must actually perform (>= this) — not just non-zero noise
REPO_MAP_MAX_CHARS = 120_000  # character budget for build_repo_map output
SYNTHESIS_CONCURRENCY = 5

# LiteLLM model names for 3-model synthesis
SYNTHESIS_MODELS = [
    "openai/aws/anthropic/bedrock-claude-sonnet-4-6",
    "openai/gcp/google/gemini-3.1-pro-preview",
    "openai/us/azure/openai/gpt-5.4",
]
JUDGE_MODEL = "openai/aws/anthropic/bedrock-claude-sonnet-4-6"


# ---------------------------------------------------------------------------
# Step order
# ---------------------------------------------------------------------------

SEARCH_STEPS = [
    "extract",
    "synthesize",
    "validate",
    "dedup",
    "harbor",
    "smoke-all",
    "gold-review",
    "filter",
    "report",
]


# ---------------------------------------------------------------------------
# Shared utilities
# ---------------------------------------------------------------------------

APPROACHES = ["a", "b", "c"]


def load_approach_tasks(output_dir: str) -> list[dict]:
    """Load all search tasks across approach-{a,b,c}/search_tasks.json."""
    all_tasks: list[dict] = []
    for approach in APPROACHES:
        path = os.path.join(output_dir, f"approach-{approach}", "search_tasks.json")
        if not os.path.exists(path):
            continue
        with open(path) as f:
            all_tasks.extend(json.load(f))
    return all_tasks


# ---------------------------------------------------------------------------
# State model
# ---------------------------------------------------------------------------


@dataclass
class SearchTaskStatus:
    """Per-task agent scores and filter result."""

    opus_reward: float | None = None
    opus_nav: float | None = None
    opus_assert: float | None = None
    opus_file_recall: float | None = None
    opus_func_recall: float | None = None

    codex_reward: float | None = None
    codex_nav: float | None = None
    codex_assert: float | None = None
    codex_file_recall: float | None = None
    codex_func_recall: float | None = None

    haiku_reward: float | None = None
    haiku_nav: float | None = None
    haiku_assert: float | None = None
    haiku_file_recall: float | None = None
    haiku_func_recall: float | None = None

    review_recommendation: str = ""
    review_flags: list[str] = field(default_factory=list)

    status: str = ""  # accepted / rejected / flagged
    flags: list[str] = field(default_factory=list)


@dataclass
class SearchPipelineState:
    """State for the search-from-T2 pipeline."""

    created: str = ""
    last_updated: str = ""
    run_dir: str = ""
    profile_data: dict = field(default_factory=dict)

    # Pipeline progress
    stages_completed: list[str] = field(default_factory=list)
    current_stage: str = ""

    # Config (populated at start, persisted for resume)
    tasks_dir: str = ""
    repos_dir: str = ""
    output_dir: str = ""
    harbor_dir: str = ""
    limit: int = 0  # limit number of input tasks to process (0 = all)
    concurrency: int = 4

    # Job directories from agent smoke runs
    job_dirs: dict[str, str] = field(default_factory=dict)

    # Per-task statuses (task_id -> scores + filter result)
    task_statuses: dict[str, SearchTaskStatus] = field(default_factory=dict)

    def save(self, path: str) -> None:
        self.last_updated = datetime.now().isoformat()
        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
        with open(path, "w") as f:
            json.dump(asdict(self), f, indent=2, default=str)

    @classmethod
    def load(cls, path: str) -> SearchPipelineState:
        with open(path) as f:
            data = json.load(f)
        state = cls(
            created=data.get("created", ""),
            last_updated=data.get("last_updated", ""),
            run_dir=data.get("run_dir", ""),
            profile_data=data.get("profile_data", {}),
            stages_completed=data.get("stages_completed", []),
            current_stage=data.get("current_stage", ""),
            tasks_dir=data.get("tasks_dir", data.get("t2_tasks_dir", "")),
            repos_dir=data.get("repos_dir", ""),
            output_dir=data.get("output_dir", ""),
            harbor_dir=data.get("harbor_dir", ""),
            limit=data.get("limit", 0),
            concurrency=data.get("concurrency", 4),
            job_dirs=data.get("job_dirs", {}),
        )
        known_fields = {f.name for f in SearchTaskStatus.__dataclass_fields__.values()}
        for tid, tdata in data.get("task_statuses", {}).items():
            filtered = {k: v for k, v in tdata.items() if k in known_fields}
            state.task_statuses[tid] = SearchTaskStatus(**filtered)
        return state