adapterbridge 0.1.0__py3-none-any.whl

adapterbridge/__init__.py

@@ -0,0 +1,32 @@
+"""AdapterBridge: LoRA Checkpoint & Config Compatibility Engine for Enterprise Inference Runtimes."""
+
+__version__ = "0.1.0"
+
+from adapterbridge.models.manifest import CheckpointManifest, TensorMetadata
+from adapterbridge.models.report import (
+    IssueSeverity,
+    ValidationIssue,
+    ValidationReport,
+    RemediationAction,
+    RemediationOperation,
+    RemediationPlan,
+    VerificationResult,
+)
+from adapterbridge.models.target_spec import TargetEngine, BaseTargetProfile
+from adapterbridge.core.inspector import AdapterInspector
+
+__all__ = [
+    "AdapterInspector",
+    "CheckpointManifest",
+    "TensorMetadata",
+    "IssueSeverity",
+    "ValidationIssue",
+    "ValidationReport",
+    "RemediationAction",
+    "RemediationOperation",
+    "RemediationPlan",
+    "VerificationResult",
+    "TargetEngine",
+    "BaseTargetProfile",
+]
+

adapterbridge/cli.py

@@ -0,0 +1,143 @@
+"""CLI entry points using Typer and Rich formatting."""
+
+import json
+import os
+import sys
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from adapterbridge.core.inspector import AdapterInspector
+from adapterbridge.models.report import IssueSeverity
+
+app = typer.Typer(
+    name="adapterbridge",
+    help="AdapterBridge: LoRA Checkpoint & Config Compatibility Engine for Enterprise Inference Runtimes.",
+    add_completion=False,
+)
+
+console = Console()
+
+
+@app.command(name="check")
+def check_cmd(
+    path: str = typer.Option(..., "--path", "-p", help="Path to checkpoint directory"),
+    target: str = typer.Option(..., "--target", "-t", help="Target serving engine (vllm, sglang, ollama, tensorrt)"),
+    format: str = typer.Option("text", "--format", "-f", help="Output format: text, json, sarif, markdown, pr-comment"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Optional output file destination"),
+):
+    """Static linter and compatibility validator for LoRA checkpoints."""
+    try:
+        inspector = AdapterInspector(checkpoint_path=path, target_engine=target)
+        report = inspector.run_diagnostics()
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] {str(e)}")
+        raise typer.Exit(code=1)
+
+    if format == "json":
+        formatted_output = report.model_dump_json(indent=2)
+    elif format == "sarif":
+        formatted_output = json.dumps(report.to_sarif(), indent=2)
+    elif format == "pr-comment":
+        formatted_output = report.to_pr_comment()
+    elif format == "markdown":
+        status_str = "PASSED" if report.is_compatible else "FAILED"
+        md_lines = [
+            f"# AdapterBridge Compatibility Report",
+            f"**Checkpoint:** `{report.checkpoint_path}`  ",
+            f"**Target Engine:** `{report.target_engine}`  ",
+            f"**Status:** `{status_str}`  ",
+            "",
+            "## Diagnostic Issues",
+        ]
+        for issue in report.issues:
+            md_lines.append(f"- **[{issue.severity.value.upper()}]** `[{issue.code}]`: {issue.message}")
+        formatted_output = "\n".join(md_lines)
+    else:
+        # Rich Terminal Output
+        table = Table(title=f"AdapterBridge Diagnostic Report ({target.upper()})")
+        table.add_column("Severity", style="bold")
+        table.add_column("Code", style="cyan")
+        table.add_column("Message")
+
+        for issue in report.issues:
+            color = "red" if issue.severity == IssueSeverity.ERROR else "yellow"
+            table.add_row(f"[{color}]{issue.severity.value.upper()}[/{color}]", issue.code, issue.message)
+
+        console.print(table)
+        status_panel_style = "green" if report.is_compatible else "red"
+        console.print(Panel(report.summary, style=status_panel_style))
+        formatted_output = None
+
+    if output and formatted_output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(formatted_output)
+        console.print(f"[bold green]Report written to:[/] {output}")
+    elif formatted_output and format != "text":
+        console.print(formatted_output)
+
+    if not report.is_compatible:
+        raise typer.Exit(code=1)
+
+
+@app.command(name="fix")
+def fix_cmd(
+    src: str = typer.Option(..., "--src", "-s", help="Source checkpoint path"),
+    dst: str = typer.Option(..., "--dst", "-d", help="Destination path for repaired checkpoint"),
+    target: str = typer.Option(..., "--target", "-t", help="Target engine (vllm, sglang, ollama, tensorrt)"),
+    base_model: Optional[str] = typer.Option(None, "--base-model", "-b", help="Fallback base model ID"),
+):
+    """Automated normalizer & metadata synthesizer for LoRA checkpoints."""
+    try:
+        inspector = AdapterInspector(checkpoint_path=src, target_engine=target)
+        console.print(f"[bold blue]Analyzing source checkpoint:[/] {src}")
+        plan = inspector.auto_repair(destination_path=dst, fallback_base_model=base_model)
+        
+        console.print(f"[bold green]Repaired checkpoint saved to:[/] {plan.output_path}")
+        console.print(f"Executed {len(plan.operations)} remediation operation(s).")
+    except Exception as e:
+        console.print(f"[bold red]Remediation Error:[/] {str(e)}")
+        raise typer.Exit(code=1)
+
+
+@app.command(name="verify")
+def verify_cmd(
+    path: str = typer.Option(..., "--path", "-p", help="Path to checkpoint directory"),
+    target: str = typer.Option(..., "--target", "-t", help="Target engine"),
+    tensor_parallel_size: int = typer.Option(1, "--tensor-parallel-size", "-tp", help="Tensor Parallelism degree"),
+):
+    """Zero-GPU mock serving dry-run engine."""
+    try:
+        inspector = AdapterInspector(checkpoint_path=path, target_engine=target)
+        res = inspector.verify_dry_run(tensor_parallel_size=tensor_parallel_size)
+        
+        if res.success:
+            console.print(Panel(f"SUCCESS: {res.reason}\nEstimated Adapter RAM: {res.memory_estimate_mb} MB", style="green"))
+        else:
+            console.print(Panel(f"FAILURE: {res.reason}\nIssues: {res.sharding_issues}", style="red"))
+            raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[bold red]Verification Error:[/] {str(e)}")
+        raise typer.Exit(code=1)
+
+
+@app.command(name="export")
+def export_cmd(
+    path: str = typer.Option(..., "--path", "-p", help="Path to checkpoint directory"),
+    target: str = typer.Option(..., "--target", "-t", help="Target engine"),
+    output: str = typer.Option(..., "--output", "-o", help="Export target destination directory"),
+):
+    """Serving-targeted bundler."""
+    try:
+        inspector = AdapterInspector(checkpoint_path=path, target_engine=target)
+        plan = inspector.auto_repair(destination_path=output)
+        console.print(f"[bold green]Successfully exported checkpoint bundle to:[/] {output}")
+    except Exception as e:
+        console.print(f"[bold red]Export Error:[/] {str(e)}")
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

