sysmlv2copilot 0.2.0__py3-none-any.whl

sysmlv2copilot/__init__.py

@@ -0,0 +1,49 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .client import SysMLCopilot
+from .exceptions import (
+    APIConnectionError,
+    APIResponseValidationError,
+    APIStatusError,
+    AuthenticationError,
+    RateLimitError,
+    SysMLCopilotError,
+)
+from .types import (
+    ArtifactReference,
+    DependencyStatus,
+    ErrorPayload,
+    HealthResponse,
+    RepairCreateParams,
+    RepairObject,
+    RequestDetail,
+    ResponseCreateParams,
+    ResponseMetadata,
+    ResponseObject,
+)
+
+try:
+    __version__ = version("sysmlv2copilot")
+except PackageNotFoundError:
+    __version__ = "0.2.0"
+
+__all__ = [
+    "APIConnectionError",
+    "APIResponseValidationError",
+    "APIStatusError",
+    "ArtifactReference",
+    "AuthenticationError",
+    "DependencyStatus",
+    "ErrorPayload",
+    "HealthResponse",
+    "RateLimitError",
+    "RepairCreateParams",
+    "RepairObject",
+    "RequestDetail",
+    "ResponseCreateParams",
+    "ResponseMetadata",
+    "ResponseObject",
+    "SysMLCopilot",
+    "SysMLCopilotError",
+    "__version__",
+]

sysmlv2copilot/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sysmlv2copilot/cli.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .client import SysMLCopilot
+from .exceptions import SysMLCopilotError
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sysmlv2copilot",
+        description="CLI client for the SysML refinement API.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--base-url",
+        default=os.getenv("SYSMLV2COPILOT_BASE_URL", "http://127.0.0.1:8000"),
+        help="API base URL.",
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("SYSMLV2COPILOT_API_KEY"),
+        help="Bearer API key. Defaults to SYSMLV2COPILOT_API_KEY.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    responses_parser = subparsers.add_parser("responses", help="Create a refinement response.")
+    responses_subparsers = responses_parser.add_subparsers(dest="responses_command", required=True)
+    create_parser = responses_subparsers.add_parser("create", help="Create a response.")
+    create_group = create_parser.add_mutually_exclusive_group(required=True)
+    create_group.add_argument("--input", help="Inline natural-language input text.")
+    create_group.add_argument("--input-file", type=Path, help="Path to a file containing the input.")
+    create_parser.add_argument("--model", default="refine-sysml-v1")
+    create_parser.add_argument("--provider", choices=["openai", "anthropic"])
+    create_parser.add_argument("--upstream-model")
+    create_parser.add_argument("--max-iters", type=int, default=10)
+    create_parser.add_argument("--max-total-tokens", type=int, default=40_000)
+    create_parser.add_argument("--temperature", type=float)
+
+    repairs_parser = subparsers.add_parser("repairs", help="Repair existing SysML.")
+    repairs_subparsers = repairs_parser.add_subparsers(dest="repairs_command", required=True)
+    repair_create_parser = repairs_subparsers.add_parser("create", help="Repair a SysML document.")
+    repair_group = repair_create_parser.add_mutually_exclusive_group(required=True)
+    repair_group.add_argument("--input", help="Inline SysML input text.")
+    repair_group.add_argument("--input-file", type=Path, help="Path to a file containing SysML.")
+    repair_create_parser.add_argument("--model", default="refine-sysml-v1")
+    repair_create_parser.add_argument("--provider", choices=["openai", "anthropic"])
+    repair_create_parser.add_argument("--upstream-model")
+    repair_create_parser.add_argument("--max-iters", type=int, default=10)
+    repair_create_parser.add_argument("--max-total-tokens", type=int, default=40_000)
+    repair_create_parser.add_argument("--temperature", type=float)
+
+    requests_parser = subparsers.add_parser("requests", help="Fetch a stored request.")
+    requests_subparsers = requests_parser.add_subparsers(dest="requests_command", required=True)
+    retrieve_parser = requests_subparsers.add_parser("retrieve", help="Retrieve a request by id.")
+    retrieve_parser.add_argument("request_id")
+
+    health_parser = subparsers.add_parser("health", help="Check service health.")
+    health_subparsers = health_parser.add_subparsers(dest="health_command", required=True)
+    health_subparsers.add_parser("check", help="Get /healthz.")
+    return parser
+
+
+def _read_input_text(args: argparse.Namespace) -> str:
+    if args.input is not None:
+        return args.input
+    return args.input_file.read_text(encoding="utf-8")
+
+
+def _print_json(data: Any) -> None:
+    print(json.dumps(data, indent=2, sort_keys=True))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        with SysMLCopilot(api_key=args.api_key, base_url=args.base_url) as client:
+            if args.command == "responses" and args.responses_command == "create":
+                response = client.responses.create(
+                    input=_read_input_text(args),
+                    model=args.model,
+                    provider=args.provider,
+                    upstream_model=args.upstream_model,
+                    max_iters=args.max_iters,
+                    max_total_tokens=args.max_total_tokens,
+                    temperature=args.temperature,
+                )
+                _print_json(response.model_dump())
+                return 0
+            if args.command == "repairs" and args.repairs_command == "create":
+                response = client.repairs.create(
+                    input=_read_input_text(args),
+                    model=args.model,
+                    provider=args.provider,
+                    upstream_model=args.upstream_model,
+                    max_iters=args.max_iters,
+                    max_total_tokens=args.max_total_tokens,
+                    temperature=args.temperature,
+                )
+                _print_json(response.model_dump())
+                return 0
+            if args.command == "requests" and args.requests_command == "retrieve":
+                detail = client.requests.retrieve(args.request_id)
+                _print_json(detail.model_dump())
+                return 0
+            if args.command == "health" and args.health_command == "check":
+                health = client.health.check()
+                _print_json(health.model_dump())
+                return 0
+    except SysMLCopilotError as exc:
+        print(f"error: {exc}")
+        return 1
+    parser.error("Unsupported command.")
+    return 2

