agentlink-cli 0.1.6__tar.gz → 0.1.8__tar.gz

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentlink-cli
-Version: 0.1.6
+Version: 0.1.8
 Summary: Local runtime connector for AgentLink
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/acp/adapter.py

@@ -125,7 +125,7 @@ class AcpAdapter:
                 },
                 timeout=_SESSION_NEW_TIMEOUT_S,
             )
-        except (AcpJsonRpcError, TimeoutError, asyncio.TimeoutError) as exc:
+        except (AcpJsonRpcError, TimeoutError) as exc:
             stderr = client.stderr_excerpt if client else ""
             detail = str(exc)
             if _is_authish_error(detail):
@@ -257,7 +257,7 @@ class AcpAdapter:
                 if isinstance(item, dict) and item.get("sessionId")
             ]
             return {"threads": threads[:limit], "skippedThreads": [], "backendNotifications": []}
-        except Exception:
+        except Exception:  # noqa: BLE001
             logger.exception("{} session/list failed", self.runtime)
             return {"threads": [], "skippedThreads": [], "backendNotifications": []}
 
@@ -305,7 +305,7 @@ class AcpAdapter:
             client = await self._ensure_client()
             await client.notify("session/cancel", {"sessionId": runtime.external_session_id})
             return {"interrupted": True}
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             logger.exception("{} session/cancel failed", self.runtime)
             return {"interrupted": False, "reason": str(exc)}
 
@@ -382,7 +382,7 @@ class AcpAdapter:
                     },
                     timeout=max_turn_s,
                 )
-            except AcpJsonRpcError as exc:
+            except AcpJsonRpcError:
                 if runtime.interrupted:
                     outcome = "cancelled"
                     end = runtime.reducer.turn_end(
@@ -394,7 +394,7 @@ class AcpAdapter:
                     )
                     await self._emit_reduction(end)
                     return
-                raise exc
+                raise
             stop_reason = _optional_string(result.get("stopReason") or result.get("stop_reason"))
             if runtime.interrupted:
                 outcome = "cancelled"
@@ -409,7 +409,7 @@ class AcpAdapter:
         except asyncio.CancelledError:
             outcome = "cancelled"
             raise
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             outcome = "cancelled" if runtime.interrupted else "failed"
             logger.exception(
                 "ACP turn failed runtime={} session_id={} turn_id={}",
@@ -477,7 +477,7 @@ class AcpAdapter:
                 data, original_name, detected_type = await self.attachment_downloader(
                     runtime.session_id, file_id
                 )
-            except Exception:
+            except Exception:  # noqa: BLE001
                 logger.exception("attachment download failed file_id={}", file_id)
                 blocks.append({"type": "text", "text": f"\n\nAttached file: {name}"})
                 continue
@@ -542,7 +542,7 @@ class AcpAdapter:
                     },
                     timeout=45.0,
                 )
-            except (AcpJsonRpcError, TimeoutError, asyncio.TimeoutError) as exc:
+            except (AcpJsonRpcError, TimeoutError) as exc:
                 stderr = client.stderr_excerpt
                 await self._shutdown_client_unlocked()
                 detail = str(exc)
@@ -575,7 +575,7 @@ class AcpAdapter:
         """Best-effort pre-spawn of the ACP process so first session is faster."""
         try:
             await self._ensure_client()
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             logger.info("{} warm_start skipped: {}", self.runtime, exc)
 
     async def _shutdown_client(self) -> None:
@@ -589,7 +589,7 @@ class AcpAdapter:
         if client is not None:
             try:
                 await client.close()
-            except Exception:
+            except Exception:  # noqa: BLE001
                 logger.exception("{} failed to close ACP client", self.runtime)
 
     async def _on_client_exit(self) -> None:
@@ -613,7 +613,7 @@ class AcpAdapter:
                         interrupted=True,
                     )
                     await self._emit_reduction(end)
-                except Exception:
+                except Exception:  # noqa: BLE001
                     logger.exception("failed to finalize turn after process exit")
                 await self._emit(
                     "runtime.error",
@@ -793,7 +793,7 @@ class AcpAdapter:
                 )
                 used_method = mid
                 break
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001
                 last_error = str(exc)
                 logger.warning(
                     "{} interactive authenticate method={} failed: {}",
@@ -886,8 +886,8 @@ class AcpAdapter:
                     "sourceObservedAt": utc_now(),
                 },
             )
