forgexa-cli 1.54.1__tar.gz → 1.54.2__tar.gz

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.54.1
+Version: 1.54.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.54.1"
+__version__ = "1.54.2"

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/forgexa_cli/daemon.py

@@ -84,12 +84,24 @@ except ImportError:
         import runtime_evidence  # type: ignore[no-redef]  # flat script layout (desktop resources)
 
 try:
-    from app.zcode_protocol import ZCodeProtocolError, ZCodeProtocolSession
+    from app.zcode_protocol import (
+        ZCodeProtocolError,
+        ZCodeProtocolSession,
+        parse_model_selection,
+    )
 except ImportError:
     try:
-        from .zcode_protocol import ZCodeProtocolError, ZCodeProtocolSession  # type: ignore[no-redef]
+        from .zcode_protocol import (  # type: ignore[no-redef]
+            ZCodeProtocolError,
+            ZCodeProtocolSession,
+            parse_model_selection,
+        )
     except ImportError:
-        from zcode_protocol import ZCodeProtocolError, ZCodeProtocolSession  # type: ignore[no-redef]
+        from zcode_protocol import (  # type: ignore[no-redef]
+            ZCodeProtocolError,
+            ZCodeProtocolSession,
+            parse_model_selection,
+        )
 
 # Backwards-compatible aliases: keep every moved symbol importable from
 # app.daemon (tests patch e.g. app.daemon._kill_proc) while the single source
@@ -1138,7 +1150,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.54.1"
+DAEMON_VERSION = "1.54.2"
 
 
 def _detect_client_type() -> str:
@@ -7033,8 +7045,10 @@ class ProcessManager:
             if client.process is not None:
                 self.active_processes[task_id] = client.process
             self.active_zcode_sessions[task_id] = client
+            model_selection = parse_model_selection(os.environ.get("FACTORY_ZCODE_MODEL"))
             await client.create_session(
                 cwd,
+                model=model_selection,
                 tool_allowlist=list(agent_core.ZCODE_ALLOWED_TOOLS),
                 tool_denylist=list(agent_core.ZCODE_DENIED_TOOLS),
             )
@@ -7042,6 +7056,7 @@ class ProcessManager:
                 prompt,
                 input_id=task_id,
                 timeout=float(timeout),
+                model=model_selection,
             )
             metrics = {
                 "token_input": protocol_result.usage.get("input_tokens", 0),

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/forgexa_cli/zcode_protocol.py

@@ -58,6 +58,15 @@ class ZCodeTurnResult:
     usage: dict[str, int]
 
 
+@dataclass(frozen=True)
+class _TurnTerminal:
+    """Raw terminal signal from ``computer-use/operation-event`` before hydration."""
+
+    status: str
+    turn_id: str | None
+    error: str | None
+
+
 # Union[], not PEP 604 `|`: these aliases are evaluated at runtime and the
 # host must import on macOS system Python 3.9 (see agent_host.py's version gate).
 PermissionHandler = Callable[[dict[str, Any]], Union[dict[str, Any], Awaitable[dict[str, Any]]]]  # noqa: UP007 - runtime alias must stay 3.9-compatible
@@ -84,6 +93,49 @@ def _default_permission_response() -> dict[str, Any]:
     }
 
 
