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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amina-cli
-Version: 0.4.1
+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.1 → amina_cli-0.4.3}/pyproject.toml

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

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

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

{amina_cli-0.4.1 → 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:
@@ -958,19 +1016,20 @@ def reconcile(
             per_job.append(entry)
             continue
 
-        local_status = job_info.get("status", "")
-        if local_status not in TERMINAL_STATUSES:
-            # Local cache (now fresh) says this job hasn't terminated yet.
-            # Don't waste a per-job HTTP roundtrip just to confirm.
-            summary["still_running"] += 1
-            entry["action"] = "still_running"
-            entry["status"] = local_status
-            per_job.append(entry)
-            continue
-
-        # Terminal: fetch the full payload (signed_urls, output_files) so the
-        # response.json we write matches the shape `amina jobs download`
-        # produces.
+        # Always go to the server for the truth, even if the local cache says
+        # non-terminal. Reason: the bulk /list_jobs refresh above can return
+        # stale data when the worker's completion callback dropped (Supabase
+        # blip, gateway crash mid-handler) — a 300-job campaign reported 197
+        # jobs still_running while all 300 had finished on Modal. The CLI
+        # used to early-return on local non-terminal status, which made this
+        # bug unrecoverable from the client. Now reconcile mirrors what
+        # `amina jobs status` does: ask Modal directly via call_id.
+        #
+        # Cost: O(pending) HTTP calls per cycle. Bounded by jobs the user is
+        # actively waiting on (response.json-present dirs short-circuit
+        # above), and the gateway's heal-on-read upgrade makes the post-merge
+        # local cache mostly fresh anyway, so this fall-through is rarely hit
+        # in practice. It exists as a defence-in-depth for gateway brownouts.
         try:
             status_result = _resolve_job_status(job_info)
         except ToolExecutionError as fetch_err:
@@ -981,6 +1040,15 @@ def reconcile(
             continue
         _persist_terminal_status(job_info, status_result)
 
+        if not status_result.get("terminal", False) and status_result.get("status") not in TERMINAL_STATUSES:
+            # Genuinely still running on the server. Count, record the
+            # FRESH status (not the stale-cache one we started with), move on.
+            summary["still_running"] += 1
+            entry["action"] = "still_running"
+            entry["status"] = status_result.get("status", "running")
+            per_job.append(entry)
+            continue
+
         # Build the response payload. For completed jobs the gateway hands us
         # a full `result` dict (output_files, signed_urls, data, ...). For
         # failed/cancelled jobs Modal often returns only an error string with
@@ -1002,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.1 → 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.1 → 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(