amina-cli 0.4.2__tar.gz → 0.4.3__tar.gz

{amina_cli-0.4.2 → amina_cli-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amina-cli
-Version: 0.4.2
+Version: 0.4.3
 Summary: CLI for AminoAnalytica protein engineering platform
 Project-URL: Homepage, https://aminoanalytica.com
 Project-URL: Documentation, https://docs.aminoanalytica.com

{amina_cli-0.4.2 → amina_cli-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amina-cli"
-version = "0.4.2"
+version = "0.4.3"
 description = "CLI for AminoAnalytica protein engineering platform"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{amina_cli-0.4.2 → amina_cli-0.4.3}/src/amina_cli/__init__.py

@@ -9,4 +9,4 @@ Quick start:
     amina run esmfold --sequence "MKFLILLFNILCLFPVLAADNH"
 """
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"

{amina_cli-0.4.2 → amina_cli-0.4.3}/src/amina_cli/commands/jobs_cmd.py

@@ -775,7 +775,7 @@ def download(
     response_path.write_text(json.dumps(result, indent=2, default=str))
 
     try:
-        downloaded = download_results(result, output)
+        downloaded, failed = download_results(result, output)
         if downloaded:
             console.print(f"[green]\u2713[/green] Downloaded {len(downloaded)} file(s) to {output}/")
             for path in downloaded:
@@ -797,8 +797,20 @@ def download(
 
                 tool_metadata = get_tool(job_info.get("tool_name", ""))
                 render_tool_output(result, tool_metadata)
-            else:
+            elif not failed:
                 console.print("[dim]No output files to download.[/dim]")
+        # Per-file failures are reported separately from total-failure (StorageError).
+        # A non-empty `failed` dict means a partial success \u2014 the caller (often an
+        # agent) needs to know which files are missing so it can rerun `amina jobs
+        # download` to mint fresh signed URLs and retry just the gaps.
+        if failed:
+            console.print(f"[yellow]Warning:[/yellow] {len(failed)} file(s) failed to download:")
+            for file_type, err in failed.items():
+                console.print(f"  - {file_type}: {err}")
+            console.print(
+                "[dim]Re-run `amina jobs download` to mint fresh signed URLs and retry the missing files.[/dim]"
+            )
+            raise typer.Exit(1)
     except StorageError as e:
         # Show signed URLs as fallback
         signed_urls = result.get("signed_urls", {})
@@ -819,6 +831,40 @@ def download(
 # ═══════════════════════════════════════════════════════════════════════════════
 
 
+def _missing_artifacts(response_path: Path, dir_path: Path) -> list[str]:
+    """Return artifact file_types in ``response.json`` whose local file is missing.
+
+    Used by ``reconcile`` to detect partial downloads: a response.json on disk
+    with declared ``output_files`` but no corresponding local files indicates
+    the original download partially failed (a stale signed URL, an HTTP 400,
+    a network blip). The dir needs a retry with fresh URLs, not a skip.
+
+    Returns an empty list when:
+      - response.json doesn't exist or is malformed (caller already handled)
+      - the result declared no ``output_files`` (e.g. data-only tools)
+      - every declared file is on disk
+
+    Returns a list of ``file_type`` keys (e.g. ``["pdb_filepath",
+    "csv_filepath"]``) for each missing artifact.
+    """
+    try:
+        result = json.loads(response_path.read_text())
+    except (OSError, json.JSONDecodeError):
+        # If we can't parse it, downstream code will re-resolve from scratch.
+        return []
+    output_files = result.get("output_files") or {}
+    if not isinstance(output_files, dict):
+        return []
+    missing: list[str] = []
+    for file_type, remote_path in output_files.items():
+        if not remote_path:
+            continue
+        local = dir_path / Path(remote_path).name
+        if not local.exists():
+            missing.append(file_type)
+    return missing
+
+
 def _find_submission_files(root: Path, recursive: bool) -> list[tuple[str, Path]]:
     """Walk ``root`` for ``submission.json`` files and extract job_id from each.
 
@@ -945,11 +991,23 @@ def reconcile(
         response_path = dir_path / "response.json"
         entry: dict = {"job_id": job_id, "dir": str(dir_path)}
 
+        # Idempotency check has two parts: response.json must exist AND every
+        # declared artifact must be on local disk. Checking only response.json
+        # leaves silent gaps when the original download partially failed
+        # (HTTP 400 on a single file, stale URL after >1h, etc.) — reconcile
+        # would forever mark such dirs as `already_done` despite missing PDB
+        # or TRB outputs.
         if response_path.exists():
-            summary["already_done"] += 1
-            entry["action"] = "skipped_response_json_exists"
-            per_job.append(entry)
-            continue
+            missing = _missing_artifacts(response_path, dir_path)
+            if not missing:
+                summary["already_done"] += 1
+                entry["action"] = "skipped_response_json_exists"
+                per_job.append(entry)
+                continue
+            # Fall through to re-resolve status. _resolve_job_status will
+            # mint fresh signed URLs (any in the on-disk response.json are
+            # likely expired) and we'll retry the download below.
+            entry["missing_artifacts_before_retry"] = missing
 
         job_info = get_job_info(job_id)
         if not job_info:
@@ -1012,8 +1070,15 @@ def reconcile(
             entry["action"] = "wrote_response_json"
             if download:
                 try:
-                    downloaded = download_results(result_payload, dir_path)
+                    downloaded, failed = download_results(result_payload, dir_path)
                     entry["downloaded_files"] = [p.name for p in downloaded]
+                    # Per-file failures are partial successes; count and surface
+                    # them so the agent can detect missing artifacts without
+                    # post-hoc disk inspection. Idempotency check above will
+                    # also catch this on the next pass and retry the gaps.
+                    if failed:
+                        summary["download_failed"] += 1
+                        entry["download_failures"] = failed
                 except StorageError as dl_err:
                     summary["download_failed"] += 1
                     entry["download_error"] = str(dl_err)

{amina_cli-0.4.2 → amina_cli-0.4.3}/src/amina_cli/commands/tools/__init__.py

@@ -382,12 +382,15 @@ def run_tool_with_progress(
 
             progress.update(task, description="Downloading results...")
 
-            # Download output files
-            downloaded = []
+            # Download output files. download_results returns (downloaded, failed):
+            # per-file errors land in `failed` rather than aborting the loop, so a
+            # single stale signed URL no longer silently abandons the other files.
+            downloaded: list[Path] = []
+            failed: dict[str, str] = {}
             try:
-                downloaded = download_results(result, output_dir)
+                downloaded, failed = download_results(result, output_dir)
             except StorageError as e:
-                # If signed_urls are available, show them as fallback
+                # Total failure (e.g. no signed URLs and no Supabase credentials).
                 signed_urls = result.get("signed_urls", {})
                 if signed_urls:
                     console.print("\n[yellow]Warning:[/yellow] Could not download files automatically.")
@@ -398,6 +401,16 @@ def run_tool_with_progress(
                 else:
                     console.print(f"\n[yellow]Warning:[/yellow] Download failed: {e}")
 
+            # Surface per-file failures so agents don't silently end up with
+            # response.json present but artifacts missing.
+            if failed:
+                console.print(f"\n[yellow]Warning:[/yellow] {len(failed)} file(s) failed to download:")
+                for file_type, err in failed.items():
+                    console.print(f"  - {file_type}: {err}")
+                console.print(
+                    "[dim]Re-run `amina jobs download` to mint fresh signed URLs and retry the missing files.[/dim]"
+                )
+
             # Persist the structured response payload (success or failure) so agents
             # and scripts can read metrics/warnings/cost without re-parsing stdout.
             # Soft-fail on filesystem errors — the job has already run and been

{amina_cli-0.4.2 → amina_cli-0.4.3}/src/amina_cli/storage.py

@@ -136,12 +136,14 @@ def download_results(
     result: dict,
     output_dir: Optional[Path] = None,
     bucket: str = DEFAULT_BUCKET,
-) -> list[Path]:
+) -> tuple[list[Path], dict[str, str]]:
     """
     Download all output files from a tool result.
 
     Prefers signed URLs (no credentials needed) over direct Supabase access.
-    The API response includes 'signed_urls' dict when available.
+    Individual file failures are recorded but do not stop the loop — every
+    file gets its own attempt. This means a single bad signed URL no longer
+    aborts the whole download and silently abandons the rest.
 
     Args:
         result: Tool execution result with 'output_files' and optional 'signed_urls'
@@ -149,23 +151,31 @@ def download_results(
         bucket: Supabase storage bucket (only used as fallback)
 
     Returns:
-        List of downloaded file paths
+        Tuple ``(downloaded, failed)`` where:
+          - ``downloaded`` is the list of locally-written file paths
+          - ``failed`` is a dict ``{file_type: error_message}`` for files
+            that could not be downloaded. An empty ``failed`` dict means
+            the download was complete; callers should treat any non-empty
+            ``failed`` as a partial success that must be retried.
 
     Raises:
-        StorageError: If any download fails
+        StorageError: Only when there is no way to attempt any download at
+        all (e.g. no signed URLs AND no Supabase credentials). Per-file
+        failures are reported in the ``failed`` dict instead.
     """
     output_files = result.get("output_files", {})
     signed_urls = result.get("signed_urls", {})
 
     if not output_files and not signed_urls:
-        return []
+        return [], {}
 
     if output_dir is None:
         output_dir = Path.cwd()
 
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    downloaded = []
+    downloaded: list[Path] = []
+    failed: dict[str, str] = {}
 
     # Prefer signed URLs (no credentials needed)
     if signed_urls:
@@ -182,10 +192,13 @@ def download_results(
                 filename = f"{file_type.replace('_filepath', '')}.out"
 
             local_path = output_dir / filename
-            download_from_signed_url(signed_url, local_path)
-            downloaded.append(local_path)
+            try:
+                download_from_signed_url(signed_url, local_path)
+                downloaded.append(local_path)
+            except StorageError as e:
+                failed[file_type] = str(e)
 
-        return downloaded
+        return downloaded, failed
 
     # No signed URLs available - direct Supabase access requires credentials
     # Check if we have credentials before attempting
@@ -203,10 +216,13 @@ def download_results(
 
         filename = Path(remote_path).name
         local_path = output_dir / filename
-        download_file(remote_path, local_path, bucket)
-        downloaded.append(local_path)
+        try:
+            download_file(remote_path, local_path, bucket)
+            downloaded.append(local_path)
+        except StorageError as e:
+            failed[file_type] = str(e)
 
-    return downloaded
+    return downloaded, failed
 
 
 def upload_file(