+# Answer to the server's session/requestRuntimePreferences reverse request,
+# matching upstream zcodeSessionRuntimePreferencesResultSchema (strict). The
+# server blocks session/create until this arrives, so reply deterministically:
+# no ambient search, no cross-session memory, auto-resolve questions so a
+# headless turn can never stall on one.
+def _runtime_preferences_result() -> dict[str, Any]:
+    return {
+        "nativeSearchEnhancementsEnabled": False,
+        "memoryEnabled": False,
+        "askUserQuestionAutoResolutionEnabled": True,
+        "modelContextBudgetStrategy": "preflight-v1",
+    }
+
+
+def parse_model_selection(raw: object) -> dict[str, Any] | None:
+    """Parse a ZCode model picker value into a wire ModelSelection.
+
+    ZCode refuses to silently default a model for headless sessions ("Select a
+    model before continuing"), so a configured selection must travel on the
+    wire the way the desktop sends it with each submission.  The value uses
+    ZCode's picker format: ``provider/model`` with an optional
+    ``$reasoningLevel`` suffix.  A blank value returns None, letting ZCode fall
+    back to its own persisted default for the isolated profile.
+    """
+    text = str(raw or "").strip()
+    if not text:
+        return None
+    provider, separator, model = text.partition("/")
+    model, _, reasoning = model.partition("$")
+    if not separator or not provider.strip() or not model.strip():
+        raise ZCodeProtocolError(
+            'FACTORY_ZCODE_MODEL must be formatted as "provider/model"'
+            ' (optionally "provider/model$reasoningLevel")'
+        )
+    selection: dict[str, Any] = {
+        "providerId": provider.strip(),
+        "modelId": model.strip(),
+    }
+    if reasoning.strip():
+        selection["options"] = {"reasoningLevel": reasoning.strip()}
+    return selection
+
+
 class ZCodeProtocolSession:
     """One ZCode Protocol process and one active native session at a time."""
 
@@ -108,11 +160,12 @@ class ZCodeProtocolSession:
         self._stderr_task: asyncio.Task[None] | None = None
         self._pending: dict[str, asyncio.Future[Any]] = {}
         self._write_lock = asyncio.Lock()
-        self._active_turn: asyncio.Future[ZCodeTurnResult] | None = None
+        self._active_turn: asyncio.Future[_TurnTerminal] | None = None
         self._active_turn_id: str | None = None
+        self._stop_requested = False
+        self._last_turn_error: str | None = None
         self._seen_event_ids: deque[str] = deque(maxlen=_MAX_SEEN_EVENT_IDS)
         self._seen_event_id_set: set[str] = set()
-        self._last_seq = -1
         self._stderr_tail: deque[str] = deque(maxlen=20)
         self._closed = False
 
@@ -147,11 +200,12 @@ class ZCodeProtocolSession:
         workspace: str | Path,
         *,
         mode: str = "build",
+        model: dict[str, Any] | None = None,
         tool_allowlist: list[str] | None = None,
         tool_denylist: list[str] | None = None,
     ) -> ZCodeSession:
         workspace_path = str(Path(workspace).resolve())
-        result = await self._request("session/create", {
+        params: dict[str, Any] = {
             "workspace": {
                 "workspacePath": workspace_path,
                 "workspaceKey": workspace_path,
@@ -161,7 +215,10 @@ class ZCodeProtocolSession:
             "mcpServers": [],
             "toolAllowlist": tool_allowlist or [],
             "toolDenylist": tool_denylist or [],
-        })
+        }
+        if model:
+            params["model"] = model
+        result = await self._request("session/create", params)
         return self._accept_session_snapshot(result)
 
     async def resume_session(self, session_id: str) -> ZCodeSession:
@@ -174,20 +231,30 @@ class ZCodeProtocolSession:
         *,
         input_id: str,
         timeout: float | None,
+        model: dict[str, Any] | None = None,
     ) -> ZCodeTurnResult:
         if not self.session_id:
             raise ZCodeProtocolError("ZCode session has not been created or resumed")
         if self._active_turn is not None and not self._active_turn.done():
             raise ZCodeProtocolError("ZCode session already has an active turn")
-        active_turn = asyncio.get_running_loop().create_future()
+        active_turn: asyncio.Future[_TurnTerminal] = (
+            asyncio.get_running_loop().create_future()
+        )
         self._active_turn = active_turn
         self._active_turn_id = None
+        self._stop_requested = False
+        self._last_turn_error = None
         try:
-            acknowledgement = await self._request("session/send", {
+            send_params: dict[str, Any] = {
                 "sessionId": self.session_id,
                 "content": content,
                 "inputId": input_id,
-            })
+            }
+            # session/send carries the selection for every turn, including
+            # resumed sessions where session/create's model field is absent.
+            if model:
+                send_params["modelSelection"] = model
+            acknowledgement = await self._request("session/send", send_params)
             if isinstance(acknowledgement, dict) and acknowledgement.get("accepted") is False:
                 raise ZCodeProtocolError("ZCode rejected the turn")
             if isinstance(acknowledgement, dict) and isinstance(
@@ -195,16 +262,71 @@ class ZCodeProtocolSession:
             ):
                 self._active_turn_id = acknowledgement["turnId"]
             if timeout is None:
-                return await active_turn
-            return await asyncio.wait_for(active_turn, timeout=timeout)
+                terminal = await active_turn
+            else:
+                terminal = await asyncio.wait_for(active_turn, timeout=timeout)
+            return await self._hydrate_turn_result(terminal)
         finally:
             if self._active_turn is active_turn:
                 self._active_turn = None
                 self._active_turn_id = None
 
+    async def _hydrate_turn_result(self, terminal: _TurnTerminal) -> ZCodeTurnResult:
+        # The turn-lifecycle channel carries no assistant text; the resolved
+        # answer lives in the persisted transcript, so read it back once the
+        # turn reaches a terminal state.
+        text = ""
+        usage: dict[str, int] = {}
+        if terminal.status == "success":
+            text, usage = await self._fetch_turn_transcript(terminal.turn_id)
+        return ZCodeTurnResult(
+            status=terminal.status,
+            session_id=self.session_id or "",
+            turn_id=terminal.turn_id,
+            text=text,
+            error=terminal.error,
+            usage=usage,
+        )
+
+    async def _fetch_turn_transcript(
+        self, turn_id: str | None,
+    ) -> tuple[str, dict[str, int]]:
+        result = await self._request("session/messages", {"sessionId": self.session_id})
+        messages = result.get("messages") if isinstance(result, dict) else None
+        if not isinstance(messages, list):
+            return "", {}
+        texts: list[str] = []
+        totals = {"input_tokens": 0, "output_tokens": 0}
+        for message in messages:
+            if not isinstance(message, dict):
+                continue
+            info = message.get("info") if isinstance(message.get("info"), dict) else {}
+            if info.get("role") != "assistant":
+                continue
+            anchor = info.get("anchor") if isinstance(info.get("anchor"), dict) else {}
+            message_turn = anchor.get("turnId")
+            if turn_id and isinstance(message_turn, str) and message_turn != turn_id:
+                continue
+            parts = message.get("parts") if isinstance(message.get("parts"), list) else []
+            for part in parts:
+                if (
+                    isinstance(part, dict) and part.get("type") == "text"
+                    and isinstance(part.get("text"), str)
+                ):
+                    texts.append(part["text"])
+            tokens = info.get("tokens") if isinstance(info.get("tokens"), dict) else {}
+            if isinstance(tokens.get("input"), (int, float)):
+                totals["input_tokens"] += int(tokens["input"])
+            if isinstance(tokens.get("output"), (int, float)):
+                totals["output_tokens"] += int(tokens["output"])
+        text = "\n".join(stripped for stripped in (t.strip() for t in texts) if stripped)
+        usage = {key: value for key, value in totals.items() if value}
+        return text, usage
+
     async def stop_turn(self, *, timeout: float = 10.0) -> None:
         if not self.session_id:
             return
+        self._stop_requested = True
         await self._request("session/stop", {"sessionId": self.session_id}, timeout=timeout)
 
     async def close(self) -> None:
@@ -295,16 +417,135 @@ class ZCodeProtocolSession:
                 else:
                     future.set_result(frame.get("result"))
             return
-        if method == "session/event":
-            params = frame.get("params")
-            if isinstance(params, dict):
-                await self._handle_session_event(params)
-            return
         if frame_id is not None and isinstance(method, str):
             await self._handle_server_request(str(frame_id), method, frame.get("params"))
