deepy-cli 0.2.4__tar.gz → 0.2.5__tar.gz

{deepy_cli-0.2.4 → deepy_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.4
+Version: 0.2.5
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko

{deepy_cli-0.2.4 → deepy_cli-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.4"
+version = "0.2.5"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.2.4 → deepy_cli-0.2.5}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 
 def main() -> None:

{deepy_cli-0.2.4 → deepy_cli-0.2.5}/src/deepy/llm/runner.py

@@ -25,6 +25,11 @@ from .events import DeepyStreamEvent, normalize_stream_event
 from .provider import ProviderBundle, build_provider_bundle
 
 DEFAULT_MAX_TURNS = 100
+INTERRUPTED_MARKER_TEXT = (
+    "Interrupted by user with Esc. This turn was stopped before completion. "
+    "Do not continue the interrupted request unless the user explicitly asks to continue."
+)
+INTERRUPTED_TOOL_OUTPUT_TEXT = "Tool execution interrupted by user with Esc."
 
 
 @dataclass(frozen=True)
@@ -128,6 +133,7 @@ async def run_prompt_once(
     pending_questions: list[dict[str, Any]] = []
     usage = TokenUsage()
     interrupt_task: asyncio.Task[bool] | None = None
+    session_baseline_count = len(await session.get_items())
     try:
         result = Runner.run_streamed(
             agent,
@@ -272,6 +278,12 @@ async def run_prompt_once(
         raise
 
     interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
+    if interrupted:
+        await _reconcile_interrupted_session_tail(
+            session,
+            baseline_count=session_baseline_count,
+            prompt=prompt,
+        )
 
     final_output = getattr(result, "final_output", None)
     output = final_output if isinstance(final_output, str) else "".join(chunks)
@@ -512,6 +524,143 @@ async def _finish_interrupt_task(task: asyncio.Task[bool] | None) -> bool:
     return False
 
 
+async def _reconcile_interrupted_session_tail(
+    session: DeepyJsonlSession,
+    *,
+    baseline_count: int,
+    prompt: str,
+) -> None:
+    items = await session.get_items()
+    if baseline_count < 0 or baseline_count > len(items):
+        return
+    suffix = items[baseline_count:]
+    if not suffix:
+        return
+
+    if len(suffix) == 1 and _is_user_prompt_item(suffix[0], prompt):
+        await session.pop_item()
+        return
+
+    additions = _interrupted_tool_output_items(suffix)
+    if not _is_interrupt_marker_item(suffix[-1]):
+        additions.append(_interrupted_marker_item())
+    if additions:
+        await session.add_items(additions)
+
+
+def _is_user_prompt_item(item: dict[str, Any], prompt: str) -> bool:
+    if item.get("role") != "user":
+        return False
+    return _item_text_content(item) == prompt
+
+
+def _item_text_content(item: dict[str, Any]) -> str:
+    content = item.get("content")
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for part in content:
+        if isinstance(part, dict):
+            text = part.get("text")
+            if text is None:
+                text = part.get("input_text")
+            if isinstance(text, str):
+                parts.append(text)
+    return "".join(parts)
+
+
+def _interrupted_tool_output_items(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    output_call_ids = {
+        call_id
+        for item in items
+        if (call_id := _function_call_output_id(item))
+    }
+    additions: list[dict[str, Any]] = []
+    added_call_ids: set[str] = set()
+    for item in items:
+        for call_id, output_item in _missing_output_items_for_call(item, output_call_ids):
+            if call_id in added_call_ids:
+                continue
+            additions.append(output_item)
+            added_call_ids.add(call_id)
+    return additions
+
+
+def _missing_output_items_for_call(
+    item: dict[str, Any],
+    output_call_ids: set[str],
+) -> list[tuple[str, dict[str, Any]]]:
+    call_id = _function_call_id(item)
+    if call_id:
+        return (
+            []
+            if call_id in output_call_ids
+            else [
+                (
+                    call_id,
+                    {
+                        "type": "function_call_output",
+                        "call_id": call_id,
+                        "output": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                    },
+                )
+            ]
+        )
+
+    missing: list[tuple[str, dict[str, Any]]] = []
+    if item.get("role") != "assistant":
+        return missing
+    tool_calls = item.get("tool_calls")
+    if not isinstance(tool_calls, list):
+        return missing
+    for tool_call in tool_calls:
+        if not isinstance(tool_call, dict):
+            continue
+        chat_call_id = tool_call.get("id")
+        if not isinstance(chat_call_id, str) or not chat_call_id or chat_call_id in output_call_ids:
+            continue
+        missing.append(
+            (
+                chat_call_id,
+                {
+                    "role": "tool",
+                    "tool_call_id": chat_call_id,
+                    "content": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                },
+            )
+        )
+    return missing
+
+
+def _function_call_id(item: dict[str, Any]) -> str:
+    if item.get("type") != "function_call":
+        return ""
+    call_id = item.get("call_id")
+    if call_id is None:
+        call_id = item.get("id")
+    return call_id if isinstance(call_id, str) else ""
+
+
+def _function_call_output_id(item: dict[str, Any]) -> str:
+    if item.get("type") == "function_call_output":
+        call_id = item.get("call_id")
+        return call_id if isinstance(call_id, str) else ""
+    if item.get("role") == "tool":
+        tool_call_id = item.get("tool_call_id")
+        return tool_call_id if isinstance(tool_call_id, str) else ""
+    return ""
+
+
+def _interrupted_marker_item() -> dict[str, Any]:
+    return {"role": "assistant", "content": INTERRUPTED_MARKER_TEXT}
+
+
+def _is_interrupt_marker_item(item: dict[str, Any]) -> bool:
+    return item.get("role") == "assistant" and item.get("content") == INTERRUPTED_MARKER_TEXT
+
+
 def _pending_questions_from_tool_output(output: str) -> list[dict[str, Any]]:
     if not output.strip():
         return []