adapterbridge/core/__init__.py

@@ -0,0 +1,16 @@
+"""Core subsystems package exports."""
+
+from adapterbridge.core.inspector import AdapterInspector
+from adapterbridge.core.lineage import scan_checkpoint
+from adapterbridge.core.remapper import execute_remediation_plan, normalize_tensor_key
+from adapterbridge.core.template_linter import lint_chat_template
+from adapterbridge.core.dry_run import run_dry_run_verification
+
+__all__ = [
+    "AdapterInspector",
+    "scan_checkpoint",
+    "execute_remediation_plan",
+    "normalize_tensor_key",
+    "lint_chat_template",
+    "run_dry_run_verification",
+]

adapterbridge/core/dry_run.py

@@ -0,0 +1,96 @@
+"""Zero-GPU mock serving dry-run engine supporting PyTorch meta-tensors and NumPy shape math."""
+
+from typing import Dict, List, Optional
+from adapterbridge.models.manifest import CheckpointManifest
+from adapterbridge.models.report import VerificationResult
+
+# Optional PyTorch import check
+try:
+    import torch
+    HAS_TORCH = True
+except ImportError:
+    HAS_TORCH = False
+
+
+DTYPE_BYTES: Dict[str, float] = {
+    "float32": 4,
+    "fp32": 4,
+    "float16": 2,
+    "fp16": 2,
+    "bfloat16": 2,
+    "bf16": 2,
+    "int8": 1,
+    "int4": 0.5,
+}
+
+
+def run_dry_run_verification(
+    manifest: CheckpointManifest, tensor_parallel_size: int = 1
+) -> VerificationResult:
+    """Simulate target-runtime memory allocation, rank scaling, and tensor-parallel sharding math."""
+    sharding_issues: List[str] = []
+    total_bytes = 0
+    used_meta_tensors = False
+
+    if HAS_TORCH:
+        try:
+            used_meta_tensors = True
+            for t_name, t_meta in manifest.tensor_manifest.items():
+                # Materialize meta tensor without allocating GPU or host RAM
+                meta_t = torch.empty(t_meta.shape, device="meta")
+                element_bytes = meta_t.element_size() if meta_t.element_size() > 0 else 2
+                total_bytes += int(t_meta.n_elements * element_bytes)
+
+                # Validate Tensor Parallelism sharding division
+                if tensor_parallel_size > 1 and meta_t.dim() >= 2:
+                    major_dim = max(meta_t.shape)
+                    if major_dim % tensor_parallel_size != 0:
+                        sharding_issues.append(
+                            f"Tensor '{t_name}' dimension {major_dim} cannot be split evenly across tensor-parallel-size={tensor_parallel_size}."
+                        )
+        except Exception:
+            used_meta_tensors = False
+
+    if not used_meta_tensors:
+        # Fallback NumPy shape math
+        for t_name, t_meta in manifest.tensor_manifest.items():
+            element_bytes = DTYPE_BYTES.get(t_meta.dtype.lower(), 2)
+            total_bytes += int(t_meta.n_elements * element_bytes)
+
+            if tensor_parallel_size > 1 and len(t_meta.shape) >= 2:
+                major_dim = max(t_meta.shape)
+                if major_dim % tensor_parallel_size != 0:
+                    sharding_issues.append(
+                        f"Tensor '{t_name}' dimension {major_dim} cannot be split evenly across tensor-parallel-size={tensor_parallel_size}."
+                    )
+
+    # Validate LoRA rank dimension matching
+    for t_name, t_meta in manifest.tensor_manifest.items():
+        if ("lora_A" in t_name or "lora_B" in t_name) and manifest.lora_r:
+            if manifest.lora_r not in t_meta.shape:
+                sharding_issues.append(
+                    f"Tensor '{t_name}' shape {t_meta.shape} does not contain configured rank r={manifest.lora_r}."
+                )
+
+    memory_estimate_mb = round(total_bytes / (1024 * 1024), 3)
+
+    scaling_info = ""
+    if manifest.lora_r and manifest.lora_alpha:
+        scale = manifest.lora_alpha / manifest.lora_r
+        scaling_info = f" Rank r={manifest.lora_r}, alpha={manifest.lora_alpha}, scale={scale:.2f}."
+
+    mode_info = " [PyTorch meta-tensors]" if used_meta_tensors else " [NumPy shape engine]"
+    success = len(sharding_issues) == 0
+    reason = (
+        f"Dry-run simulation passed successfully.{scaling_info}{mode_info}"
+        if success
+        else f"Dry-run failed with {len(sharding_issues)} sharding/shape issue(s).{mode_info}"
+    )
+
+    return VerificationResult(
+        success=success,
+        reason=reason,
+        tensor_parallel_size=tensor_parallel_size,
+        memory_estimate_mb=memory_estimate_mb,
+        sharding_issues=sharding_issues,
+    )

