openrunner-sdk 2.41.2__tar.gz → 2.41.3__tar.gz

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.41.2
+Version: 2.41.3
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/__init__.py

@@ -181,7 +181,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.41.2"
+__version__ = "2.41.3"
 
 logger = logging.getLogger("openrunner")
 

openrunner_sdk-2.41.3/openrunner/_native.py

@@ -0,0 +1,34 @@
+"""Optional native core: PyO3 bindings over the Rust openrunner-sdk.
+
+The Python SDK progressively delegates to `openrunner_core` (built from
+sdk-rust/openrunner-core-py with maturin) when it is installed; every call
+site keeps a pure-Python fallback, so the native core is an accelerator and
+single-implementation point, never a hard dependency.
+
+    pip install openrunner-core   # optional
+
+Covered surface today: projects (incl. linked repo), artifacts/versions,
+presigned downloads (selective, GIL released during transfers), container
+registries + broker login tokens.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+try:  # pragma: no cover - depends on optional wheel
+    import openrunner_core as _core
+except ImportError:  # pragma: no cover
+    _core = None
+
+
+def available() -> bool:
+    """True when the native core wheel is importable."""
+    return _core is not None
+
+
+def native_client(base_url: str, api_key: str) -> Optional[Any]:
+    """A native Client for the given credentials, or None without the wheel."""
+    if _core is None:
+        return None
+    return _core.Client(base_url, api_key)

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/api_client.py

@@ -465,6 +465,110 @@ class APIClient:
             logger.warning("link_project_image failed: %s", e)
             return None
 
+    def update_project_repo(
+        self,
+        org_id: str,
+        project_id: str,
+        github_repo: str | None = ...,
+        github_path: str | None = ...,
+        github_branch: str | None = ...,
+    ) -> dict[str, Any] | None:
+        """PATCH /organizations/{org_id}/projects/{id}/repo -- link source repo.
+
+        Only pass the fields to change; an explicit None clears the stored
+        value (Ellipsis sentinel = leave unchanged).
+        """
+        try:
+            body: dict[str, Any] = {}
+            if github_repo is not ...:
+                body["github_repo"] = github_repo
+            if github_path is not ...:
+                body["github_path"] = github_path
+            if github_branch is not ...:
+                body["github_branch"] = github_branch
+            r = self._request(
+                "patch",
+                f"/organizations/{org_id}/projects/{project_id}/repo",
+                json=body,
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("update_project_repo failed: %s", e)
+            return None
+
+    # -- Container registries (org-level, tokens encrypted server-side) ------
+
+    def list_container_registries(self, org_id: str) -> list[dict[str, Any]]:
+        """GET /gpu/registries -- the org's connected registries (no tokens)."""
+        try:
+            r = self._request("get", "/gpu/registries", params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("list_container_registries failed: %s", e)
+            return []
+
+    def create_container_registry(
+        self,
+        org_id: str,
+        name: str,
+        registry_url: str,
+        token: str,
+        username: str | None = None,
+        namespace: str | None = None,
+    ) -> dict[str, Any] | None:
+        """POST /gpu/registries -- store a registry credential (encrypted)."""
+        try:
+            r = self._request(
+                "post", "/gpu/registries", params={"org_id": org_id},
+                json={"name": name, "registry_url": registry_url, "token": token,
+                      "username": username, "namespace": namespace},
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("create_container_registry failed: %s", e)
+            return None
+
+    def verify_container_registry(self, org_id: str, registry_id: str) -> dict[str, Any] | None:
+        """POST /gpu/registries/{id}/verify -- probe the stored credential."""
+        try:
+            r = self._request("post", f"/gpu/registries/{registry_id}/verify",
+                              params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("verify_container_registry failed: %s", e)
+            return None
+
+    def set_default_container_registry(self, org_id: str, registry_id: str) -> dict[str, Any] | None:
+        """POST /gpu/registries/{id}/default -- mark the org default registry."""
+        try:
+            r = self._request("post", f"/gpu/registries/{registry_id}/default",
+                              params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("set_default_container_registry failed: %s", e)
+            return None
+
+    def registry_login_token(self) -> dict[str, Any] | None:
+        """POST /registry/login-token -- short-lived broker docker-login credential.
+
+        Returns {token, registry_host, username, expires_in}; docker login the
+        registry_host with it, then push/pull <registry_host>/<ns>/<repo> — the
+        broker proxies to the upstream registry with the stored credential.
+        None when the broker is unavailable (503) or on failure.
+        """
+        try:
+            r = self._request("post", "/registry/login-token")
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("registry_login_token failed: %s", e)
+            return None
+
     def list_deployments(self, project_id: str) -> list[dict[str, Any]]:
         """GET /projects/{id}/deployments -- list a project's GPU deployments."""
         try:
@@ -674,6 +778,7 @@ class APIClient:
         description: str | None = None,
         metadata: dict[str, Any] | None = None,
         base_version_id: str | None = None,
+        message: str | None = None,
     ) -> dict[str, Any] | None:
         """POST /runs/{run_id}/artifacts -- create a new artifact version.
 
@@ -700,6 +805,8 @@ class APIClient:
                 body["metadata"] = metadata
             if base_version_id is not None:
                 body["base_version_id"] = base_version_id
+            if message is not None:
+                body["message"] = message
             response = self._request("post",f"/runs/{run_id}/artifacts", json=body)
             response.raise_for_status()
             return response.json()

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/cli.py

@@ -649,12 +649,178 @@ def _format_size(size_bytes: int) -> str:
     return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
 
 
+def _resolve_org_and_project(
+    client: "APIClient", project_name: str
+) -> tuple[str, dict] | tuple[None, None]:
+    """Resolve 'org/name' (or bare name) to (org_id, project dict)."""
+    name = project_name.split("/")[-1]
+    for p in client.list_projects():
+        if p.get("name") == name or p.get("slug") == name or p.get("id") == project_name:
+            return str(p.get("org_id")), p
+    return None, None
+
+
+@main.group()
+def repo() -> None:
+    """Linked source repository (project <-> GitHub repo/subdir)."""
+    pass
+
+
+@repo.command("link")
+@click.argument("project")
+@click.option("--repo", "repo_", required=True,
+              help="GitHub repo as 'org/name' or full URL")
+@click.option("--path", "subdir", default=None,
+              help="Subdirectory of the repo holding this project's code (monorepo)")
+@click.option("--branch", default=None, help="Branch to track (server default: main)")
+def repo_link(project: str, repo_: str, subdir: str | None, branch: str | None) -> None:
+    """Link PROJECT to its source repository (with optional subdirectory)."""
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    kwargs: dict = {"github_repo": repo_}
+    if subdir is not None:
+        kwargs["github_path"] = subdir
+    if branch is not None:
+        kwargs["github_branch"] = branch
+    updated = client.update_project_repo(org_id, str(proj["id"]), **kwargs)
+    client.close()
+    if updated is None:
+        click.echo("Error: failed to link repository.", err=True)
+        raise SystemExit(1)
+    loc = updated.get("github_repo") or ""
+    if updated.get("github_path"):
+        loc += f"/{updated['github_path']}"
+    click.echo(f"Linked {proj.get('name')} -> {loc} @ {updated.get('github_branch') or 'main'}")
+
+
+@repo.command("show")
+@click.argument("project")
+def repo_show(project: str) -> None:
+    """Show PROJECT's linked repository."""
+    client = _get_client()
+    _org_id, proj = _resolve_org_and_project(client, project)
+    client.close()
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    if not proj.get("github_repo"):
+        click.echo("No repository linked.")
+        return
+    click.echo(f"repo:   {proj['github_repo']}")
+    click.echo(f"path:   {proj.get('github_path') or '(repo root)'}")
+    click.echo(f"branch: {proj.get('github_branch') or 'main'}")
+
+
+@repo.command("unlink")
+@click.argument("project")
+def repo_unlink(project: str) -> None:
+    """Remove PROJECT's repository link."""
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    updated = client.update_project_repo(
+        org_id, str(proj["id"]),
+        github_repo=None, github_path=None, github_branch=None,
+    )
+    client.close()
+    if updated is None:
+        click.echo("Error: failed to unlink repository.", err=True)
+        raise SystemExit(1)
+    click.echo(f"Unlinked repository from {proj.get('name')}.")
+
+
 @main.group()
 def artifact() -> None:
     """Artifact management commands."""
     pass
 
 
+@artifact.command("link-commit")
+@click.argument("name")
+@click.option("--commit", required=True, help="Git commit SHA the version points at")
+@click.option("--repo", "repo_", default=None,
+              help="Repo 'org/name' (default: the project's linked repo)")
+@click.option("--path", "subdir", default=None,
+              help="Subdirectory (default: the project's linked path)")
+@click.option("--branch", default=None, help="Branch the commit lives on")
+@click.option("--project", "-p", required=True, help="Project name or org/name")
+@click.option("--message", "-m", default=None, help="Version message (e.g. commit subject)")
+def artifact_link_commit(
+    name: str,
+    commit: str,
+    repo_: str | None,
+    subdir: str | None,
+    branch: str | None,
+    project: str,
+    message: str | None,
+) -> None:
+    """Record a new version of artifact NAME as a git commit reference.
+
+    Instead of uploading a code snapshot, the version stores {repo, commit,
+    path} in its metadata (zero bytes stored). Use for code artifacts whose
+    source of truth is the linked repository.
+    """
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        client.close()
+        raise SystemExit(1)
+    repo_ = repo_ or proj.get("github_repo")
+    if subdir is None:
+        subdir = proj.get("github_path")
+    if not repo_:
+        click.echo("Error: no --repo given and project has no linked repository "
+                   "(openrunner repo link ...).", err=True)
+        client.close()
+        raise SystemExit(1)
+    client.close()
+
+    import openrunner
+
+    run = openrunner.init(
+        project=project,
+        name=f"link-commit-{name}",
+        save_code=False,
+    )
+    if run is None:
+        click.echo("Error: failed to initialize run.", err=True)
+        raise SystemExit(1)
+    try:
+        client = _get_client()
+        git_ref = {"repo": repo_, "commit": commit}
+        if subdir:
+            git_ref["path"] = subdir
+        if branch:
+            git_ref["branch"] = branch
+        result = client.create_artifact_version(
+            run.id, name, "code", [],
+            metadata={"git_ref": git_ref},
+            message=message or f"git ref {commit[:12]}",
+        )
+        if not result:
+            click.echo("Error: create_artifact_version failed.", err=True)
+            client.close()
+            raise SystemExit(1)
+        client.confirm_artifact_version(result["version_id"])
+        client.close()
+    finally:
+        openrunner.finish()
+    url = f"https://github.com/{repo_}/tree/{commit}"
+    if subdir:
+        url += f"/{subdir}"
+    click.echo(
+        f"'{name}' v{result.get('version', '?')} -> {repo_}@{commit[:12]}"
+        + (f" path {subdir}" if subdir else "")
+    )
+    click.echo(url)
+
+
 @artifact.command("list")
 @click.argument("project", required=False)
 @click.option("--project", "-p", "project_opt", default=None, help="Project name")

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/datasets.py

@@ -801,6 +801,58 @@ class DatasetsClient:
         _check(r)
         return DatasetInfo._from_json(r.json())
 
+    def add_column(self, repo_id: str, name: str, *, default: str | None = None) -> list[str]:
+        """Add an editable column to an indexed dataset.
+
+        The dataset's indexed source ("parent") columns stay **read-only**: the new
+        column lives in a separate overlay table keyed on the primary key
+        (``debug_id``), so the source data is never mutated. Works on a plain
+        indexed dataset or a query-derived one — ``index_dataset`` the dataset first
+        if it isn't already. A name that collides with a read-only source column is
+        rejected. Returns the editable column names.
+        """
+        ds = self._resolve(repo_id)
+        r = self._http.post(f"/datasets/{ds.id}/columns",
+                            json={"name": name, "default": default})
+        _check(r)
+        return r.json().get("columns", [])
+
+    def set_cell(self, repo_id: str, debug_id: str, column: str,
+                 value: str | None = None) -> dict:
+        """Set ONE editable cell (creates the column on first write).
+
+        ``debug_id`` is the row's primary-key value; ``value=None`` clears it. A
+        read-only source column (or the primary key) is rejected. Returns
+        ``{ok, debug_id, column}``.
+        """
+        ds = self._resolve(repo_id)
+        r = self._http.patch(f"/datasets/{ds.id}/cell",
+                            json={"debug_id": debug_id, "column": column, "value": value})
+        _check(r)
+        return r.json()
+
+    def edit_row(self, repo_id: str, debug_id: str, values: dict[str, str | None]) -> dict:
+        """Edit one row — set several editable columns at once.
+
+        ``values`` maps column -> value (``None`` clears). Only user-added overlay /
+        derived columns are writable; the whole edit is rejected (400) if any key is
+        a read-only source column. Returns ``{ok, debug_id, columns}``.
+        """
+        ds = self._resolve(repo_id)
+        r = self._http.patch(f"/datasets/{ds.id}/rows/{debug_id}", json={"values": values})
+        _check(r)
+        return r.json()
+
+    def get_row(self, repo_id: str, debug_id: str) -> dict:
+        """Fetch one full row by ``debug_id``: read-only source fields with any
+        editable overlay values merged on top. Returns
+        ``{debug_id, row, editable_columns}`` (everything in ``row`` not listed in
+        ``editable_columns`` is a read-only parent column)."""
+        ds = self._resolve(repo_id)
+        r = self._http.get(f"/datasets/{ds.id}/row", params={"debug_id": debug_id})
+        _check(r)
+        return r.json()
+
     def delete_dataset(self, repo_id: str) -> None:
         ds = self._resolve(repo_id)
         self._http.delete(f"/datasets/{ds.id}")
@@ -1003,6 +1055,28 @@ def add_derivation(repo_id: str, parent_repo_id: str) -> "DatasetInfo":
     return _c().add_derivation(repo_id, parent_repo_id)
 
 
+def add_column(repo_id: str, name: str, *, default: str | None = None) -> list[str]:
+    """Add an editable overlay column to an indexed dataset (source columns stay
+    read-only). Module-level mirror of DatasetsClient.add_column."""
+    return _c().add_column(repo_id, name, default=default)
+
+
+def set_cell(repo_id: str, debug_id: str, column: str, value: str | None = None) -> dict:
+    """Set one editable cell of a dataset row (creates the column if new)."""
+    return _c().set_cell(repo_id, debug_id, column, value)
+
+
+def edit_row(repo_id: str, debug_id: str, values: dict[str, str | None]) -> dict:
+    """Edit one row — set several editable columns at once (read-only source
+    columns are rejected)."""
+    return _c().edit_row(repo_id, debug_id, values)
+
+
+def get_row(repo_id: str, debug_id: str) -> dict:
+    """Fetch one full row by debug_id (source fields + editable overlay values)."""
+    return _c().get_row(repo_id, debug_id)
+
+
 def presign_batch(repo_id: str, paths: list[str], **kwargs: Any) -> list[dict]:
     return _c().presign_batch(repo_id, paths, **kwargs)
 

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/install_commands.py

@@ -2188,6 +2188,26 @@ python3 -c "from openrunner import datasets as ds; ds.add_derivation('ORG/CHILD'
 ### 5. Card + verify lineage
 Write a short card explaining the heuristic + thresholds + per-language stats, then `ds.set_dataset_card('ORG/CHILD', md)`. Verify: `GET /datasets/{{id}}/lineage` (or the dataset page Lineage tab) now shows CHILD under the parent's children, and the parent can no longer be deleted without removing the child first.
 
+## Alternative: add an editable column IN PLACE (no new dataset)
+
+When you don't need a separate child dataset — you just want to **annotate / label / correct** rows of an existing **indexed** dataset — add an editable column directly. The dataset's indexed source columns stay **read-only** ("parent" columns); your new column lives in a separate overlay table keyed on `debug_id`, so the source data is never touched. This is the right tool for human review, GT correction, or attaching a quality flag you edit over time.
+
+```bash
+python3 -c "
+from openrunner import datasets as ds
+# 1. Add the editable column (index the dataset first if it isn't: ds.index_dataset('ORG/NAME', text_columns=[...]))
+ds.add_column('ORG/NAME', 'review_status', default='pending')   # -> editable column names
+# 2. Edit one cell of a row (debug_id = the row's primary key)
+ds.set_cell('ORG/NAME', 'ROW_DEBUG_ID', 'review_status', 'approved')
+# 3. Or edit several editable columns of a row at once
+ds.edit_row('ORG/NAME', 'ROW_DEBUG_ID', {{'review_status': 'rejected', 'note': 'misaligned'}})
+# 4. Read the row back (source fields + your overlay values merged)
+row = ds.get_row('ORG/NAME', 'ROW_DEBUG_ID'); print(row['editable_columns'], row['row'])
+"
+```
+
+Rules: writing a read-only **source** column (or the primary key) is rejected — only user-added columns are editable. `edit_row` validates every column up front and rejects the whole edit if any is read-only. Use this for in-place edits; use the derive flow above when you want a distinct, lineage-linked child dataset.
+
 ## Common mistakes
 - ❌ `openrunner.Artifact(...).add_file(parquet); run.log_artifact(a)` — that's a run artifact, **not** a dataset; no lineage, not queryable.
 - ❌ Re-uploading the parent's audio into the child — derived datasets reference parent media.

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/openrunner/mcp_server.py

@@ -544,6 +544,37 @@ def create_server():
                     "required": ["repo_id", "run_id"],
                 },
             ),
+            Tool(
+                name="openrunner_link_repo",
+                description=(
+                    "Link a project to its source GitHub repository, with optional "
+                    "subdirectory (monorepo) and branch. The linked repo lets code "
+                    "artifact versions be recorded as commit references instead of "
+                    "uploaded snapshots."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "project": {
+                            "type": "string",
+                            "description": "Project name (format: org/project or just project)",
+                        },
+                        "repo": {
+                            "type": "string",
+                            "description": "GitHub repo 'org/name' or full URL",
+                        },
+                        "path": {
+                            "type": "string",
+                            "description": "Subdirectory of the repo holding this project's code",
+                        },
+                        "branch": {
+                            "type": "string",
+                            "description": "Branch to track (default: main)",
+                        },
+                    },
+                    "required": ["repo"],
+                },
+            ),
             Tool(
                 name="openrunner_search_runs",
                 description="Search experiment runs by name, tags, or notes.",
@@ -1527,6 +1558,8 @@ def create_server():
                 result = await _tool_create_dataset(arguments)
             elif name == "openrunner_link_dataset_run":
                 result = await _tool_link_dataset_run(arguments)
+            elif name == "openrunner_link_repo":
+                result = await _tool_link_repo(arguments)
             elif name == "openrunner_drift_check":
                 result = await _tool_drift_check(arguments)
             elif name == "openrunner_drift_monitors":
@@ -2533,6 +2566,47 @@ async def _tool_link_dataset_run(args: dict) -> str:
     return f"Linked dataset {repo_id} -> run {run_id} as [{link_type}]."
 
 
+async def _tool_link_repo(args: dict) -> str:
+    """Link a project to its source repository (repo + subdir + branch)."""
+    repo = (args.get("repo") or "").strip()
+    if not repo:
+        return "Error: repo is required."
+    project = args.get("project") or _load_settings().get("project")
+    if not project:
+        return "Error: No project specified and none configured."
+    data = await _api_get("/projects", params={})
+    projects = data if isinstance(data, list) else []
+    match = None
+    for p in projects:
+        org = p.get("org_name", "")
+        name = p.get("name", "")
+        slug = p.get("slug", "")
+        if project in (f"{org}/{name}", f"{org}/{slug}", name, slug, str(p.get("id"))):
+            match = p
+            break
+    if match is None:
+        return f"Project '{project}' not found."
+    body: dict = {"github_repo": repo}
+    if args.get("path") is not None:
+        body["github_path"] = args["path"]
+    if args.get("branch") is not None:
+        body["github_branch"] = args["branch"]
+    try:
+        updated = await _api_patch(
+            f"/organizations/{match.get('org_id')}/projects/{match.get('id')}/repo",
+            data=body,
+        )
+    except Exception as e:
+        return f"Error linking repository: {e}"
+    loc = updated.get("github_repo") or repo
+    if updated.get("github_path"):
+        loc += f"/{updated['github_path']}"
+    return (
+        f"Linked project {match.get('name')} -> {loc} "
+        f"@ {updated.get('github_branch') or 'main'}"
+    )
+
+
 async def _tool_set_model_card(args: dict) -> str:
     """Set card_markdown on a model artifact, returning validation warnings."""
     from .model_card import validate_model_card
@@ -3571,7 +3645,7 @@ async def _tool_patent_lab_list(arguments: dict) -> str:
     for e in entries:
         score = e.get("novelty_score") or 0
         status = e.get("status", "?")
-        commit = e.get("commit_hash", "")[:8]
+        commit = (e.get("commit_hash") or "")[:8]
         lines.append(f"  [{score:3d}] {status:10s} {e.get('title', 'Untitled')}")
         if commit:
             lines.append(f"       commit: {commit}  branch: {e.get('branch', '?')}")
@@ -3837,10 +3911,50 @@ async def _tool_patent_agent(arguments: dict) -> str:
                 "max_budget_usd": max_budget,
             },
         )