sysmlv2copilot/client.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import httpx
+from pydantic import ValidationError
+
+from .exceptions import (
+    APIConnectionError,
+    APIResponseValidationError,
+    APIStatusError,
+    AuthenticationError,
+    RateLimitError,
+)
+from .types import (
+    HealthResponse,
+    RepairCreateParams,
+    RepairObject,
+    RequestDetail,
+    ResponseCreateParams,
+    ResponseObject,
+)
+
+
+def _normalize_base_url(base_url: str) -> str:
+    return base_url.rstrip("/")
+
+
+class _BaseResource:
+    def __init__(self, client: "SysMLCopilot") -> None:
+        self._client = client
+
+    def _request(self, method: str, path: str, *, json_body: Mapping[str, Any] | None = None) -> Any:
+        return self._client._request(method, path, json_body=json_body)
+
+
+class ResponsesResource(_BaseResource):
+    def create(
+        self,
+        *,
+        input: str,
+        model: str = "refine-sysml-v1",
+        provider: str | None = None,
+        upstream_model: str | None = None,
+        max_iters: int = 10,
+        max_total_tokens: int = 40_000,
+        temperature: float | None = None,
+    ) -> ResponseObject:
+        payload = ResponseCreateParams(
+            input=input,
+            model=model,
+            provider=provider,
+            upstream_model=upstream_model,
+            max_iters=max_iters,
+            max_total_tokens=max_total_tokens,
+            temperature=temperature,
+        )
+        data = self._request(
+            "POST",
+            "/v1/responses",
+            json_body=payload.model_dump(exclude_none=True),
+        )
+        try:
+            return ResponseObject.model_validate(data)
+        except ValidationError as exc:
+            raise APIResponseValidationError(f"Invalid response payload: {exc}") from exc
+
+
+class RequestsResource(_BaseResource):
+    def retrieve(self, request_id: str) -> RequestDetail:
+        data = self._request("GET", f"/v1/requests/{request_id}")
+        try:
+            return RequestDetail.model_validate(data)
+        except ValidationError as exc:
+            raise APIResponseValidationError(f"Invalid request detail payload: {exc}") from exc
+
+
+class RepairsResource(_BaseResource):
+    def create(
+        self,
+        *,
+        input: str,
+        model: str = "refine-sysml-v1",
+        provider: str | None = None,
+        upstream_model: str | None = None,
+        max_iters: int = 10,
+        max_total_tokens: int = 40_000,
+        temperature: float | None = None,
+    ) -> RepairObject:
+        payload = RepairCreateParams(
+            input=input,
+            model=model,
+            provider=provider,
+            upstream_model=upstream_model,
+            max_iters=max_iters,
+            max_total_tokens=max_total_tokens,
+            temperature=temperature,
+        )
+        data = self._request(
+            "POST",
+            "/v1/repairs",
+            json_body=payload.model_dump(exclude_none=True),
+        )
+        try:
+            return RepairObject.model_validate(data)
+        except ValidationError as exc:
+            raise APIResponseValidationError(f"Invalid repair payload: {exc}") from exc
+
+
+class HealthResource(_BaseResource):
+    def check(self) -> HealthResponse:
+        data = self._request("GET", "/healthz")
+        try:
+            return HealthResponse.model_validate(data)
+        except ValidationError as exc:
+            raise APIResponseValidationError(f"Invalid health payload: {exc}") from exc
+
+
+class SysMLCopilot:
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str = "http://127.0.0.1:8000",
+        timeout: float = 120.0,
+        http_client: httpx.Client | None = None,
+        default_headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.base_url = _normalize_base_url(base_url)
+        self._owns_client = http_client is None
+        headers = {"Accept": "application/json"}
+        if default_headers:
+            headers.update(default_headers)
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        if http_client is None:
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=timeout,
+            )
+        else:
+            http_client.headers.update(headers)
+            self._client = http_client
+        self.responses = ResponsesResource(self)
+        self.repairs = RepairsResource(self)
+        self.requests = RequestsResource(self)
+        self.health = HealthResource(self)
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> "SysMLCopilot":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, *, json_body: Mapping[str, Any] | None = None) -> Any:
+        try:
+            response = self._client.request(method, path, json=json_body)
+        except httpx.HTTPError as exc:
+            raise APIConnectionError(f"Request failed: {exc}") from exc
+        if response.is_error:
+            self._raise_for_status(response)
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise APIResponseValidationError(f"Response was not valid JSON: {exc}") from exc
+
+    def _raise_for_status(self, response: httpx.Response) -> None:
+        body: Any
+        try:
+            body = response.json()
+        except ValueError:
+            body = response.text
+
+        detail = body.get("detail") if isinstance(body, dict) else None
+        payload = detail.get("error") if isinstance(detail, dict) else None
+        error_type = payload.get("type") if isinstance(payload, dict) else None
+        message = payload.get("message") if isinstance(payload, dict) else response.text
+
+        exc_cls: type[APIStatusError]
+        if response.status_code == 401:
+            exc_cls = AuthenticationError
+        elif response.status_code == 429:
+            exc_cls = RateLimitError
+        else:
+            exc_cls = APIStatusError
+        raise exc_cls(
+            message or f"API request failed with status {response.status_code}",
+            status_code=response.status_code,
+            body=body,
+            error_type=error_type,
+        )