adapterbridge/core/inspector.py

@@ -0,0 +1,53 @@
+"""Top-level SDK orchestration for checkpoint inspection, repair, and dry-run verification."""
+
+from typing import Optional, Union
+from adapterbridge.core.dry_run import run_dry_run_verification
+from adapterbridge.core.lineage import scan_checkpoint
+from adapterbridge.core.remapper import execute_remediation_plan
+from adapterbridge.models.manifest import CheckpointManifest
+from adapterbridge.models.report import RemediationPlan, ValidationReport, VerificationResult
+from adapterbridge.models.target_spec import TargetEngine
+from adapterbridge.targets.registry import get_target_profile
+
+
+class AdapterInspector:
+    """Primary SDK entry point for evaluating and remediating LoRA checkpoints."""
+
+    def __init__(self, checkpoint_path: str, target_engine: Union[TargetEngine, str]):
+        self.checkpoint_path = checkpoint_path
+        self.target_engine_str = target_engine.value if isinstance(target_engine, TargetEngine) else str(target_engine)
+        self.target_profile = get_target_profile(self.target_engine_str)
+        self._manifest: Optional[CheckpointManifest] = None
+
+    @property
+    def manifest(self) -> CheckpointManifest:
+        """Lazy-loaded CheckpointManifest."""
+        if self._manifest is None:
+            self._manifest = scan_checkpoint(self.checkpoint_path)
+        return self._manifest
+
+    def run_diagnostics(self) -> ValidationReport:
+        """Perform static schema inspection and validation against the target profile."""
+        return self.target_profile.validate_manifest(self.manifest)
+
+    def auto_repair(
+        self, destination_path: str, fallback_base_model: Optional[str] = None
+    ) -> RemediationPlan:
+        """Generate and execute a non-destructive remediation plan."""
+        current_manifest = self.manifest
+        if fallback_base_model and not current_manifest.base_model_id:
+            current_manifest = current_manifest.model_copy(
+                update={"base_model_id": fallback_base_model}
+            )
+
+        plan = self.target_profile.generate_remediation_plan(
+            manifest=current_manifest, destination_path=destination_path
+        )
+        if plan.is_executable and plan.operations:
+            execute_remediation_plan(current_manifest, plan)
+
+        return plan
+
+    def verify_dry_run(self, tensor_parallel_size: int = 1) -> VerificationResult:
+        """Perform zero-GPU mock dry-run simulation."""
+        return run_dry_run_verification(self.manifest, tensor_parallel_size=tensor_parallel_size)

