kiwi-code 0.0.501__tar.gz → 0.0.503__tar.gz

{kiwi_code-0.0.501 → kiwi_code-0.0.503}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.501
+Version: 0.0.503
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.501 → kiwi_code-0.0.503}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.501"
+version = "0.0.503"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.501 → kiwi_code-0.0.503}/src/kiwi_cli/client.py

@@ -11,8 +11,13 @@ from pykiwiai.api.hello import hello_v1_hello_get
 from pykiwiai.api.auth import (
     return_user_and_session_v1_auth_post,
 )
-from pykiwiai.api.actions import async_run_action_v1_actions_id_async_run_post
+from pykiwiai.api.actions import (
+    answer_human_questions_v1_actions_action_result_id_answer_post,
+    async_run_action_v1_actions_id_async_run_post,
+)
 from pykiwiai.api.action_results import get_action_result_v1_action_results_id_get
+from pykiwiai.api.subagents import list_subagents_of_run_v1_subagents_runs_parent_action_run_id_get
+from pykiwiai.models.human_answers_request import HumanAnswersRequest
 from pykiwiai.models.body_return_user_and_session_v1_auth_post import (
     BodyReturnUserAndSessionV1AuthPost,
 )
@@ -21,6 +26,7 @@ from pykiwiai.models.body_async_run_action_v1_actions_id_async_run_post import (
 )
 from pykiwiai.models import DataBlock, Metadata
 from .models import AuthTokens, LoginCredentials
+from .human_questions import WAITING_STATUS, human_event_type, parse_questions
 
 
 class AutobotsClientWrapper:
@@ -545,6 +551,11 @@ class AutobotsClientWrapper:
                     except Exception:
                         pass
 
+                questions = getattr(result, "human_questions", None)
+                result_dict["human_questions"] = parse_questions(
+                    [q.to_dict() for q in questions] if isinstance(questions, list) else None
+                )
+
                 result_dict["id"] = run_id
 
                 # Prompts waiting behind the current turn: with any left, a finished turn
@@ -604,6 +615,10 @@ class AutobotsClientWrapper:
             elif status == "cancelled":
                 return False, result, "Action cancelled"
 
+            # The turn ended asking the user something: done until they answer.
+            elif status == WAITING_STATUS:
+                return True, result, "Action waiting for an answer"
+
             # Still processing (a run being cancelled is not over until it says so)
             elif status in ["processing", "running", "pending", "request_cancel"]:
                 logger.debug(f"Action still {status}, attempt {attempt + 1}/{max_attempts}")
@@ -684,7 +699,12 @@ class AutobotsClientWrapper:
                         try:
                             data = json.loads(data_str)
                             on_message(data)
-                            if stop_on_terminal_status and isinstance(data, dict):
+                            # A question event's `status` is the questions', not the run's.
+                            if (
+                                stop_on_terminal_status
+                                and isinstance(data, dict)
+                                and human_event_type(data) is None
+                            ):
                                 status = str(data.get("status", "") or "").lower()
                                 if status in ["completed", "success", "finished", "failed", "error", "cancelled"]:
                                     return True
@@ -751,6 +771,85 @@ class AutobotsClientWrapper:
             logger.error(f"SSE error: {e}")
             raise
 