+            return
+        params = frame.get("params")
+        if not isinstance(params, dict):
+            return
+        if method == "computer-use/operation-event":
+            await self._handle_operation_event(params)
+            return
+        if method == "v4/telemetry/event":
+            await self._handle_telemetry_event(params)
+
+    async def _handle_operation_event(self, params: dict[str, Any]) -> None:
+        # The 0.16.x app-server publishes turn lifecycle on this channel rather
+        # than the legacy session/event stream (proven against the live server):
+        # turn-started carries the native turnId that session/send only
+        # acknowledges, and turn-completed/turn-failed is the reliable terminal
+        # signal on both the success and failure paths.
+        if self.session_id and params.get("sessionId") != self.session_id:
+            return
+        kind = str(params.get("kind") or "")
+        turn_id = str(params.get("turnId") or "") or None
+        if kind == "turn-started":
+            if turn_id and self._active_turn is not None and not self._active_turn.done():
+                self._active_turn_id = turn_id
+            return
+        if kind not in {"turn-completed", "turn-failed"}:
+            return
+        active_turn = self._active_turn
+        if active_turn is None or active_turn.done():
+            return
+        if self._active_turn_id and turn_id and turn_id != self._active_turn_id:
+            return
+        failed = kind == "turn-failed"
+        resolved_turn_id = turn_id or self._active_turn_id
+        if not failed:
+            self._resolve_terminal(_TurnTerminal(
+                status="success", turn_id=resolved_turn_id, error=None,
+            ))
+            return
+        if self._stop_requested:
+            self._resolve_terminal(_TurnTerminal(
+                status="cancelled", turn_id=resolved_turn_id, error="ZCode turn stopped",
+            ))
+            return
+        if self._last_turn_error:
+            self._resolve_terminal(_TurnTerminal(
+                status="failed", turn_id=resolved_turn_id, error=self._last_turn_error,
+            ))
+            return
+        # Observed live: the v4 telemetry turn.terminal carrying the provider
+        # error detail lands a few milliseconds AFTER turn-failed; wait briefly
+        # so users see the real reason (e.g. "not logged in") instead of a
+        # generic failure.
+        asyncio.get_running_loop().call_later(
+            0.25, self._resolve_deferred_failure, resolved_turn_id,
+        )
+
+    def _resolve_deferred_failure(self, turn_id: str | None) -> None:
+        active_turn = self._active_turn
+        if active_turn is None or active_turn.done():
+            return
+        if self._stop_requested:
+            status, error = "cancelled", "ZCode turn stopped"
+        else:
+            status = "failed"
+            error = self._last_turn_error or "ZCode turn failed"
+        self._resolve_terminal(_TurnTerminal(status=status, turn_id=turn_id, error=error))
+
+    def _resolve_terminal(self, terminal: _TurnTerminal) -> None:
+        active_turn = self._active_turn
+        if active_turn is None or active_turn.done():
+            return
+        if terminal.turn_id:
+            self._active_turn_id = terminal.turn_id
+        active_turn.set_result(terminal)
+
+    async def _handle_telemetry_event(self, params: dict[str, Any]) -> None:
+        if self.session_id and params.get("sessionId") != self.session_id:
+            return
+        event_id = params.get("eventId")
+        if isinstance(event_id, str) and event_id:
+            if event_id in self._seen_event_id_set:
+                return
+            if len(self._seen_event_ids) == self._seen_event_ids.maxlen:
+                expired = self._seen_event_ids.popleft()
+                self._seen_event_id_set.discard(expired)
+            self._seen_event_ids.append(event_id)
+            self._seen_event_id_set.add(event_id)
+        kind = str(params.get("kind") or "")
+        turn_id = str(params.get("turnId") or "") or None
+        if kind == "turn.terminal":
+            # Capture the provider error detail for a subsequent op-event
+            # turn-failed; this fact carries errorMessage/errorCode that the
+            # lifecycle channel omits, so record it without resolving.
+            error_detail = params.get("errorMessage") or params.get("errorCode")
+            detail = _safe_detail(error_detail)
+            if detail and str(params.get("status") or "") == "failed":
+                self._last_turn_error = detail
+            return
+        if kind != "tool.lifecycle" or self.on_event is None:
+            return
+        payload: dict[str, Any] = {
+            "toolCallId": params.get("toolCallId"),
+            "toolName": params.get("toolName"),
+            "status": params.get("phase"),
+        }
+        if params.get("errorMessage"):
+            payload["output"] = _safe_detail(params.get("errorMessage"), 200)
+        emitted = self.on_event({
+            "type": "tool.updated",
+            "sessionId": self.session_id,
+            "turnId": turn_id,
+            "payload": payload,
+        })
+        if inspect.isawaitable(emitted):
+            await emitted
 
     async def _handle_server_request(
         self, request_id: str, method: str, params: object) -> None:
+        if method == "session/requestRuntimePreferences":
+            # Arrives during session/create; the server blocks the create
+            # response for ~15s until this is answered, so reply before any
+            # session-id checks (the session does not exist yet).
+            await self._write({
+                "id": request_id,
+                "result": _runtime_preferences_result(),
+            })
+            return
         if method != "interaction/requestPermission" or not isinstance(params, dict):
             await self._write({
                 "id": request_id,
@@ -336,61 +577,6 @@ class ZCodeProtocolSession:
                 logger.warning("ZCode permission handler failed; denying request")
         await self._write({"id": request_id, "result": decision})
 
-    async def _handle_session_event(self, event: dict[str, Any]) -> None:
-        event_session_id = event.get("sessionId")
-        if self.session_id and event_session_id != self.session_id:
-            return
-        event_id = event.get("eventId")
-        if isinstance(event_id, str) and event_id:
-            if event_id in self._seen_event_id_set:
-                return
-            if len(self._seen_event_ids) == self._seen_event_ids.maxlen:
-                expired = self._seen_event_ids.popleft()
-                self._seen_event_id_set.discard(expired)
-            self._seen_event_ids.append(event_id)
-            self._seen_event_id_set.add(event_id)
-        sequence = event.get("seq")
-        if isinstance(sequence, int):
-            if sequence <= self._last_seq:
-                return
-            self._last_seq = sequence
-        if self.on_event is not None:
-            emitted = self.on_event(event)
-            if inspect.isawaitable(emitted):
-                await emitted
-        event_type = event.get("type")
-        event_turn_id = str(event.get("turnId")) if event.get("turnId") else None
-        if event_type == "turn.started" and self._active_turn is not None:
-            self._active_turn_id = event_turn_id
-            return
-        if event_type not in {"turn.completed", "turn.failed"}:
-            return
-        active_turn = self._active_turn
-        if active_turn is None or active_turn.done():
-            return
-        if not self._active_turn_id or event_turn_id != self._active_turn_id:
-            return
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        result_type = str(payload.get("resultType") or "")
-        failed = event_type == "turn.failed"
-        status = "failed" if failed else ("cancelled" if result_type == "cancelled" else "success")
-        error = payload.get("error") or payload.get("message") if failed else None
-        text = payload.get("response") or payload.get("result") or payload.get("text") or ""
-        usage_raw = payload.get("usage") if isinstance(payload.get("usage"), dict) else {}
-        usage = {
-            key: int(usage_raw.get(key, 0) or 0)
-            for key in ("input_tokens", "output_tokens")
-            if isinstance(usage_raw.get(key), int)
-        }
-        active_turn.set_result(ZCodeTurnResult(
-            status=status,
-            session_id=str(event_session_id or self.session_id or ""),
-            turn_id=event_turn_id,
-            text=str(text),
-            error=_safe_detail(error) or None,
-            usage=usage,
-        ))
-
     def _accept_session_snapshot(self, snapshot: object) -> ZCodeSession:
         if not isinstance(snapshot, dict):
             raise ZCodeProtocolError("ZCode returned an invalid session snapshot")
@@ -401,12 +587,11 @@ class ZCodeProtocolSession:
         if version != _SUPPORTED_PROTOCOL_VERSION:
             raise ZCodeProtocolError("ZCode Protocol version is incompatible")
         session = snapshot.get("session") if isinstance(snapshot.get("session"), dict) else snapshot
-        session_id = session.get("id") or snapshot.get("sessionId")
+        session_id = session.get("sessionId") or session.get("id") or snapshot.get("sessionId")
         if not isinstance(session_id, str) or not session_id:
             raise ZCodeProtocolError("ZCode session snapshot did not include a session id")
         self.session_id = session_id
         self.protocol_version = version
-        self._last_seq = -1
         self._seen_event_ids.clear()
         self._seen_event_id_set.clear()
         return ZCodeSession(session_id=session_id, protocol_version=version)

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.54.1
+Version: 1.54.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.54.1 → forgexa_cli-1.54.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.54.1"
+version = "1.54.2"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"