adapterbridge/core/lineage.py

@@ -0,0 +1,85 @@
+"""Checkpoint inspection scanner and metadata lineage resolution."""
+
+import json
+import os
+from typing import Dict
+from adapterbridge.models.manifest import CheckpointManifest, TensorMetadata
+from adapterbridge.utils.safetensors_io import extract_tensor_headers
+
+
+def scan_checkpoint(checkpoint_path: str) -> CheckpointManifest:
+    """Inspect a local checkpoint directory and construct an immutable CheckpointManifest."""
+    if not os.path.exists(checkpoint_path):
+        return CheckpointManifest(
+            checkpoint_path=checkpoint_path,
+            is_adapter=False,
+            has_config=False,
+            has_tokenizer=False,
+            has_chat_template=False,
+            tensor_manifest={},
+            validation_errors=[f"Checkpoint path '{checkpoint_path}' does not exist."],
+        )
+
+    adapter_config_path = os.path.join(checkpoint_path, "adapter_config.json")
+    config_path = os.path.join(checkpoint_path, "config.json")
+    tok_config_path = os.path.join(checkpoint_path, "tokenizer_config.json")
+    tok_json_path = os.path.join(checkpoint_path, "tokenizer.json")
+
+    is_adapter = os.path.exists(adapter_config_path)
+    has_config = os.path.exists(config_path)
+    has_tokenizer = os.path.exists(tok_config_path) or os.path.exists(tok_json_path)
+
+    base_model_id = None
+    adapter_type = "lora"
+    lora_r = None
+    lora_alpha = None
+    target_modules = []
+
+    if is_adapter:
+        try:
+            with open(adapter_config_path, "r", encoding="utf-8") as f:
+                ac_data = json.load(f)
+                base_model_id = ac_data.get("base_model_name_or_path")
+                adapter_type = ac_data.get("peft_type", "lora").lower()
+                lora_r = ac_data.get("r")
+                lora_alpha = ac_data.get("lora_alpha")
+                t_mods = ac_data.get("target_modules", [])
+                if isinstance(t_mods, list):
+                    target_modules = t_mods
+                elif isinstance(t_mods, str):
+                    target_modules = [t_mods]
+        except Exception:
+            pass
+
+    has_chat_template = False
+    if os.path.exists(tok_config_path):
+        try:
+            with open(tok_config_path, "r", encoding="utf-8") as f:
+                tc_data = json.load(f)
+                if "chat_template" in tc_data and tc_data["chat_template"]:
+                    has_chat_template = True
+        except Exception:
+            pass
+
+    tensor_manifest: Dict[str, TensorMetadata] = {}
+    for root, _, files in os.walk(checkpoint_path):
+        for file in files:
+            if file.endswith(".safetensors"):
+                full_path = os.path.join(root, file)
+                headers = extract_tensor_headers(full_path)
+                tensor_manifest.update(headers)
+
+    return CheckpointManifest(
+        checkpoint_path=checkpoint_path,
+        is_adapter=is_adapter,
+        base_model_id=base_model_id,
+        adapter_type=adapter_type,
+        lora_r=lora_r,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules,
+        has_config=has_config,
+        has_tokenizer=has_tokenizer,
+        has_chat_template=has_chat_template,
+        tensor_manifest=tensor_manifest,
+        validation_errors=[],
+    )