-        except Exception:
-            pass
+        except Exception:  # noqa: BLE001
+            logger.exception("{} failed to emit required authentication status", self.runtime)
         return detail
 
     async def _probe_auth_and_options(self, client: AcpJsonRpcClient) -> dict[str, Any]:
@@ -946,7 +946,14 @@ class AcpAdapter:
                     else:
                         await client.request(method, {"sessionId": session_id}, timeout=3.0)
                     break
-                except Exception:
+                except Exception as exc:  # noqa: BLE001
+                    logger.debug(
+                        "{} best-effort session cleanup failed method={} session_id={} error={}",
+                        self.runtime,
+                        method,
+                        session_id,
+                        exc,
+                    )
                     continue
         return probe
 
@@ -997,7 +1004,7 @@ class AcpAdapter:
                 )
                 logger.info("{} authenticated via method={}", self.runtime, mid)
                 return True
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001
                 logger.debug(
                     "{} authenticate method={} failed: {}",
                     self.runtime,
@@ -1132,23 +1139,24 @@ class AcpAdapter:
             if isinstance(session_id, str):
                 session_runtime = self._sessions.get(session_id)
                 timer = session_runtime.turn_timer if session_runtime is not None else None
-            if timer is not None and item_type not in {"turn.start", "turn.end"}:
-                if (
-                    item_type == "message"
-                    and isinstance(item, dict)
-                    and item.get("role") == "assistant"
-                    and isinstance(item.get("content"), dict)
-                    and (
-                        (isinstance(item["content"].get("text"), str) and item["content"]["text"].strip())
-                        or (isinstance(item["content"].get("rawText"), str) and item["content"]["rawText"].strip())
-                    )
-                ):
-                    timer.mark_first_timeline(
-                        runtime=self.runtime,
-                        session_id=session_id,
-                        turn_id=item.get("turnId") if isinstance(item, dict) else None,
-                        stage_alias="adapter.first_assistant_token",
-                    )
+            if (
+                timer is not None
+                and item_type not in {"turn.start", "turn.end"}
+                and item_type == "message"
+                and isinstance(item, dict)
+                and item.get("role") == "assistant"
+                and isinstance(item.get("content"), dict)
+                and (
+                    (isinstance(item["content"].get("text"), str) and item["content"]["text"].strip())
+                    or (isinstance(item["content"].get("rawText"), str) and item["content"]["rawText"].strip())
+                )
+            ):
+                timer.mark_first_timeline(
+                    runtime=self.runtime,
+                    session_id=session_id,
+                    turn_id=item.get("turnId"),
+                    stage_alias="adapter.first_assistant_token",
+                )
             await self._emit("timeline.itemUpsert", {"sessionId": item["sessionId"], "item": item})
         if reduced.approval:
             await self._emit("approval.requested", reduced.approval)
@@ -1217,5 +1225,3 @@ def _max_turn_seconds(manifest: AgentManifest) -> float | None:
 
 def _connector_version() -> str:
     return connector_version()
-
-

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/acp/discovery.py

@@ -19,7 +19,6 @@ from connector.acp.rpc import AcpJsonRpcClient, AcpJsonRpcError
 from connector.launch import LaunchTarget, launch_target, path_exists_for_launch
 from connector.logging import logger
 
-
 _COMMAND_CHECK_TIMEOUT_S = 6.0
 # Full auth/model probe is expensive (spawn + session/new). Discovery stays light.
 _LIGHT_INIT_TIMEOUT_S = 10.0
@@ -164,7 +163,7 @@ async def probe_acp_agent(manifest: AgentManifest, target: LaunchTarget) -> dict
             if isinstance(session_id, str) and session_id:
                 await _best_effort_close_session(client, session_id)
             return probe
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         logger.warning("ACP probe failed runtime={} error={}", manifest.id, exc)
         probe["authStatus"] = "unknown"
         probe["probeError"] = str(exc)
@@ -174,8 +173,8 @@ async def probe_acp_agent(manifest: AgentManifest, target: LaunchTarget) -> dict
     finally:
         try:
             await client.close()
-        except Exception:
-            pass
+        except Exception:  # noqa: BLE001
+            logger.exception("ACP probe client close failed runtime={}", manifest.id)
 
 
 def _looks_like_auth_error(message: str) -> bool:
@@ -217,7 +216,7 @@ async def _probe_session_new(
             return None, True
         logger.debug("ACP probe session/new failed non-auth: {}", exc)
         return None, False
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         message = str(exc)
         if "timeout" in message.lower() or _looks_like_auth_error(message):
             return None, True
@@ -233,7 +232,13 @@ async def _best_effort_close_session(client: AcpJsonRpcClient, session_id: str)
             else:
                 await client.request(method, {"sessionId": session_id}, timeout=2.0)
             break
-        except Exception:
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(
+                "ACP best-effort session cleanup failed method={} session_id={} error={}",
+                method,
+                session_id,
+                exc,
+            )
             continue
 
 
@@ -268,7 +273,13 @@ async def _try_authenticate(
             )
             logger.info("ACP discovery authenticated runtime={} method={}", manifest.id, mid)
             return
-        except Exception:
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(
+                "ACP headless authentication failed runtime={} method={} error={}",
+                manifest.id,
+                mid,
+                exc,
+            )
             continue
 
 
@@ -368,7 +379,7 @@ async def _run_command(command: list[str]) -> dict[str, Any]:
         return {"status": "ok", "stdout": (stdout or stderr)[:200]}
     except FileNotFoundError:
         return {"status": "missing", "reason": "file not found"}
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         logger.exception("ACP version check failed command={}", command)
         return {"status": "failed", "reason": str(exc)}
 

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/acp/manifest.py

@@ -6,7 +6,6 @@ from importlib import resources
 from pathlib import Path
 from typing import Any, Literal
 
-
 ProcessModel = Literal["shared", "per_session"]
 CapabilityLevel = Literal["required", "optional", "unsupported"]
 
@@ -86,7 +85,7 @@ def manifest_from_dict(raw: dict[str, Any]) -> AgentManifest:
 def load_manifest_file(path: str | Path) -> AgentManifest:
     data = json.loads(Path(path).read_text(encoding="utf-8"))
     if not isinstance(data, dict):
-        raise ValueError(f"manifest file must be a JSON object: {path}")
+        raise TypeError(f"manifest file must be a JSON object: {path}")
     return manifest_from_dict(data)
 
 

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/acp/rpc.py

@@ -8,7 +8,6 @@ from typing import Any
 
 from connector.logging import logger
 
-
 NotificationHandler = Callable[[dict[str, Any]], Awaitable[None]]
 ServerRequestHandler = Callable[[str | int, str, dict[str, Any]], Awaitable[dict[str, Any] | None]]
 ExitHandler = Callable[[], Awaitable[None]]
@@ -232,7 +231,7 @@ class AcpJsonRpcClient:
         if handler is not None and not self._closed:
             try:
                 await handler()
-            except Exception:
+            except Exception:  # noqa: BLE001
                 logger.exception("ACP exit handler failed")
 
     async def _read_stderr(self) -> None:
@@ -293,16 +292,16 @@ class AcpJsonRpcClient:
         if handler is None:
             try:
                 await self.respond_error(request_id, code=-32601, message=f"Method not found: {method}")
-            except Exception:
+            except Exception:  # noqa: BLE001
                 logger.exception("ACP respond_error failed method={}", method)
             return
         try:
             result = await handler(request_id, method, params)
             if result is not None:
                 await self.respond(request_id, result)
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             logger.exception("ACP server request handler failed method={}", method)
             try:
                 await self.respond_error(request_id, code=-32000, message=str(exc))
-            except Exception:
+            except Exception:  # noqa: BLE001
                 logger.exception("ACP respond_error failed method={}", method)

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/adapter.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from collections.abc import Awaitable, Callable
 from typing import Any, Protocol, runtime_checkable
 
-
 NotificationSink = Callable[[str, dict[str, Any]], Awaitable[None]] | None
 
 

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/attachments.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import re
 from pathlib import Path
 
-
 ATTACHMENTS_ROOT_ENV = "AGENT_CONNECTOR_ATTACHMENTS_ROOT"
 DEFAULT_ATTACHMENTS_DIR = ".agent-link/attachments"
 _SAFE_FILENAME_RE = re.compile(r"[^\w.\-+]+")

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/capabilities.py

@@ -264,7 +264,7 @@ async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget | Laun
             _read_codex_collaboration_mode_options(client),
             timeout=_CODEX_CHECK_TIMEOUT_S,
         )
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         stage = "model-list" if "model_options" in locals() or _is_model_list_error(exc) else "app-server"
         return {
             **base,
@@ -276,8 +276,8 @@ async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget | Laun
     finally:
         try:
             await client.close()
-        except Exception:
-            pass
+        except Exception:  # noqa: BLE001
+            logger.exception("closing Codex capability probe client failed")
 
     return {
         **base,
@@ -398,7 +398,7 @@ async def _read_codex_model_options(client: JsonRpcStdioClient) -> list[dict[str
 
 def _codex_model_page(result: Any) -> tuple[list[Any], str | None]:
     if not isinstance(result, dict):
-        raise RuntimeError("model/list returned a non-object response")
+        raise RuntimeError("model/list returned a non-object response")  # noqa: TRY004
     raw_models: Any = result.get("models")
     if raw_models is None:
         raw_models = result.get("items")
@@ -407,7 +407,7 @@ def _codex_model_page(result: Any) -> tuple[list[Any], str | None]:
     if isinstance(raw_models, dict):
         raw_models = raw_models.get("items") or raw_models.get("models")
     if not isinstance(raw_models, list):
-        raise RuntimeError("model/list response has no models list")
+        raise RuntimeError("model/list response has no models list")  # noqa: TRY004
     raw_cursor = (
         result.get("nextCursor")
         or result.get("nextPageToken")
@@ -463,7 +463,7 @@ def _is_model_list_error(exc: BaseException) -> bool:
 async def _read_codex_collaboration_mode_options(client: JsonRpcStdioClient) -> list[dict[str, Any]]:
     try:
         result = await client.request("collaborationMode/list", {})
-    except Exception:
+    except Exception:  # noqa: BLE001
         return []
     return normalize_collaboration_modes(result)
 
@@ -498,7 +498,7 @@ def _check_claude_history() -> dict[str, Any]:
     api = "list_sessions"
     try:
         sessions = _list_claude_sdk_sessions()
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         return {
             "status": "unavailable",
             "source": source,
@@ -515,7 +515,7 @@ def _check_claude_history() -> dict[str, Any]:
 
 def _list_claude_sdk_sessions() -> list[Any]:
     sdk = importlib.import_module("claude_agent_sdk")
-    list_sessions = getattr(sdk, "list_sessions")
+    list_sessions = sdk.list_sessions
     return list(list_sessions())
 
 
@@ -546,7 +546,7 @@ async def _run_version(command: list[str], *, start_new_session: bool = False) -
         if proc is not None and proc.returncode is None:
             await _terminate_process(proc, process_group=start_new_session)
         raise
-    except Exception as exc:
+    except Exception as exc:  # noqa: BLE001
         if proc is not None and proc.returncode is None:
             await _terminate_process(proc, process_group=start_new_session)
         return {"status": "failed", "reason": _exception_reason(exc)}

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/claude/history_adapter.py

@@ -6,12 +6,11 @@ from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from typing import Any
 
-from connector.logging import logger
-
 from connector.claude.normalizers import ClaudeTranscriptNormalizer
 from connector.claude.path_utils import stable_claude_session_id
 from connector.claude.timeline_identity import content_hash
 from connector.claude.timeline_reducer import ClaudeTimelineReducer
+from connector.logging import logger
 from connector.sync_state import SyncStateStore
 from connector.time import utc_now
 
@@ -503,7 +502,7 @@ def _turn_boundary_item(
 def _list_sessions(sdk: Any, *, limit: int) -> list[Any]:
     list_sessions = getattr(sdk, "list_sessions", None)
     if not callable(list_sessions):
-        raise RuntimeError("claude-agent-sdk does not expose list_sessions()")
+        raise RuntimeError("claude-agent-sdk does not expose list_sessions()")  # noqa: TRY004
     return list(list_sessions(limit=limit))
 
 
@@ -520,7 +519,7 @@ def _get_session_info(sdk: Any, session_id: str, *, directory: str | None) -> An
 def _get_session_messages(sdk: Any, session_id: str, *, directory: str | None) -> list[Any]:
     get_session_messages = getattr(sdk, "get_session_messages", None)
     if not callable(get_session_messages):
-        raise RuntimeError("claude-agent-sdk does not expose get_session_messages()")
+        raise RuntimeError("claude-agent-sdk does not expose get_session_messages()")  # noqa: TRY004
     try:
         return list(get_session_messages(session_id, directory=directory))
     except TypeError:

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/claude/path_utils.py

@@ -9,5 +9,5 @@ def stable_claude_session_id(connector_id: str, claude_uuid: str) -> str:
     Mirrors connector.codex.adapter.stable_session_id so the backend never
     sees two ids referring to the same upstream session.
     """
-    digest = hashlib.sha256(f"{connector_id}:claude:{claude_uuid}".encode("utf-8")).hexdigest()[:24]
+    digest = hashlib.sha256(f"{connector_id}:claude:{claude_uuid}".encode()).hexdigest()[:24]
     return f"sess_claude_{digest}"

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/claude/sdk_adapter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import base64
 import hashlib
+import inspect
 import json
 import re
 import secrets
@@ -10,18 +11,19 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Any
 
-from connector.logging import logger
-
-from connector.attachments import attachment_target
 from connector.adapter import NotificationSink
+from connector.attachments import attachment_target
 from connector.claude.history_adapter import ClaudeHistoryAdapter
 from connector.claude.normalized import NormalizedClaudeEvent
 from connector.claude.normalizers import ClaudeLiveNormalizer
-from connector.claude.timeline_reducer import ClaudeTimelineReducer, is_task_event_tool_name
+from connector.claude.timeline_reducer import (
+    ClaudeTimelineReducer,
+    is_task_event_tool_name,
+)
 from connector.launch import LaunchTarget, launch_target
+from connector.logging import logger
 from connector.time import utc_now
 
-
 AttachmentDownloader = Callable[[str, str], Awaitable[tuple[bytes, str, str]]]
 """(session_id, file_id) -> (data, original_name, media_type)"""
 
@@ -97,6 +99,28 @@ class ClaudeSdkAdapter:
     def apply_history_sync_state(self, state: list[dict[str, Any]]) -> None:
         self.history_adapter.apply_history_sync_state(state)
 
+    async def close(self) -> None:
+        tasks = [
+            runtime.active_task
+            for runtime in self._sessions.values()
+            if runtime.active_task is not None and not runtime.active_task.done()
+        ]
+        for runtime in self._sessions.values():
+            runtime.interrupted = True
+            for pending in runtime.pending_approvals.values():
+                if not pending.future.done():
+                    pending.future.set_result("cancelled")
+            client = runtime.client
+            if client is not None:
+                disconnect = getattr(client, "disconnect", None)
+                if callable(disconnect):
+                    result = disconnect()
+                    if inspect.isawaitable(result):
+                        await result
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+
     async def create_session(self, params: dict[str, Any]) -> dict[str, Any]:
         session_id = (
             _optional_string(params.get("sessionId"))
@@ -238,7 +262,7 @@ class ClaudeSdkAdapter:
             stream_finished = True
         except asyncio.CancelledError:
             raise
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             stderr = _stderr_excerpt(runtime.stderr_lines)
             logger.exception(
                 "claude sdk turn failed session_id={} turn_id={} cwd={} external_session_id={} "
@@ -509,7 +533,7 @@ class ClaudeSdkAdapter:
                 external_session_id=runtime.external_session_id,
                 cwd=runtime.cwd,
             )
-        except Exception:
+        except Exception:  # noqa: BLE001
             logger.exception(
                 "claude sdk history consumed marker failed session_id={} external_session_id={}",
                 runtime.session_id,
@@ -529,7 +553,7 @@ class ClaudeSdkAdapter:
                     "pendingClientMessages": _pending_client_messages(runtime),
                 }
             )
-        except Exception:
+        except Exception:  # noqa: BLE001
             logger.exception(
                 "claude sdk history snapshot failed session_id={} external_session_id={}",
                 runtime.session_id,
@@ -678,7 +702,7 @@ class ClaudeSdkAdapter:
                 data, original_name, media_type = await self.attachment_downloader(
                     session_id, file_id
                 )
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001
                 logger.exception("Claude attachment download failed file_id={}", file_id)
                 blocks.append({"type": "text", "text": f"\n\n[Failed to load attachment {file_id}: {exc}]"})
                 continue

{agentlink_cli-0.1.6 → agentlink_cli-0.1.8}/connector/claude/timeline_reducer.py

@@ -183,7 +183,7 @@ def _content_score(content: Any) -> int:
 
 def _tool_call_content(event: NormalizedClaudeEvent) -> dict[str, Any]:
     tool_name = event.toolName or "tool"
-    tool_input = event.toolInput if isinstance(event.toolInput, dict) else event.toolInput
+    tool_input = event.toolInput
     common = _tool_common(event)
     kind = _tool_kind(tool_name)
     if kind == "command":
@@ -235,7 +235,7 @@ def _tool_call_content(event: NormalizedClaudeEvent) -> dict[str, Any]:
         "kind": "tool",
         "name": tool_name,
         "tool": tool_name,
-        "arguments": tool_input if isinstance(tool_input, dict) else tool_input,
+        "arguments": tool_input,
     })