+        job_id = resp.get("job_id")
         status = resp.get("status", "unknown")
-        output = resp.get("output", "")
-        cost = resp.get("cost_usd", 0)
-        duration = resp.get("duration_ms", 0)
+        cost = resp.get("cost_usd", 0) or 0
+        duration = resp.get("duration_ms", 0) or 0
+
+        # The API launches the agent in background (202). Poll until the job
+        # finishes (llm-api mode: seconds; claude-code mode: minutes).
+        if status == "running" and job_id:
+            import asyncio
+            for _ in range(60):
+                await asyncio.sleep(3)
+                st = await _api_get(
+                    f"/projects/{project_id}/patent-lab/entries/{entry_id}/agent-status")
+                job = next((j for j in st.get("jobs", [])
+                            if j.get("job_id") == job_id), None)
+                if job and job.get("status") in ("done", "error"):
+                    status = job["status"]
+                    cost = job.get("cost_usd") or 0
+                    duration = job.get("duration_ms") or 0
+                    break
+            else:
+                return (f"Patent agent still running after 3min (job {job_id}).\n"
+                        f"Re-check later via openrunner_patent_lab_list or the web UI.")
+
+        # Full output is persisted as a patent document; previews are truncated.
+        output = ""
+        try:
+            docs = await _api_get(
+                f"/projects/{project_id}/patent-lab/entries/{entry_id}/documents")
+            doc_list = docs.get("documents", [])
+            if doc_list:
+                latest = max(doc_list, key=lambda d: d.get("created_at", ""))
+                import httpx as _httpx
+                base_url, api_key = _get_api_config()
+                async with _httpx.AsyncClient(timeout=30.0) as _c:
+                    _r = await _c.get(
+                        f"{base_url}/api/v1/projects/{project_id}/patent-lab"
+                        f"/entries/{entry_id}/documents/{latest['id']}",
+                        params={"format": "markdown"},
+                        headers={"Authorization": f"Bearer {api_key}"})
+                    _r.raise_for_status()
+                    output = _r.text
+        except Exception:
+            pass
 
         return (
             f"Patent agent completed.\n"
@@ -3848,7 +3962,7 @@ async def _tool_patent_agent(arguments: dict) -> str:
             f"  Status: {status}\n"
             f"  Cost: ${cost:.4f}\n"
             f"  Duration: {duration}ms\n"
-            f"  Output:\n{output[:1500]}"
+            f"  Output:\n{output[:6000] if output else '(voir Patent Lab)'}"
         )
     except Exception as e:
         return f"Error running patent agent: {e}"

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.41.2"
+version = "2.41.3"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.3}/tests/test_mcp_server.py

@@ -2166,7 +2166,12 @@ class TestPatentAgent:
         monkeypatch.setattr(mcp, "_resolve_project_id", resolver)
         patch_post(monkeypatch, {"status": "done", "output": "result text", "cost_usd": 0.5, "duration_ms": 1000})
         out = run(mcp._tool_patent_agent({"entry_id": "e", "task": "analyze"}))
-        assert "Patent agent completed" in out and "result text" in out
+        # The full output is now persisted to the patent-lab entry and fetched as
+        # the latest document; with no document mocked here, the tool shows the
+        # "(voir Patent Lab)" pointer instead of inlining the raw output.
+        assert "Patent agent completed" in out
+        assert "Status: done" in out
+        assert ("result text" in out) or ("voir Patent Lab" in out)
 
     def test_error(self, monkeypatch) -> None:
         monkeypatch.setattr(mcp, "_resolve_project", lambda: "org/p")