adapterbridge/core/remapper.py

@@ -0,0 +1,97 @@
+"""Tensor state-dict key normalization and remediation plan execution engine."""
+
+import json
+import os
+import shutil
+import uuid
+from typing import Dict
+from adapterbridge.models.manifest import CheckpointManifest
+from adapterbridge.models.report import RemediationAction, RemediationPlan
+from adapterbridge.utils.safetensors_io import remap_safetensors_file
+
+
+KNOWN_PREFIX_REMAPS = [
+    ("base_model.model.model.layers.", "model.layers."),
+    ("base_model.model.", "model."),
+]
+
+
+def normalize_tensor_key(key: str) -> str:
+    """Normalize a tensor key using standard framework prefix stripping."""
+    for old_prefix, new_prefix in KNOWN_PREFIX_REMAPS:
+        if key.startswith(old_prefix):
+            return key.replace(old_prefix, new_prefix, 1)
+    return key
+
+
+def execute_remediation_plan(manifest: CheckpointManifest, plan: RemediationPlan) -> str:
+    """Execute a remediation plan using atomic staging directories.
+    
+    Returns the final destination directory path.
+    """
+    dst_path = os.path.abspath(plan.output_path)
+    staging_dir = os.path.join(
+        os.path.dirname(dst_path),
+        f".adapterbridge_staging_{uuid.uuid4().hex[:8]}"
+    )
+    os.makedirs(staging_dir, exist_ok=True)
+
+    try:
+        # Copy source files to staging
+        if os.path.exists(manifest.checkpoint_path):
+            for item in os.listdir(manifest.checkpoint_path):
+                s_item = os.path.join(manifest.checkpoint_path, item)
+                d_item = os.path.join(staging_dir, item)
+                if os.path.isfile(s_item):
+                    shutil.copy2(s_item, d_item)
+                elif os.path.isdir(s_item):
+                    shutil.copytree(s_item, d_item)
+
+        # Execute operations
+        for op in plan.operations:
+            if op.action == RemediationAction.SYNTHESIZE_FILE:
+                target_rel = os.path.relpath(op.target_path, plan.output_path)
+                staged_file = os.path.join(staging_dir, target_rel)
+                os.makedirs(os.path.dirname(staged_file), exist_ok=True)
+
+                if staged_file.endswith(".json"):
+                    with open(staged_file, "w", encoding="utf-8") as f:
+                        json.dump(op.details, f, indent=2)
+                elif staged_file.endswith("Modelfile"):
+                    with open(staged_file, "w", encoding="utf-8") as f:
+                        f.write(f"FROM {op.details.get('base_model', 'llama3.1')}\n")
+                        f.write(f"ADAPTER {op.details.get('adapter_path', './adapter_model.safetensors')}\n")
+
+            elif op.action == RemediationAction.INJECT_CHAT_TEMPLATE:
+                tok_config_path = os.path.join(staging_dir, "tokenizer_config.json")
+                tc_data: Dict[str, str] = {}
+                if os.path.exists(tok_config_path):
+                    try:
+                        with open(tok_config_path, "r", encoding="utf-8") as f:
+                            tc_data = json.load(f)
+                    except Exception:
+                        pass
+                tc_data["chat_template"] = op.details.get("chat_template", "")
+                with open(tok_config_path, "w", encoding="utf-8") as f:
+                    json.dump(tc_data, f, indent=2)
+
+            elif op.action == RemediationAction.REMAP_TENSOR_KEY:
+                key_map = op.details.get("key_map", {})
+                for root, _, files in os.walk(staging_dir):
+                    for file in files:
+                        if file.endswith(".safetensors"):
+                            staged_st = os.path.join(root, file)
+                            temp_st = staged_st + ".tmp"
+                            remap_safetensors_file(staged_st, temp_st, key_map)
+                            os.replace(temp_st, staged_st)
+
+        # Atomic rename into final destination
+        if os.path.exists(dst_path):
+            shutil.rmtree(dst_path)
+        shutil.move(staging_dir, dst_path)
+        return dst_path
+
+    except Exception as e:
+        if os.path.exists(staging_dir):
+            shutil.rmtree(staging_dir, ignore_errors=True)
+        raise RuntimeError(f"Remediation execution failed: {str(e)}") from e

