kiwi-code 0.0.45__tar.gz → 0.0.50__tar.gz

{kiwi_code-0.0.45 → kiwi_code-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.45
+Version: 0.0.50
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>
@@ -19,7 +19,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: pykiwiai==0.0.13
+Requires-Dist: pykiwiai==0.0.14
 Requires-Dist: setproctitle>=1.3.0
 Requires-Dist: textual-dev>=1.8.0
 Requires-Dist: textual>=8.1.1

{kiwi_code-0.0.45 → kiwi_code-0.0.50}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "kiwi-code"
-version = "0.0.45"
+version = "0.0.50"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"
 dependencies = [
-    "pykiwiai==0.0.13",
+    "pykiwiai==0.0.14",
     "loguru>=0.7.3",
     "pydantic>=2.12.5",
     "textual>=8.1.1",

{kiwi_code-0.0.45 → kiwi_code-0.0.50}/src/kiwi_cli/client.py

@@ -547,6 +547,11 @@ class AutobotsClientWrapper:
 
                 result_dict["id"] = run_id
 
+                # Prompts waiting behind the current turn: with any left, a finished turn
+                # is not the end of the run.
+                queued_inputs = getattr(getattr(result, "queued_inputs", None), "inputs", None)
+                result_dict["queued"] = len(queued_inputs) if isinstance(queued_inputs, list) else 0
+
                 logger.info(f"Parsed result: status={result_dict.get('status')}, has_result={('result' in result_dict)}")
                 logger.info(f"Result structure keys: {result_dict.keys()}")
                 if "result" in result_dict and isinstance(result_dict["result"], dict):

{kiwi_code-0.0.45 → kiwi_code-0.0.50}/src/kiwi_cli/commands.py

@@ -4,18 +4,22 @@ Each command function takes an AuthenticatedClient and keyword args,
 and returns a list of strings (output lines).
 """
 
+import re
 import os
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from typing import Iterator, Optional
+from typing import Callable, Iterator, Optional
 from pykiwiai import AuthenticatedClient
 from pykiwiai.api.actions import (
     list_actions_v1_actions_get,
     get_action_v1_actions_id_get,
     cancel_action_run_v1_actions_action_result_id_cancel_post,
+    instruct_action_run_v1_actions_action_result_id_instruct_post,
 )
 from pykiwiai.api.action_results import (
+    get_action_queue_v1_action_results_action_result_id_queue_get,
+    update_action_queue_v1_action_results_action_result_id_queue_put,
     list_action_result_v1_action_results_get,
     get_action_result_v1_action_results_id_get,
 )
@@ -211,6 +215,121 @@ def runs_cancel(client: AuthenticatedClient, *, id: str) -> list[str]:
     return cancel_lines(id, *cancel_run(client, id=id))
 
 
+# steering a run that is in progress
+
+def instruct_run(client: AuthenticatedClient, *, id: str, text: str, urls: Optional[list[str]] = None) -> int:
+    """Hand a run that is processing an instruction to read at its next step. Returns the
+    HTTP status: 202 when taken, 409 when the run is not processing."""
+    from pykiwiai.models.run_instruction import RunInstruction
+
+    resp = instruct_action_run_v1_actions_action_result_id_instruct_post.sync_detailed(
+        action_result_id=id, client=client, body=RunInstruction(text=text, urls=list(urls or [])),
+    )
+    return resp.status_code
+
+
+# the queue: prompts waiting behind the turn in progress
+
+def get_queue(client: AuthenticatedClient, *, id: str) -> tuple[int, list[str], int]:
+    """The prompts queued on a run, oldest first. Returns (HTTP status, prompts, the
+    queue's version, which a write has to quote)."""
+    status, blocks, version = _read_queue(client, id)
+    return status, [_block_text(block) for block in blocks], version
+
+
+def _block_text(block: object) -> str:
+    return str(getattr(block, "text", None) or "")
+
+
+def _read_queue(client: AuthenticatedClient, id: str) -> tuple[int, list, int]:
+    """The queue as the server stores it: (HTTP status, input blocks, version)."""
+    resp = get_action_queue_v1_action_results_action_result_id_queue_get.sync_detailed(
+        action_result_id=id, client=client,
+    )
+    queue = resp.parsed
+    inputs = getattr(queue, "inputs", None)
+    if resp.status_code != 200 or not isinstance(inputs, list):
+        return resp.status_code, [], 0
+    version = getattr(queue, "version_number", 0)
+    return 200, list(inputs), version if isinstance(version, int) else 0
+
+
+@dataclass
+class QueueRemoval:
+    status: int                      # HTTP status of the read or the write that decided it
+    removed: Optional[str] = None    # the prompt taken out, when one was
+    waiting: int = 0                 # how many are queued now
+    moved: bool = False              # the queue is not what the caller was looking at
+
+
+def remove_from_queue(
+    client: AuthenticatedClient, *, id: str, number: int, is_expected: Optional[Callable[[str], bool]] = None,
+) -> QueueRemoval:
+    """Take the prompt at `number` (1 is the next to run) out of a run's queue.
+
+    Positions shift whenever the server starts a queued prompt, so the caller can pass
+    `is_expected` to say what it believes is at that position; if something else is there
+    nothing is removed. The write quotes the version it read, so a change in between is
+    refused by the server rather than removing the wrong prompt."""
+    from pykiwiai.models.queued_inputs import QueuedInputs
+
+    status, blocks, version = _read_queue(client, id)
+    if status != 200:
+        return QueueRemoval(status)
+    if not 1 <= number <= len(blocks):
+        return QueueRemoval(200, waiting=len(blocks))
+    target = _block_text(blocks[number - 1])
+    if is_expected is not None and not is_expected(target):
+        return QueueRemoval(200, waiting=len(blocks), moved=True)
+    # The blocks go back as they came, so each keeps its author and attachments.
+    kept = blocks[: number - 1] + blocks[number:]
+    resp = update_action_queue_v1_action_results_action_result_id_queue_put.sync_detailed(
+        action_result_id=id, client=client, body=QueuedInputs(inputs=kept, version_number=version),
+    )
+    if resp.status_code == 200:
+        return QueueRemoval(200, removed=target, waiting=len(kept))
+    return QueueRemoval(resp.status_code, waiting=len(blocks), moved=resp.status_code == 409)
+
+
+def clear_queue(client: AuthenticatedClient, *, id: str) -> tuple[int, int]:
+    """Drop every prompt queued on a run. Returns (HTTP status, how many were dropped).
+    The turn in progress is not touched. A prompt the server started, or one queued from
+    elsewhere, between the read and the write makes the write a 409; it is read again
+    and retried once."""
+    from pykiwiai.models.queued_inputs import QueuedInputs
+
+    status = 409
+    for _ in range(2):
+        status, prompts, version = get_queue(client, id=id)
+        if status != 200 or not prompts:
+            return status, 0
+        resp = update_action_queue_v1_action_results_action_result_id_queue_put.sync_detailed(
+            action_result_id=id, client=client,
+            body=QueuedInputs(inputs=[], version_number=version),
+        )
+        status = resp.status_code
+        if status == 200:
+            return 200, len(prompts)
+        if status == 404:
+            # The server keeps no queue for a run nothing was ever queued on.
+            return 200, 0
+        if status != 409:
+            break
+    return status, 0
+
+
+def queue_lines(prompts: list[str], *, width: int = 100) -> list[str]:
+    """The queue as numbered lines, one prompt each, cut to fit."""
+    if not prompts:
+        return ["Nothing is queued."]
+    lines = [f"{len(prompts)} queued, in the order they will run:"]
+    for number, prompt in enumerate(prompts, 1):
+        text = " ".join(prompt.split())
+        room = max(10, width - 6)
+        lines.append(f"  {number}. {text if len(text) <= room else text[: room - 1] + '…'}")
+    return lines
+
+
 # token usage
 
 @dataclass
@@ -550,6 +669,30 @@ def subject_name(subject: dict) -> str:
     return subject.get("name") or f"(unnamed {str(subject.get('subject_id') or '')[:8]})"
 
 
+TRIGGER_LABELS = {"api": "API", "batch": "Batch", "scheduled": "Scheduled", "webhook": "Webhook"}
+
+
+def trigger_label(trigger: Optional[str]) -> str:
+    """A run's trigger as the web dashboard names it. Runs the server could not attribute
+    to a trigger come back as `unknown`."""
+    key = (trigger or "unknown").lower()
+    return TRIGGER_LABELS.get(key) or " ".join(w.capitalize() for w in re.split(r"[_\s-]+", key) if w)
+
+
+def trigger_rows(stats: RunStats) -> list[tuple[str, str, str, str, str]]:
+    """What started the runs, largest share first: label, runs, share, tokens, spend. A run
+    spawned by another run is its own row, so what subagents cost is read off directly."""
+    rows = sorted(stats.data.get("by_trigger") or [], key=lambda x: x.get("runs") or 0, reverse=True)
+    total = sum(x.get("runs") or 0 for x in rows)
+    return [
+        (
+            trigger_label(x.get("trigger")), f"{x.get('runs') or 0:,}", fmt_pct((x.get("runs") or 0) / total),
+            fmt_count(x.get("tokens_total")), fmt_spend(x),
+        )
+        for x in rows if x.get("runs")
+    ]
+
+
 def stats_lines(stats: RunStats) -> list[str]:
     """The run metrics dashboard as plain output lines."""
     if stats.status_code != 200:
@@ -597,12 +740,14 @@ def stats_lines(stats: RunStats) -> list[str]:
                 f"{(m.get('model') or '(unknown)')[:28]:<28} {m.get('runs', 0):>6,} "
                 f"{fmt_count(m.get('tokens_total')):>9} {fmt_spend(m):>10}"
             )
-    triggers = data.get("by_trigger") or []
+    triggers = trigger_rows(stats)
     if triggers:
-        lines += ["", "Triggers      : " + ", ".join(f"{x.get('trigger') or 'unknown'} {x.get('runs', 0):,}" for x in triggers)]
+        header = f"{'Started by':<28} {'Runs':>6} {'Share':>8} {'Tokens':>9} {'Spend':>10}"
+        lines += ["", header, "-" * len(header)]
+        lines += [f"{label[:28]:<28} {runs:>6} {share:>8} {tokens:>9} {spend:>10}" for label, runs, share, tokens, spend in triggers]
     errors = data.get("top_errors") or []
     if errors:
-        lines.append("Failures      : " + ", ".join(f"{x.get('error_class') or 'Unclassified'} {x.get('runs', 0):,}" for x in errors))
+        lines += ["", "Failures      : " + ", ".join(f"{x.get('error_class') or 'Unclassified'} {x.get('runs', 0):,}" for x in errors)]
     return lines
 
 
@@ -620,6 +765,10 @@ Session:
   /new                  Start new conversation
   /status               Show current action & run
   /cancel [run_id]      Cancel a running run (default: current run)
+  /queue <prompt>       Run a prompt after the current turn finishes
+  /queue list           Show the prompts waiting to run
+  /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)
   /usage [run_id]       Show token usage for a run and its subagents (default: current run)
 

{kiwi_code-0.0.45 → kiwi_code-0.0.50}/src/kiwi_runtime/sessions.py

@@ -398,6 +398,19 @@ if not IS_WINDOWS:
             except Exception:
                 return False
 
+else:
+
+    class PTYProcess:  # type: ignore[no-redef]
+        """Stands in for the Unix PTY session on Windows, where there is no pty module.
+
+        The name has to exist so that modules importing it load on every platform; the
+        handlers only ever construct it when not on Windows, so this is never built.
+        """
+
+        def __init__(self, *args, **kwargs) -> None:
+            raise RuntimeError("PTY sessions are not available on Windows; use PipeProcess.")
+
+
 class PipeProcess:
     """Manages a persistent shell session using subprocess pipes (Windows-compatible)."""