sysmlv2copilot/exceptions.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class SysMLCopilotError(Exception):
+    """Base SDK exception."""
+
+
+class APIConnectionError(SysMLCopilotError):
+    """Raised when the API cannot be reached."""
+
+
+class APIResponseValidationError(SysMLCopilotError):
+    """Raised when the API response shape is invalid."""
+
+
+class APIStatusError(SysMLCopilotError):
+    """Raised for non-2xx API responses."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        body: Any | None = None,
+        error_type: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+        self.error_type = error_type
+
+
+class AuthenticationError(APIStatusError):
+    """Raised for 401 responses."""
+
+
+class RateLimitError(APIStatusError):
+    """Raised for 429 responses."""

sysmlv2copilot/types.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class ResponseCreateParams(BaseModel):
+    input: str
+    model: str = "refine-sysml-v1"
+    provider: Literal["openai", "anthropic"] | None = None
+    upstream_model: str | None = None
+    max_iters: int = Field(default=10, ge=1, le=50)
+    max_total_tokens: int = Field(default=40_000, ge=1, le=250_000)
+    temperature: float | None = Field(default=None, ge=0, le=2)
+
+
+class RepairCreateParams(ResponseCreateParams):
+    pass
+
+
+class ErrorPayload(BaseModel):
+    type: str
+    message: str
+
+
+class ArtifactReference(BaseModel):
+    id: str
+    artifact_type: str
+    storage_backend: str
+    storage_path: str
+    content_type: str
+    size_bytes: int
+    created_at: str
+
+
+class ResponseMetadata(BaseModel):
+    operation: Literal["generate", "repair"] | None = None
+    provider: Literal["openai", "anthropic"] | None = None
+    upstream_model: str | None = None
+    run_id: str | None = None
+    diagnostics_summary: str | None = None
+    initial_compiler_passed: bool | None = None
+    artifact_paths: dict[str, str] = Field(default_factory=dict)
+    usage: dict[str, int | None] = Field(default_factory=dict)
+
+
+class ResponseObject(BaseModel):
+    id: str
+    object: Literal["response"] = "response"
+    status: Literal["completed", "failed"]
+    model: str
+    output_text: str | None = None
+    compiler_passed: bool | None = None
+    iterations_completed: int | None = None
+    started_at: str
+    finished_at: str | None = None
+    duration_ms: int | None = None
+    request_user_id: str
+    request_user_email: str | None = None
+    request_user_name: str | None = None
+    metadata: ResponseMetadata
+    error: ErrorPayload | None = None
+
+
+class RepairObject(BaseModel):
+    id: str
+    object: Literal["repair"] = "repair"
+    status: Literal["completed", "failed"]
+    model: str
+    output_text: str | None = None
+    compiler_passed: bool | None = None
+    iterations_completed: int | None = None
+    started_at: str
+    finished_at: str | None = None
+    duration_ms: int | None = None
+    request_user_id: str
+    request_user_email: str | None = None
+    request_user_name: str | None = None
+    metadata: ResponseMetadata
+    error: ErrorPayload | None = None
+
+
+class RequestDetail(BaseModel):
+    id: str
+    object: Literal["request"] = "request"
+    status: str
+    model: str
+    output_text: str | None = None
+    compiler_passed: bool | None = None
+    iterations_completed: int | None = None
+    started_at: str
+    finished_at: str | None = None
+    duration_ms: int | None = None
+    request_user_id: str
+    request_user_email: str | None = None
+    request_user_name: str | None = None
+    metadata: ResponseMetadata
+    error: ErrorPayload | None = None
+    artifacts: list[ArtifactReference] = Field(default_factory=list)
+
+
+class DependencyStatus(BaseModel):
+    available: bool
+    detail: str | None = None
+
+
+class HealthResponse(BaseModel):
+    status: Literal["ok"] = "ok"
+    service: str
+    version: str
+    dependencies: dict[str, DependencyStatus]

sysmlv2copilot-0.2.0.dist-info/METADATA

@@ -0,0 +1,432 @@
+Metadata-Version: 2.4
+Name: sysmlv2copilot
+Version: 0.2.0
+Summary: Python client SDK and CLI for the SysML refinement API
+Author: Chance LaVoie
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cmuchancel/sysmlv2copilot
+Project-URL: Repository, https://github.com/cmuchancel/sysmlv2copilot
+Project-URL: Issues, https://github.com/cmuchancel/sysmlv2copilot/issues
+Project-URL: Documentation, https://github.com/cmuchancel/sysmlv2copilot/tree/main/docs
+Keywords: sysml,sysmlv2,api-client,sdk,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: pydantic<3,>=2.7
+Provides-Extra: server
+Requires-Dist: alembic<2,>=1.14; extra == "server"
+Requires-Dist: anthropic<1,>=0.84; extra == "server"
+Requires-Dist: fastapi<1,>=0.116; extra == "server"
+Requires-Dist: openai<2,>=1.0; extra == "server"
+Requires-Dist: psycopg[binary]<4,>=3.2; extra == "server"
+Requires-Dist: pydantic-settings<3,>=2.7; extra == "server"
+Requires-Dist: python-dotenv<2,>=1.0; extra == "server"
+Requires-Dist: sqlalchemy<3,>=2.0; extra == "server"
+Requires-Dist: uvicorn<1,>=0.35; extra == "server"
+Provides-Extra: admin
+Requires-Dist: pandas<3,>=2.2; extra == "admin"
+Requires-Dist: streamlit<2,>=1.45; extra == "admin"
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: pytest<9,>=8.3; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# SysML Refinement API
+
+This repository contains two distinct products:
+- a public Python SDK and CLI, published as `sysmlv2copilot`
+- an internal server/admin implementation that stays hosted and black-box
+
+## Repo Split
+
+The repository is now organized into two explicit halves:
+- `api/`: index for the service/SDK/admin side
+- `finetune/`: local dataset generation, repair corpus, and fine-tuning assets
+
+To avoid breaking runtime imports in one large move, the API code still currently lives in the root-owned paths such as `app/`, `alembic/`, `sysmlv2copilot/`, `sysmlv2copilot_admin/`, and the main `scripts/` directory. The fine-tuning assets now live directly under `finetune/`.
+
+The hosted service accepts either natural-language requirements or SysML input, runs the compiler-in-the-loop workflow, returns SysML plus structured metadata, and stores each request with a single persisted artifact bundle.
+
+The service itself is intentionally narrow:
+- internal-only
+- one user, one API key
+- plain text in, SysML text out
+- FastAPI HTTP layer
+- Postgres-compatible metadata storage
+- filesystem artifact storage by default
+- admin operations through CLI scripts, not public admin routes
+
+## Public SDK
+
+The public package is client-only. It does not ship the backend, migrations, deployment code, or admin console.
+
+Install from PyPI:
+
+```bash
+python -m pip install sysmlv2copilot
+```
+
+Basic generation:
+
+```python
+from sysmlv2copilot import SysMLCopilot
+
+with SysMLCopilot(
+    api_key="sysml_live_...",
+    base_url="https://your-deployment.example.com",
+) as client:
+    response = client.responses.create(
+        input="Design a compact warehouse inspection drone that can hover for 15 minutes.",
+        provider="openai",
+    )
+    print(response.id)
+    print(response.output_text)
+```
+
+Basic repair:
+
+```python
+from sysmlv2copilot import SysMLCopilot
+
+broken_sysml = """package Example {
+  public import ScalarValues::*;
+  requirement def R { text = "Missing semicolon" }
+}
+"""
+
+with SysMLCopilot(
+    api_key="sysml_live_...",
+    base_url="https://your-deployment.example.com",
+) as client:
+    repaired = client.repairs.create(input=broken_sysml, provider="openai")
+    print(repaired.compiler_passed)
+    print(repaired.output_text)
+```
+
+CLI examples:
+
+```bash
+sysmlv2copilot --api-key sysml_live_... \
+  --base-url https://your-deployment.example.com \
+  responses create \
+  --input "Design a compact warehouse inspection drone that can hover for 15 minutes."
+
+sysmlv2copilot --api-key sysml_live_... \
+  --base-url https://your-deployment.example.com \
+  repairs create \
+  --input-file ./broken.sysml
+```
+
+SDK details:
+- [docs/PYTHON_SDK.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/PYTHON_SDK.md)
+- [docs/PYPI_RELEASE.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/PYPI_RELEASE.md)
+
+## What It Solves
+
+The upstream pipeline already knows how to:
+- build the iterative refinement prompt
+- call the OpenAI Responses API
+- write every iteration prompt and candidate SysML file
+- run `syside check`
+- capture compiler diagnostics
+- stop on success or refinement limits
+
+This service wraps that exact behavior in an authenticated API with request tracking and persistent artifacts so an internal team can use it immediately.
+
+The refinement loop now supports either upstream provider:
+- OpenAI via the Responses API
+- Anthropic via the Messages API
+
+The public API surface stays narrow and OpenAI-style. Provider choice is an internal runtime option exposed as an extra request field.
+
+## Repo Layout
+
+- `app/`: FastAPI app, auth, DB models, storage, and upstream wrapper
+- `app/upstream/refine_sysml.py`: vendored upstream refiner used as the behavior source of truth
+- `context/upstream/`: tight context package copied from the upstream repo
+- `scripts/`: admin CLI for user creation, API key reset, and usage reporting
+- `alembic/`: schema migrations
+- `sysmlv2copilot/`: public client SDK and CLI package
+- `sysmlv2copilot_admin/`: internal Streamlit admin console
+- `tests/`: API, CLI, and config coverage
+
+## Internal Repo Setup
+
+If you are working on the hosted backend from this repo, install the internal extras:
+
+1. Create a virtual environment and install dependencies:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e ".[server,admin,dev]"
+```
+
+2. Create `.env`:
+
+```bash
+cp .env.example .env
+```
+
+3. Fill in at least:
+- one or both of `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`
+- one of `SYSIDE_VENV_PATH` or `SYSIDE_EXECUTABLE_PATH`
+- `API_KEY_HASH_PEPPER`
+- optionally a PostgreSQL `DATABASE_URL`
+
+SQLite works for local development. PostgreSQL or Supabase Postgres is preferred for shared environments.
+For PostgreSQL or Supabase, install/runtime support now includes `psycopg`.
+
+## Migrations
+
+Run the schema migration before starting the service:
+
+```bash
+alembic upgrade head
+```
+
+## Start The Service
+
+```bash
+uvicorn app.main:app --reload
+```
+
+The default address is `http://127.0.0.1:8000`.
+
+## Create A User And API Key
+
+Create a user and print the plaintext key once:
+
+```bash
+python scripts/create_user.py --email engineer@example.com --name "Internal Engineer"
+```
+
+Reset the single API key for an existing user:
+
+```bash
+python scripts/reset_api_key.py --email engineer@example.com
+```
+
+List usage:
+
+```bash
+python scripts/list_usage.py --email engineer@example.com --from-date 2026-03-01 --to-date 2026-03-31
+```
+
+## Call The API
+
+```bash
+curl -s http://127.0.0.1:8000/v1/responses \
+  -H "Authorization: Bearer sysml_live_..." \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "Design a compact battery-powered inspection drone that fits in a 30 cm cube and flies for 20 minutes.",
+    "model": "refine-sysml-v1",
+    "provider": "openai",
+    "max_iters": 10,
+    "max_total_tokens": 40000,
+    "temperature": null
+  }'
+```
+
+Example successful response:
+
+```json
+{
+  "id": "resp_20260312_161200_abcd",
+  "object": "response",
+  "status": "completed",
+  "model": "refine-sysml-v1",
+  "output_text": "package RequirementsOnly { ... }",
+  "compiler_passed": true,
+  "iterations_completed": 4,
+  "started_at": "2026-03-12T16:12:00Z",
+  "finished_at": "2026-03-12T16:12:22Z",
+  "duration_ms": 22014,
+  "request_user_id": "usr_1234",
+  "metadata": {
+    "provider": "openai",
+    "upstream_model": "gpt-5-mini",
+    "run_id": "run_20260312_161200_abcd",
+    "artifact_paths": {
+      "request_artifact": "/abs/path/request_artifact.json"
+    }
+  },
+  "error": null
+}
+```
+
+Repair request example:
+
+```bash
+curl -s http://127.0.0.1:8000/v1/repairs \
+  -H "Authorization: Bearer sysml_live_..." \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "package Example { requirement def R { text = \"Missing semicolon\" } }",
+    "model": "refine-sysml-v1",
+    "provider": "openai"
+  }'
+```
+
+Anthropic request example:
+
+```bash
+curl -s http://127.0.0.1:8000/v1/responses \
+  -H "Authorization: Bearer sysml_live_..." \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "Design a compact battery-powered inspection drone that fits in a 30 cm cube and flies for 20 minutes.",
+    "model": "refine-sysml-v1",
+    "provider": "anthropic",
+    "upstream_model": "claude-sonnet-4-5-20250929"
+  }'
+```
+
+Check a stored request:
+
+```bash
+curl -s http://127.0.0.1:8000/v1/requests/resp_20260312_161200_abcd \
+  -H "Authorization: Bearer sysml_live_..."
+```
+
+Health check:
+
+```bash
+curl -s http://127.0.0.1:8000/healthz
+```
+
+## Repair Workflow
+
+The hosted API now supports a repair-oriented workflow:
+- accept raw SysML text
+- run SysIDE immediately
+- if the model already passes, return it unchanged with `iterations_completed = 0`
+- if it fails, feed the broken SysML plus real compiler diagnostics into the repair loop
+- persist the same request tracking and single-artifact bundle used by generation requests
+
+Repair metadata includes:
+- `metadata.operation = "repair"`
+- `metadata.initial_compiler_passed`
+- `metadata.diagnostics_summary`
+
+Design note:
+- [docs/ITERATION_STALL_POLICY.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/ITERATION_STALL_POLICY.md)
+
+## Admin Frontend
+
+Run the Streamlit admin console:
+
+```bash
+streamlit run sysmlv2copilot_admin/app.py
+```
+
+It uses the real configured database and supports:
+- create users and issue API keys
+- rotate existing keys
+- inspect per-user usage totals
+- inspect overall usage and compiler performance
+- browse recent request activity
+- check live API health against a configured base URL
+
+More detail:
+- [docs/ADMIN_FRONTEND.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/ADMIN_FRONTEND.md)
+- [docs/PYPI_RELEASE.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/PYPI_RELEASE.md)
+
+## Artifact Storage
+
+Artifacts are stored under `ARTIFACT_ROOT`, defaulting to `./data/artifacts`. Each request gets a run directory with a single persisted artifact:
+- `request_artifact.json`
+
+That JSON bundle stores:
+- the original input text
+- the final SysML output
+- request statistics such as tokens, chars, duration, and iterations
+- provider/model metadata and any terminal error
+
+Each request registers exactly one row in the `artifacts` table. Temporary iteration files used during SysIDE checks are removed before persistence.
+
+## Tests
+
+Run the test suite with:
+
+```bash
+pytest
+```
+
+The tests mock the expensive upstream generation path and cover auth, request tracking, repair flow, artifacts, CLI operations, health reporting, packaging boundaries, and config validation.
+
+## Docker
+
+Build:
+
+```bash
+docker build \
+  --build-arg SYSIDE_PIP_SPEC='syside==<your-version>' \
+  --build-arg REQUIRE_SYSIDE=1 \
+  -t sysml-refinement-api .
+```
+
+Run:
+
+```bash
+docker run --rm -p 8000:8000 --env-file .env sysml-refinement-api
+```
+
+The container runs `alembic upgrade head` before starting `uvicorn`.
+
+## Azure And Supabase
+
+The repo is now prepared for:
+- Azure Container Apps for compute
+- Azure Container Registry for the private image
+- Azure Files for persistent artifacts
+- Supabase Postgres for metadata
+
+Relevant files:
+- [docs/AZURE_CONTAINER_APPS.md](/Users/chancelavoie/Desktop/sysmlv2copilot/docs/AZURE_CONTAINER_APPS.md)
+- [scripts/deploy_azure_container_app.sh](/Users/chancelavoie/Desktop/sysmlv2copilot/scripts/deploy_azure_container_app.sh)
+- [scripts/build_database_url.py](/Users/chancelavoie/Desktop/sysmlv2copilot/scripts/build_database_url.py)
+- [scripts/render_azure_containerapp_yaml.py](/Users/chancelavoie/Desktop/sysmlv2copilot/scripts/render_azure_containerapp_yaml.py)
+- [infra/supabase/create_service_role.sql](/Users/chancelavoie/Desktop/sysmlv2copilot/infra/supabase/create_service_role.sql)
+
+To build a Supabase-compatible SQLAlchemy URL:
+
+```bash
+python scripts/build_database_url.py \
+  --host db.<project-ref>.supabase.co \
+  --port 5432 \
+  --database postgres \
+  --user sysml_api_service \
+  --password 'replace-me'
+```
+
+To deploy to Azure Container Apps:
+
+```bash
+export BUILD_MODE=local-docker
+bash scripts/deploy_azure_container_app.sh
+```
+
+## Upstream Context
+
+The copied upstream context package lives in:
+- `context/upstream/refine_sysml.py`
+- `context/upstream/setup_pipeline_env.sh`
+- `context/upstream/pipeline_README.md`
+- `context/upstream/pipeline_HELP.md`
+- `context/upstream/env.example`
+- `context/examples/example_prompt.txt`
+- `context/examples/example_output.sysml`
+- `context/examples/example_run_log.json`
+
+That context is intentionally tight and keeps the original refinement flow visible without copying the whole older repository.

sysmlv2copilot-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+sysmlv2copilot/__init__.py,sha256=p2Mh-FKAw1Kttgd5uzR-mVXziyrfrS3nB2q6at6GFcQ,1049
+sysmlv2copilot/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+sysmlv2copilot/cli.py,sha256=NgYQfYd0bgBjCKcqJdAqIZaf8LM8YxmMQXNfu3aiuKQ,5600
+sysmlv2copilot/client.py,sha256=9haAmRTDyJ0sPeQuSfZAD820ak4q_FiXLZ__c5DEwc8,6327
+sysmlv2copilot/exceptions.py,sha256=CciML13L2vi0ykFLBVKvnykCayo_lJESqSPW9yvDHo0,893
+sysmlv2copilot/types.py,sha256=4UC0ln0kpjwgxKpFpxw5o1A5zW6PYheOXQB7ESb5iII,3097
+sysmlv2copilot-0.2.0.dist-info/licenses/LICENSE,sha256=9If2iTgJ6D92J8kGny9XF5J_30GCiu_OCmu7rh0pQRQ,1070
+sysmlv2copilot-0.2.0.dist-info/METADATA,sha256=GlA-RSzUKNv5FcLY8AnLG-4_yYx-56Hp1N-HgpZBVzM,13263
+sysmlv2copilot-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sysmlv2copilot-0.2.0.dist-info/entry_points.txt,sha256=kvZa4fSgRoJjdaBg3xyyenQhULsfLQsqAKv9uilcaWw,59
+sysmlv2copilot-0.2.0.dist-info/top_level.txt,sha256=FNO1KVjFkDTO74Lbs9Zyb5yDAmcvleiZ50ap4sPaNGU,15
+sysmlv2copilot-0.2.0.dist-info/RECORD,,

sysmlv2copilot-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sysmlv2copilot-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sysmlv2copilot = sysmlv2copilot.cli:main

sysmlv2copilot-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chance LaVoie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sysmlv2copilot-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sysmlv2copilot