adapterbridge/core/template_library.py

@@ -0,0 +1,75 @@
+"""Canonical Jinja2 chat template library for supported model architectures."""
+
+from typing import Dict, Optional
+
+
+CANONICAL_TEMPLATES: Dict[str, str] = {
+    # Llama 3 / 3.1 / 3.3
+    "llama": (
+        "{% for message in messages %}"
+        "{{ '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n' + message['content'] + '<|eot_id|>' }}"
+        "{% endfor %}"
+        "{% if add_generation_prompt %}"
+        "{{ '<|start_header_id|>assistant<|end_header_id|>\n\n' }}"
+        "{% endif %}"
+    ),
+    # Qwen 2 / 2.5 / ChatML
+    "qwen2": (
+        "{% for message in messages %}"
+        "{{ '<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>\n' }}"
+        "{% endfor %}"
+        "{% if add_generation_prompt %}"
+        "{{ '<|im_start|>assistant\n' }}"
+        "{% endif %}"
+    ),
+    # Mistral / Mixtral
+    "mistral": (
+        "{% for message in messages %}"
+        "{% if message['role'] == 'user' %}"
+        "{{ '[INST] ' + message['content'] + ' [/INST]' }}"
+        "{% else %}"
+        "{{ message['content'] }}"
+        "{% endif %}"
+        "{% endfor %}"
+    ),
+    # DeepSeek R1 / V3
+    "deepseek": (
+        "{% for message in messages %}"
+        "{% if message['role'] == 'user' %}"
+        "{{ '<｜User｜>' + message['content'] }}"
+        "{% elif message['role'] == 'assistant' %}"
+        "{{ '<｜Assistant｜>' + message['content'] }}"
+        "{% endif %}"
+        "{% endfor %}"
+        "{% if add_generation_prompt %}"
+        "{{ '<｜Assistant｜>' }}"
+        "{% endif %}"
+    ),
+}
+
+# Aliases for architectural model_type strings
+ARCHITECTURE_ALIASES: Dict[str, str] = {
+    "llama": "llama",
+    "llamaforcausalm": "llama",
+    "qwen2": "qwen2",
+    "qwen2forcausallm": "qwen2",
+    "mistral": "mistral",
+    "mistralforcausallm": "mistral",
+    "mixtral": "mistral",
+    "deepseek": "deepseek",
+    "deepseekv2": "deepseek",
+    "deepseekv3": "deepseek",
+}
+
+
+def get_canonical_template_for_architecture(architecture_or_model_type: Optional[str]) -> str:
+    """Return canonical Jinja2 chat template for given architecture or model_type.
+    
+    Defaults to Llama-3 format if model type is missing or unknown.
+    """
+    if not architecture_or_model_type:
+        return CANONICAL_TEMPLATES["llama"]
+
+    normalized = str(architecture_or_model_type).lower().replace("_", "").replace("-", "")
+    family = ARCHITECTURE_ALIASES.get(normalized, "llama")
+    return CANONICAL_TEMPLATES.get(family, CANONICAL_TEMPLATES["llama"])