+    def answer_human_questions(
+        self, run_id: str, answers: list[dict]
+    ) -> tuple[int, Optional[dict], str]:
+        """Answer questions the run's model asked with `ask_human`.
+
+        `POST /v1/actions/{run_id}/answer`. Every open question must be in `answers`, each
+        answered (`selected` and/or `text`) or skipped (`skip: true`); recorded all or nothing.
+
+        Returns:
+            Tuple of (http_status, body, message). On 200 the body has `question_ids` and
+            `delivered_as`: "turn" when the run had finished and reopened as processing,
+            "instruct" when it was still running. 0 means the request did not complete.
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return 401, None, "Authentication required"
+            response = answer_human_questions_v1_actions_action_result_id_answer_post.sync_detailed(
+                action_result_id=run_id,
+                client=self.client,
+                body=HumanAnswersRequest.from_dict({"answers": answers}),
+            )
+            code = int(response.status_code)
+            if code == 200 and response.parsed is not None and hasattr(response.parsed, "delivered_as"):
+                body = response.parsed.to_dict()
+                logger.info(f"Answered {len(answers)} question(s) on run {run_id}: {body}")
+                return 200, body, "Answer sent"
+            # Only 200 and 422 are typed; the 400/403/404/409 `detail` is read from the body.
+            try:
+                body = json.loads(response.content or b"null")
+            except ValueError:
+                body = None
+            detail = body.get("detail") if isinstance(body, dict) else None
+            if not isinstance(detail, str):
+                detail = json.dumps(detail) if detail else (response.content or b"").decode("utf-8", "replace")
+            message = f"HTTP {code}" + (f": {detail}" if detail else "")
+            logger.warning(f"Answering questions on run {run_id} failed: {message}")
+            return code, body if isinstance(body, dict) else None, message
+        except Exception as e:
+            logger.error(f"Error answering questions on run {run_id}: {e}")
+            return 0, None, f"Error sending answer: {e}"
+
+    def list_subagents(self, run_id: str) -> tuple[int, Optional[dict], str]:
+        """The subagents `run_id` has spawned, once each with its status:
+        `GET /v1/subagents/runs/{run_id}`.
+
+        Returns:
+            Tuple of (http_status, body, message); body is the `SubagentsOfRun` dict on 200.
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return 401, None, "Authentication required"
+            response = list_subagents_of_run_v1_subagents_runs_parent_action_run_id_get.sync_detailed(
+                parent_action_run_id=run_id, client=self.client
+            )
+            code = int(response.status_code)
+            if code == 200 and response.parsed is not None and hasattr(response.parsed, "subagents"):
+                return 200, response.parsed.to_dict(), "ok"
+            return code, None, f"HTTP {code}"
+        except Exception as e:
+            logger.warning(f"Listing subagents of run {run_id} failed: {e}")
+            return 0, None, f"Error listing subagents: {e}"
+
+    def get_run_activity(self, run_id: str) -> tuple[int, list[dict]]:
+        """A run's recent typed activity events, oldest first
+        (`GET /v1/server_sent_events/activity/{run_id}`), for a client that subscribes to
+        `{run_id}-activity` late. A backend without the activity stream answers 404.
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return 401, []
+            response = self.client.get_httpx_client().get(f"/v1/server_sent_events/activity/{run_id}")
+            if response.status_code != 200:
+                return response.status_code, []
+            events = (response.json() or {}).get("events")
+            return 200, [e for e in events if isinstance(e, dict)] if isinstance(events, list) else []
+        except Exception as e:
+            logger.warning(f"Reading activity of run {run_id} failed: {e}")
+            return 0, []
+
     def close(self) -> None:
         """Close the client connection."""
         try:

{kiwi_code-0.0.501 → kiwi_code-0.0.503}/src/kiwi_cli/commands.py

@@ -770,6 +770,7 @@ Session:
   /queue remove <n>     Drop one waiting prompt, by its number in /queue list
   /queue clear          Drop every prompt waiting to run
   /stats [7d|30d|90d|1y] Show run statistics: runs, tokens, spend (default: 7d)
+  /agents               Show this run's subagents (also ctrl+g)
   /usage [run_id]       Show token usage for a run and its subagents (default: current run)
 
 Files:

kiwi_code-0.0.503/src/kiwi_cli/human_questions.py

@@ -0,0 +1,200 @@
+"""Questions an agent asks the user mid-run with the `ask_human` tool.
+
+The run document is the source of truth: `human_questions` on
+`GET /v1/action_results/{run_id}` holds every question ever asked in the run, each
+pointing at the turn it was asked in (`turn_index`, an index into `result.results`).
+The three events on the run's SSE topic only signal that the list changed; they are
+delivered at most once, so a client refetches the run on each one.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+ASK_HUMAN_EVENT = "ask_human"
+HUMAN_ANSWERED_EVENT = "human_answered"
+HUMAN_QUESTIONS_CLOSED_EVENT = "human_questions_closed"
+HUMAN_EVENT_TYPES = frozenset({ASK_HUMAN_EVENT, HUMAN_ANSWERED_EVENT, HUMAN_QUESTIONS_CLOSED_EVENT})
+
+#: `result.results[i].input.source` of a turn the backend opened with the user's answers.
+#: The cards already show the answers, so that turn's input is not drawn as a user message.
+HUMAN_ANSWER_SOURCE = "human_answer"
+
+#: Action-run status of a run whose turn ended with an unanswered question. The run is
+#: finished as far as a client is concerned: stop polling and let the user type.
+WAITING_STATUS = "waiting"
+
+PENDING = "pending"
+ANSWERED = "answered"
+SKIPPED = "skipped"
+CANCELLED = "cancelled"
+
+
+def human_event_type(data: object) -> str | None:
+    """The event type when `data` is one of the three human-question events."""
+    if isinstance(data, dict):
+        t = data.get("type")
+        if t in HUMAN_EVENT_TYPES:
+            return str(t)
+    return None
+
+
+def _question(raw: object) -> dict[str, Any] | None:
+    if not isinstance(raw, dict) or not raw.get("question_id"):
+        return None
+    options = []
+    for opt in raw.get("options") or []:
+        if isinstance(opt, dict) and opt.get("label"):
+            options.append({"label": str(opt["label"]), "description": str(opt.get("description") or "")})
+    answer = raw.get("answer")
+    if isinstance(answer, dict):
+        answer = {
+            "selected": [str(s) for s in (answer.get("selected") or [])],
+            "text": answer.get("text"),
+            "skipped": bool(answer.get("skipped")),
+            "answered_by": answer.get("answered_by"),
+            "answered_at": answer.get("answered_at"),
+        }
+    else:
+        answer = None
+    try:
+        turn_index = int(raw.get("turn_index") or 0)
+    except (TypeError, ValueError):
+        turn_index = 0
+    return {
+        "question_id": str(raw["question_id"]),
+        "turn_index": turn_index,
+        "header": str(raw.get("header") or ""),
+        "question": str(raw.get("question") or ""),
+        "options": options,
+        "multi_select": bool(raw.get("multi_select")),
+        "status": str(raw.get("status") or PENDING),
+        "asked_at": raw.get("asked_at"),
+        "answer": answer,
+    }
+
+
+def parse_questions(raw: object) -> list[dict[str, Any]]:
+    """Normalise a `human_questions` list (from the run or an `ask_human` event)."""
+    if not isinstance(raw, list):
+        return []
+    return [q for q in (_question(item) for item in raw) if q is not None]
+
+
+def questions_by_turn(questions: Iterable[dict[str, Any]]) -> dict[int, list[dict[str, Any]]]:
+    """Group questions by `turn_index`, keeping the order they were asked in."""
+    grouped: dict[int, list[dict[str, Any]]] = {}
+    for q in questions:
+        grouped.setdefault(int(q.get("turn_index") or 0), []).append(q)
+    return grouped
+
+
+def is_answer_turn(item: object) -> bool:
+    """Whether a `result.results[i]` entry is a turn opened by the user's answers."""
+    if not isinstance(item, dict):
+        return False
+    inp = item.get("input")
+    return isinstance(inp, dict) and inp.get("source") == HUMAN_ANSWER_SOURCE
+
+
+def has_pending(questions: Iterable[dict[str, Any]]) -> bool:
+    return any(q.get("status") == PENDING for q in questions)
+
+
+@dataclass
+class QuestionDraft:
+    """What the user has picked or typed on one card, before submitting."""
+
+    selected: list[str] = field(default_factory=list)
+    text: str = ""
+    #: The user pressed Skip on the card: sent as `skip: true`, without choices or text.
+    skipped: bool = False
+
+    def is_filled(self) -> bool:
+        return bool(self.selected) or bool(self.text.strip())
+
+    def is_handled(self) -> bool:
+        return self.skipped or self.is_filled()
+
+
+def draft_is_valid(question: dict[str, Any], draft: QuestionDraft | None) -> bool:
+    """A draft the backend would accept, or one not handled yet."""
+    if draft is None or draft.skipped or not draft.is_filled():
+        return True
+    labels = {o["label"] for o in question.get("options") or []}
+    if any(s not in labels for s in draft.selected):
+        return False
+    if not question.get("multi_select") and len(draft.selected) > 1:
+        return False
+    return True
+
+
+def build_answers(
+    questions: Iterable[dict[str, Any]], drafts: dict[str, QuestionDraft]
+) -> list[dict[str, Any]]:
+    """The `answers` body of `POST /actions/{run_id}/answer`: one item per pending card, in
+    card order, answered or `skip: true`. The backend refuses a call that leaves any open
+    question out, so `can_submit` must hold first."""
+    answers: list[dict[str, Any]] = []
+    for q in questions:
+        if q.get("status") != PENDING:
+            continue
+        draft = drafts.get(q["question_id"])
+        if draft is not None and draft.skipped:
+            answers.append({"question_id": q["question_id"], "skip": True})
+            continue
+        if draft is None or not draft.is_filled():
+            continue
+        item: dict[str, Any] = {"question_id": q["question_id"], "selected": list(draft.selected)}
+        text = draft.text.strip()
+        if text:
+            item["text"] = text
+        answers.append(item)
+    return answers
+
+
+def can_submit(questions: Iterable[dict[str, Any]], drafts: dict[str, QuestionDraft]) -> bool:
+    """Every pending card is answered (validly) or skipped: one call handles them all."""
+    pending = [q for q in questions if q.get("status") == PENDING]
+    if not pending:
+        return False
+    for q in pending:
+        draft = drafts.get(q["question_id"])
+        if draft is None or not draft.is_handled() or not draft_is_valid(q, draft):
+            return False
+    return True
+
+
+def with_status(
+    questions: Iterable[dict[str, Any]],
+    status: str,
+    *,
+    question_ids: Iterable[str] | None = None,
+    answers: Iterable[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """Copies of `questions` with the pending ones (or only `question_ids`) set to `status`;
+    a question whose answer item is a skip becomes `skipped` instead.
+
+    Used to update the screen before the backend's copy arrives; the next fetch of the run
+    replaces it.
+    """
+    ids = set(question_ids) if question_ids is not None else None
+    by_id = {a["question_id"]: a for a in (answers or [])}
+    out = []
+    for q in questions:
+        q = dict(q)
+        if q.get("status") == PENDING and (ids is None or q["question_id"] in ids):
+            q["status"] = status
+            a = by_id.get(q["question_id"])
+            if a is not None:
+                if a.get("skip"):
+                    q["status"] = SKIPPED
+                q["answer"] = {
+                    "selected": list(a.get("selected") or []),
+                    "text": a.get("text"),
+                    "skipped": bool(a.get("skip")),
+                    "answered_by": None,
+                    "answered_at": None,
+                }
+        out.append(q)
+    return out