sovara 0.3.1__tar.gz → 0.3.2__tar.gz

{sovara-0.3.1 → sovara-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sovara
-Version: 0.3.1
+Version: 0.3.2
 Summary: A development tool for agent observability, benchmarking, and optimization via domain knowledge
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{sovara-0.3.1 → sovara-0.3.2}/README.md

@@ -129,6 +129,15 @@ That copies the skill to `.claude/skills/sovara/` under the selected project. Re
 
 Use Sovara in Claude Code by letting Claude invoke the skill automatically when relevant, or select it directly from the skill menu if needed.
 
+To record Claude Code itself as a Sovara run, launch it through `so-claude`:
+
+```bash
+so-claude
+so-claude -p "summarize this repo"
+```
+
+`so-claude` starts a normal Claude Code session, routes its Anthropic API calls through Sovara, and records Claude Code model/tool activity in the run graph. It currently supports standard Anthropic API routing through `ANTHROPIC_BASE_URL`; Bedrock and Vertex Claude Code modes are not supported yet.
+
 If you want both integrations installed globally in one step, run:
 
 ```bash

{sovara-0.3.1 → sovara-0.3.2}/pyproject.toml

@@ -18,6 +18,7 @@ include = ["sovara*"]
 [project.scripts]
 # Console commands for the Sovara package
 so-record = "sovara.cli.so_record:main"
+so-claude = "sovara.cli.so_claude:main"
 so-config = "sovara.cli.so_config:main"
 so-server = "sovara.cli.so_server:main"
 so-cli = "sovara.cli.so_tool:main"
@@ -27,7 +28,7 @@ line-length = 100
 
 [project]
 name = "sovara"
-version = "0.3.1"
+version = "0.3.2"
 description = "A development tool for agent observability, benchmarking, and optimization via domain knowledge"
 readme = "docs/release/PYPI_DESC.md"
 requires-python = ">=3.10"

{sovara-0.3.1 → sovara-0.3.2}/src/sovara/assets/SKILL.md

@@ -476,7 +476,7 @@ The ideal prior has three properties:
   2. generalizes well to other scenarios where the same problem could occur in a slightly different way
   3. and it does not conflict with other existing priors.
 
-Good priors are actionable, concise, self-contained, specific, generalizable, faithful to the lesson, retrieval-friendly, and non-conflicting. If a prior captures the right lesson but is verbose, vague, overly run-specific, or hard to scan, polish it before saving or updating it. In the UI, use the **Polish** action in the content editor. From the CLI, use `so-cli priors polish <prior_id>` to get a non-mutating polished content proposal.
+Good priors are actionable, concise, self-contained, precise, well-scoped, faithful to the lesson, retrieval-friendly, and non-conflicting. Use the broadest reusable formulation that still addresses the issue, while including the conditions or exceptions needed to avoid causing mistakes in cases where the rule should not apply. If a prior captures the right lesson but is verbose, vague, overly run-specific, or hard to scan, polish it before saving or updating it. In the UI, use the **Polish** action in the content editor. From the CLI, use `so-cli priors polish <prior_id>` to get a non-mutating polished content proposal.
 
 Once you have constructed a prior, validate it by recording a fresh run with that prior available and comparing the new trace against the original observations.
 Once you verified that the prior addresses the problem, retrieve the available priors, and check if you introduced a conflict with another prior. If so, resolve the conflict by iteratively tuning and running the agent with the adapted priors, until you are satisfied.

sovara-0.3.2/src/sovara/cli/so_claude.py

@@ -0,0 +1,77 @@
+from argparse import ArgumentParser
+import sys
+
+
+def launch_command_parser():
+    parser = ArgumentParser(
+        usage="so-claude [options] [--] [claude args...]",
+        description="Launch Claude Code with Sovara observability.",
+        allow_abbrev=False,
+    )
+    parser.add_argument(
+        "--run-name",
+        default=None,
+        help="Name that will be used in the run list. If not set, Run X will be used.",
+    )
+    parser.add_argument("--user-name", help="Override or create the local Sovara user full name.")
+    parser.add_argument("--user-email", help="Override or create the local Sovara user email.")
+    parser.add_argument(
+        "--project-root",
+        help="Project root to resolve or create for this run. Defaults to the current directory.",
+    )
+    parser.add_argument("--project-name", help="Override or create the Sovara project name.")
+    parser.add_argument(
+        "--project-description",
+        help="Override or create the Sovara project description.",
+    )
+    parser.add_argument(
+        "--claude-bin",
+        default="claude",
+        help="Claude Code executable to launch. Defaults to 'claude'.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="Timeout in seconds. Terminates Claude Code if exceeded.",
+    )
+    return parser
+
+
+def _normalize_claude_args(args: list[str]) -> list[str]:
+    if args and args[0] == "--":
+        return args[1:]
+    return args
+
+
+def parse_command_args(argv: list[str] | None = None):
+    parser = launch_command_parser()
+    args, claude_args = parser.parse_known_args(argv)
+    args.claude_args = _normalize_claude_args(claude_args)
+    return args
+
+
+def launch_command(args):
+    from sovara.runner.claude_code_runner import ClaudeCodeRunner
+
+    runner = ClaudeCodeRunner(
+        claude_args=_normalize_claude_args(args.claude_args),
+        claude_bin=args.claude_bin,
+        timeout=args.timeout,
+        run_name=args.run_name,
+        user_name=getattr(args, "user_name", None),
+        user_email=getattr(args, "user_email", None),
+        project_root=getattr(args, "project_root", None),
+        project_name=getattr(args, "project_name", None),
+        project_description=getattr(args, "project_description", None),
+    )
+    runner.run()
+
+
+def main():
+    args = parse_command_args(sys.argv[1:])
+    launch_command(args)
+
+
+if __name__ == "__main__":
+    main()

{sovara-0.3.1 → sovara-0.3.2}/src/sovara/common/node_naming.py

@@ -25,6 +25,7 @@ MODEL_TOKEN_OVERRIDES = {
     "aya": "Aya",
     "awq": "AWQ",
     "bf16": "BF16",
+    "chatgpt": "ChatGPT",
     "chatglm": "ChatGLM",
     "claude": "Claude",
     "codestral": "Codestral",
@@ -138,6 +139,23 @@ def _format_openai_o_series(match: re.Match[str]) -> str:
     return f"o{major}{_format_optional_variant(variant)}"
 
 
+def _format_openai_chat_latest(match: re.Match[str]) -> str:
+    (version,) = match.groups()
+    return f"GPT-{version} Chat"
+
+
+def _format_openai_specialized_family(match: re.Match[str]) -> str:
+    family, tail = match.groups()
+    cleaned_tail = re.sub(r"-\d{4}-\d{2}-\d{2}$", "", tail or "")
+    return f"GPT {_format_model_token(family)}{_format_tail(cleaned_tail or None)}"
+
+
+def _format_openai_deep_research(match: re.Match[str]) -> str:
+    major, mini = match.groups()
+    mini_suffix = " Mini" if mini else ""
+    return f"o{major}{mini_suffix} Deep Research"
+
+
 def _format_claude_modern(match: re.Match[str]) -> str:
     family, major, minor = match.groups()
     version = _format_optional_minor(major, minor)
@@ -181,6 +199,43 @@ def _format_slug_family(match: re.Match[str]) -> str:
     return f"{family}{_format_tail(tail)}"
 
 
+def _normalize_vendor_model_name(name: str) -> str | None:
+    normalized_name = re.sub(r"^(?:apac|eu|global|us|us-gov)\.", "", name, count=1)
+
+    if normalized_name.startswith("anthropic."):
+        inner_name = normalized_name.removeprefix("anthropic.")
+        return re.sub(r"-v\d+(?::\d+)?$", "", inner_name)
+
+    if normalized_name.startswith("openai."):
+        inner_name = normalized_name.removeprefix("openai.")
+        return re.sub(r"-\d+:\d+$", "", inner_name)
+
+    if normalized_name.startswith("deepseek."):
+        inner_name = normalized_name.removeprefix("deepseek.")
+        inner_name = re.sub(r"-v\d+(?::\d+)?$", "", inner_name)
+        return f"deepseek-{inner_name}"
+
+    if normalized_name.startswith("qwen."):
+        inner_name = normalized_name.removeprefix("qwen.")
+        if inner_name == "qwen3-coder-480b-a35b-v1:0":
+            return "qwen3-coder-480b-a35b-instruct"
+        return re.sub(r"-v\d+(?::\d+)?$", "", inner_name)
+
+    if normalized_name.startswith("minimax."):
+        return normalized_name.removeprefix("minimax.")
+
+    if normalized_name.startswith("moonshotai."):
+        return normalized_name.removeprefix("moonshotai.")
+
+    if normalized_name.startswith("moonshot."):
+        return normalized_name.removeprefix("moonshot.")
+
+    if normalized_name != name:
+        return normalized_name
+
+    return None
+
+
 MODEL_NAME_PATTERNS: list[tuple[str, str]] = [
     (r"^mistral-small-2603$", "Mistral Small 4"),
     (r"^mistral-moderation-2603$", "Mistral Moderation 2"),
@@ -211,6 +266,7 @@ MODEL_NAME_PATTERNS: list[tuple[str, str]] = [
     (r"^codestral-2508$", "Codestral"),
     (r"^mistral-ocr-2512$", "OCR 3"),
     (r"^mistral-ocr-2505$", "OCR 2"),
+    (r"^chatgpt-image-latest$", "ChatGPT Image"),
     (r"^(?:openai/)?gpt-5\.2-chat-latest$", "GPT-5.2 Chat"),
     (r"^grok-4\.20-multi-agent-beta-\d{4}$", "Grok 4.20 Multi-Agent Beta"),
     (r"^grok-4\.20(?:-beta(?:-latest(?:-non-reasoning)?)?)?$", "Grok 4.20 Beta"),
@@ -240,8 +296,11 @@ ModelNameFormatter = Callable[[re.Match[str]], str]
 
 MODEL_NAME_FORMATTERS: list[tuple[str, ModelNameFormatter]] = [
     (r"^(?:chatgpt-)?gpt-4o(?:-(mini))?(?:-([a-z0-9]+(?:-[a-z0-9]+)*))?$", _format_openai_gpt_4o),
+    (r"^(?:openai/)?gpt-(\d+(?:\.\d+)?)-chat-latest$", _format_openai_chat_latest),
+    (r"^(?:openai/)?gpt-(realtime|audio|image)(?:-([a-z0-9.]+(?:-[a-z0-9.]+)*))?$", _format_openai_specialized_family),
     (r"^(?:openai/)?gpt-(\d+(?:\.\d+)?)(?:-([a-z0-9]+(?:-[a-z0-9]+)*))?$", _format_openai_gpt),
     (r"^(?:openai/)?gpt-oss-(\d+[a-z])$", _format_openai_gpt_oss),
+    (r"^(?:openai/)?o(\d+)(?:-(mini))?-deep-research$", _format_openai_deep_research),
     (r"^(?:openai/)?o(\d+)(?:-(mini|pro|preview))?$", _format_openai_o_series),
     (
         r"^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d{1,2}))?(?:-(?:\d{8}|latest))?$",
@@ -299,6 +358,10 @@ def sanitize_node_name_for_display(name: str) -> str:
     if not name:
         return NO_LABEL
 
+    normalized_name = _normalize_vendor_model_name(name)
+    if normalized_name:
+        return sanitize_node_name_for_display(normalized_name)
+
     for pattern, clean_name in COMPILED_MODEL_NAME_PATTERNS:
         if pattern.match(name):
             return clean_name