adapterbridge/core/template_linter.py

@@ -0,0 +1,44 @@
+"""Chat template linter and evaluation test vectors."""
+
+from typing import List, Tuple
+from adapterbridge.utils.jinja_sandbox import render_template_sandboxed, validate_template_syntax
+
+
+TEST_CONVERSATION_VECTORS = [
+    # 1. Simple user prompt
+    [{"role": "user", "content": "Hello, world!"}],
+    # 2. Multi-turn system + user + assistant
+    [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is Python?"},
+        {"role": "assistant", "content": "Python is a programming language."},
+        {"role": "user", "content": "Tell me more."},
+    ],
+]
+
+
+def lint_chat_template(template_str: str) -> Tuple[bool, List[str]]:
+    """Validate a Jinja2 chat template against standard conversation test vectors.
+    
+    Returns (is_valid, list_of_errors).
+    """
+    valid_syntax, err = validate_template_syntax(template_str)
+    if not valid_syntax:
+        return False, [err]
+
+    errors: List[str] = []
+    for idx, vector in enumerate(TEST_CONVERSATION_VECTORS, start=1):
+        success, res = render_template_sandboxed(
+            template_str=template_str,
+            messages=vector,
+            add_generation_prompt=True,
+            timeout_seconds=2.0,
+        )
+        if not success:
+            errors.append(f"Vector #{idx} render error: {res}")
+            break
+        elif not res or len(res.strip()) == 0:
+            errors.append(f"Vector #{idx} produced empty output.")
+            break
+
+    return len(errors) == 0, errors

adapterbridge/models/__init__.py

@@ -0,0 +1,27 @@
+"""Model package exports."""
+
+from adapterbridge.models.manifest import CheckpointManifest, TensorMetadata
+from adapterbridge.models.report import (
+    IssueSeverity,
+    ValidationIssue,
+    ValidationReport,
+    RemediationAction,
+    RemediationOperation,
+    RemediationPlan,
+    VerificationResult,
+)
+from adapterbridge.models.target_spec import TargetEngine, BaseTargetProfile
+
+__all__ = [
+    "CheckpointManifest",
+    "TensorMetadata",
+    "IssueSeverity",
+    "ValidationIssue",
+    "ValidationReport",
+    "RemediationAction",
+    "RemediationOperation",
+    "RemediationPlan",
+    "VerificationResult",
+    "TargetEngine",
+    "BaseTargetProfile",
+]