alloy-runtime-cli 0.2.63__tar.gz → 0.2.64__tar.gz

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.63
+Version: 0.2.64
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.2.3
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.63
-Requires-Dist: alloy-runtime-types==0.2.63
+Requires-Dist: alloy-runtime-sdk==0.2.64
+Requires-Dist: alloy-runtime-types==0.2.64
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -65,6 +65,10 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+Running `alloy` without a subcommand launches the Textual TUI. TUI chat uses the
+standard non-streaming generation path, so it works with agents that have tools
+configured. Responses appear once the full turn completes rather than token-by-token.
+
 For live model-execution inspection, use:
 
 ```bash
@@ -101,4 +105,3 @@ Use `alloy login` to save an API key locally, or set the environment variables w
 running on a VPS.
 
 CLI release trigger: no functional changes.
-

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/README.md

@@ -43,6 +43,10 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+Running `alloy` without a subcommand launches the Textual TUI. TUI chat uses the
+standard non-streaming generation path, so it works with agents that have tools
+configured. Responses appear once the full turn completes rather than token-by-token.
+
 For live model-execution inspection, use:
 
 ```bash
@@ -79,4 +83,3 @@ Use `alloy login` to save an API key locally, or set the environment variables w
 running on a VPS.
 
 CLI release trigger: no functional changes.
-

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/alloy_runtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.63
+Version: 0.2.64
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.2.3
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.63
-Requires-Dist: alloy-runtime-types==0.2.63
+Requires-Dist: alloy-runtime-sdk==0.2.64
+Requires-Dist: alloy-runtime-types==0.2.64
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -65,6 +65,10 @@ Use `alloy --format compact` for the existing psql-style human-readable record v
 Use `alloy --format table` for Rich table output in the non-TUI CLI.
 Use `alloy --format json` for automation-friendly machine-readable output.
 
+Running `alloy` without a subcommand launches the Textual TUI. TUI chat uses the
+standard non-streaming generation path, so it works with agents that have tools
+configured. Responses appear once the full turn completes rather than token-by-token.
+
 For live model-execution inspection, use:
 
 ```bash
@@ -101,4 +105,3 @@ Use `alloy login` to save an API key locally, or set the environment variables w
 running on a VPS.
 
 CLI release trigger: no functional changes.
-

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/alloy_runtime_cli.egg-info/requires.txt

@@ -4,6 +4,6 @@ textual==8.2.3
 genson==1.3.0
 pyperclip==1.11.0
 prompt-toolkit==3.0.52
-alloy-runtime-sdk==0.2.63
-alloy-runtime-types==0.2.63
+alloy-runtime-sdk==0.2.64
+alloy-runtime-types==0.2.64
 trogon==0.6.0

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/commands/knowledge/documents/list/command.py

@@ -19,6 +19,11 @@ def knowledge_documents_list_command(
         "--status",
         help="Filter by status: queued|processing|completed|failed|duplicate|filtered",
     ),
+    external_id: str | None = typer.Option(
+        None,
+        "--external-id",
+        help="Filter by exact external_id match",
+    ),
     limit: int = typer.Option(
         50,
         "-l",
@@ -40,6 +45,7 @@ def knowledge_documents_list_command(
         alloy knowledge documents list
         alloy knowledge documents list -C my-collection
         alloy knowledge documents list -s completed -l 20
+        alloy knowledge documents list --external-id crm-123
         alloy knowledge documents list -s duplicate
         alloy knowledge documents list -s filtered
         alloy knowledge documents list --status failed
@@ -47,6 +53,7 @@ def knowledge_documents_list_command(
     _execute_list(
         collection_id=collection,
         processing_status=status,
+        external_id=external_id,
         limit=limit,
         offset=offset,
     )
@@ -56,6 +63,7 @@ def knowledge_documents_list_command(
 async def _execute_list(
     collection_id: str | None,
     processing_status: str | None,
+    external_id: str | None,
     limit: int,
     offset: int,
 ) -> None:
@@ -66,6 +74,7 @@ async def _execute_list(
             offset=offset,
             collection_id=collection_id,
             processing_status=processing_status,
+            external_id=external_id,
         )
 
     present_documents_list(response)

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/commands/regenerate.py

@@ -1,7 +1,6 @@
 """Command for regenerating the last AI response."""
 
 from dataclasses import dataclass
-from typing import Callable
 from uuid import UUID
 
 from alloy_runtime_sdk.api_client.client import ApiClient
@@ -28,17 +27,16 @@ class RegenerateCommand:
     - Model mode: Uses provider_key/provider_model_name/system_instruction directly
 
     This command:
-    1. Transitions store to STREAMING phase
+    1. Transitions store to SENDING phase
     2. Sends a regenerate request to the API
-    3. Streams the new response chunks via callbacks (content and thinking)
-    4. Transitions back to IDLE when complete
+    3. Waits for the final non-streaming response
+    4. Leaves the store in SENDING on success so the caller can reload persisted
+       messages before clearing the waiting state
 
     Attributes:
         client: Server client for API calls.
         store: Chat store for state management.
         session_id: ID of the current chat session.
-        on_chunk: Callback invoked with each streamed text chunk.
-        on_thinking_chunk: Callback invoked with each reasoning/thinking chunk.
         agent_id: ID of the agent to use for regeneration (agent mode).
         provider_key: Provider key (model mode).
         provider_model_name: Model name (model mode).
@@ -48,8 +46,6 @@ class RegenerateCommand:
     client: ApiClient
     store: ChatStore
     session_id: UUID
-    on_chunk: Callable[[str], None]
-    on_thinking_chunk: Callable[[str], None] | None = None
     # Agent mode
     agent_id: UUID | None = None
     # Model mode
@@ -64,9 +60,8 @@ class RegenerateCommand:
             CommandResult indicating success or failure.
         """
         logger.info("regenerate_starting", session_id=str(self.session_id))
-        self.store.start_streaming()
+        self.store.start_generation()
 
-        was_cancelled = False
         try:
             # Build model source based on mode
             if self.agent_id is not None:
@@ -77,6 +72,7 @@ class RegenerateCommand:
                     provider_model_name=self.provider_model_name,
                 )
             else:
+                self.store.finish_generation()
                 return CommandResult[None](
                     success=False,
                     error="No agent or model configured for this session",
@@ -86,7 +82,7 @@ class RegenerateCommand:
                 model_source=model_source,
                 chat_session_id=self.session_id,
                 regenerate=True,
-                stream=True,
+                stream=False,
                 tags=[],
                 # Only include system instruction for model mode
                 system_instruction=self.system_instruction
@@ -94,27 +90,12 @@ class RegenerateCommand:
                 else None,
             )
 
-            async for chunk in self.client.generate_text_stream(request):
-                # Check for cancellation request
-                if self.store.state.cancel_requested:
-                    logger.info("regenerate_cancelled_by_user")
-                    was_cancelled = True
-                    return CommandResult[None](success=True, data=None)
-
-                # Handle thinking/reasoning chunks
-                if chunk.chunk_type == "thinking" and chunk.reasoning_content:
-                    if self.on_thinking_chunk:
-                        self.on_thinking_chunk(chunk.reasoning_content)
-                # Handle regular text content chunks
-                elif chunk.content:
-                    self.on_chunk(chunk.content)
+            await self.client.generate_text(request)
 
             logger.info("regenerate_completed")
             return CommandResult[None](success=True, data=None)
 
         except Exception as e:
             logger.warning("regenerate_failed", error=str(e))
+            self.store.finish_generation()
             return CommandResult[None](success=False, error=str(e))
-
-        finally:
-            self.store.finish_streaming(cancelled=was_cancelled)

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/commands/reload_session.py

@@ -59,5 +59,4 @@ class ReloadSessionCommand:
             )
 
         except Exception as e:
-            # Silently fail for reload - the user already saw the response
             return CommandResult[ReloadSessionResult](success=False, error=str(e))

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/commands/send_message.py

@@ -1,4 +1,4 @@
-"""Command for sending a message and streaming the response."""
+"""Command for sending a message and waiting for the final response."""
 
 from dataclasses import dataclass
 from typing import Callable
@@ -24,7 +24,7 @@ logger = get_logger(__name__)
 
 @dataclass
 class SendMessageCommand:
-    """Command to send a user message and stream the AI response.
+    """Command to send a user message and await the final AI response.
 
     Supports two modes:
     - Agent mode: Uses agent_id to determine model and system instruction
@@ -38,18 +38,17 @@ class SendMessageCommand:
 
     This command:
     1. Resolves any injection patterns in the message
-    2. Transitions store to STREAMING phase
+    2. Transitions store to SENDING phase
     3. Builds and sends the generation request
-    4. Streams response chunks via callbacks (content and thinking)
-    5. Transitions back to IDLE when complete
+    4. Waits for the final response from the non-streaming API
+    5. Leaves the store in SENDING on success so the caller can reload persisted
+       messages before clearing the optimistic pending state
 
     Attributes:
         client: Server client for API calls.
         store: Chat store for state management.
         session_id: ID of the current chat session.
         user_message: The user's message to send.
-        on_chunk: Callback invoked with each streamed text chunk.
-        on_thinking_chunk: Callback invoked with each reasoning/thinking chunk.
         agent_id: ID of the agent to use for generation (agent mode).
         provider_key: Provider key (model mode).
         provider_model_name: Model name (model mode).
@@ -62,8 +61,6 @@ class SendMessageCommand:
     store: ChatStore
     session_id: UUID
     user_message: str
-    on_chunk: Callable[[str], None]
-    on_thinking_chunk: Callable[[str], None] | None = None
     # Agent mode
     agent_id: UUID | None = None
     # Model mode
@@ -75,7 +72,7 @@ class SendMessageCommand:
     on_injection_resolved: Callable[[ResolvedMessage], None] | None = None
 
     async def execute(self) -> CommandResult[None]:
-        """Execute the send message and stream operation.
+        """Execute the send message operation.
 
         Returns:
             CommandResult indicating success or failure.
@@ -123,11 +120,9 @@ class SendMessageCommand:
                     error=f"Failed to resolve injections: {e}",
                 )
 
-        # Start streaming with the user message shown optimistically
+        # Start generation with the user message shown optimistically
         # Note: We show the original message, not the resolved one
-        self.store.start_streaming(user_message=self.user_message)
-
-        was_cancelled = False
+        self.store.start_generation(user_message=self.user_message)
         try:
             # Build model source based on mode
             if self.agent_id is not None:
@@ -138,6 +133,7 @@ class SendMessageCommand:
                     provider_model_name=self.provider_model_name,
                 )
             else:
+                self.store.finish_generation()
                 return CommandResult[None](
                     success=False,
                     error="No agent or model configured for this session",
@@ -146,7 +142,7 @@ class SendMessageCommand:
             request = GenerateTextRequest(
                 model_source=model_source,
                 user_message=message_to_send,  # Use resolved message
-                stream=True,
+                stream=False,
                 tags=[],
                 chat_session_id=self.session_id,
                 # Only include system instruction for model mode
@@ -155,36 +151,11 @@ class SendMessageCommand:
                 else None,
             )
 
-            async for chunk in self.client.generate_text_stream(request):
-                # Check for cancellation request
-                if self.store.state.cancel_requested:
-                    logger.info("stream_cancelled_by_user")
-                    was_cancelled = True
-                    return CommandResult[None](success=True, data=None)
-
-                # Debug: log chunk info for first few chunks
-                logger.debug(
-                    "stream_chunk",
-                    extra={
-                        "chunk_type": chunk.chunk_type,
-                        "has_content": bool(chunk.content),
-                        "has_reasoning": bool(chunk.reasoning_content),
-                        "sequence": chunk.sequence,
-                    },
-                )
-
-                # Handle thinking/reasoning chunks
-                if chunk.chunk_type == "thinking" and chunk.reasoning_content:
-                    if self.on_thinking_chunk:
-                        self.on_thinking_chunk(chunk.reasoning_content)
-                # Handle regular text content chunks
-                elif chunk.content:
-                    self.on_chunk(chunk.content)
+            await self.client.generate_text(request)
 
             return CommandResult[None](success=True, data=None)
 
         except Exception as e:
+            logger.warning("send_message_failed", error=str(e))
+            self.store.finish_generation()
             return CommandResult[None](success=False, error=str(e))
-
-        finally:
-            self.store.finish_streaming(cancelled=was_cancelled)

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/messages.py

@@ -89,44 +89,6 @@ class UndoRequested(Message):
     pass
 
 
-# =============================================================================
-# Streaming Events
-# =============================================================================
-
-
-class StreamingStarted(Message):
-    """Response streaming has begun."""
-
-    def __init__(self, execution_id: UUID) -> None:
-        self.execution_id = execution_id
-        super().__init__()
-
-
-class StreamingChunk(Message):
-    """A chunk of streamed content received."""
-
-    def __init__(self, content: str, is_reasoning: bool = False) -> None:
-        self.content = content
-        self.is_reasoning = is_reasoning
-        super().__init__()
-
-
-class StreamingCompleted(Message):
-    """Response streaming finished successfully."""
-
-    def __init__(self, full_content: str) -> None:
-        self.full_content = full_content
-        super().__init__()
-
-
-class StreamingError(Message):
-    """Error occurred during streaming."""
-
-    def __init__(self, error: str) -> None:
-        self.error = error
-        super().__init__()
-
-
 # =============================================================================
 # UI Events
 # =============================================================================

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/pane.py

@@ -25,7 +25,7 @@ class ChatPane(Widget):
 
     This widget contains the main chat interface components:
     - ChatHeader: Shows current session/model info
-    - MessageDisplay: Shows message history and streaming content
+    - MessageDisplay: Shows message history and pending request state
     - ChatInput: Text input for composing messages
 
     Each pane has its own ChatStore, allowing independent sessions

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/renderers/markdown.py

@@ -1,9 +1,4 @@
-"""Markdown renderer for chat messages.
-
-Renders messages with Rich markdown formatting for display in Textual widgets.
-Uses Rich's Markdown class to properly render markdown syntax (headers, code blocks,
-lists, etc.) in assistant responses.
-"""
+"""Markdown renderer for chat messages."""
 
 from datetime import datetime
 
@@ -18,9 +13,6 @@ from cli.tui.chat.renderers.base import (
 )
 from cli.tui.chat.types import extract_thinking_content, format_time
 
-# Spinner frames for streaming indicator
-SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-
 # Color for thinking/reasoning blocks
 THINKING_COLOR = "#bb9af7"  # tokyo-night purple accent
 
@@ -33,36 +25,29 @@ class MarkdownRenderer:
         - Assistant messages rendered as proper markdown (code blocks, headers, etc.)
         - Agent/model name in header
         - Timestamps on each message
-        - Spinner during streaming
         - Optimistic user message display
+        - Waiting indicator while a response is in flight
         - Thinking/reasoning blocks with distinctive styling
 
     This is the default renderer for the chat interface. It uses Rich's Markdown
     class to properly render markdown syntax in assistant responses.
     """
 
-    def __init__(self) -> None:
-        self._spinner_frame = 0
-
     def render(
         self,
         messages: tuple[MessageResponse, ...],
-        streaming_content: str = "",
-        streaming_thinking_content: str = "",
         pending_user_message: str | None = None,
         assistant_name: str = "Assistant",
-        is_streaming: bool = False,
+        is_generating: bool = False,
         thinking_collapsed: bool = False,
     ) -> Group:
         """Render messages to a Rich Group with proper markdown formatting.
 
         Args:
             messages: Tuple of message responses to render.
-            streaming_content: Partial content being streamed (appended to end).
-            streaming_thinking_content: Partial thinking/reasoning content being streamed.
             pending_user_message: User message shown optimistically before server confirms.
             assistant_name: Name to display for assistant (agent name or model).
-            is_streaming: Whether currently streaming a response.
+            is_generating: Whether currently waiting for the final response.
             thinking_collapsed: Whether thinking blocks should be collapsed.
 
         Returns:
@@ -89,11 +74,10 @@ class MarkdownRenderer:
                 # For assistant messages, check for thinking content
                 thinking_content = extract_thinking_content(msg)
                 if thinking_content:
-                    # Render thinking block (not streaming, use collapsed setting)
+                    # Render any persisted thinking block using the collapse setting.
                     renderables.append(
                         self._render_thinking_block_renderable(
                             thinking_content,
-                            is_streaming=False,
                             collapsed=thinking_collapsed,
                         )
                     )
@@ -116,66 +100,38 @@ class MarkdownRenderer:
             renderables.append(Text(pending_user_message))
             renderables.append(Text(""))
 
-        # Show streaming thinking/reasoning block
-        if streaming_thinking_content:
-            renderables.append(
-                self._render_thinking_block_renderable(
-                    streaming_thinking_content, is_streaming, thinking_collapsed
-                )
-            )
-            renderables.append(Text(""))
-
-        # Show streaming response with spinner
-        if is_streaming or streaming_content:
-            spinner = self._get_spinner() if is_streaming else ""
-            if streaming_content:
-                header = Text()
-                header.append(f"{assistant_name}:", style=f"bold {assistant_color}")
-                header.append(f" {spinner}", style="yellow")
-                renderables.append(header)
-                # Render streaming content as markdown too
-                renderables.append(Markdown(streaming_content))
-            elif not streaming_thinking_content:
-                # Only show "Thinking..." if we don't have actual thinking content
-                header = Text()
-                header.append(f"{assistant_name}:", style=f"bold {assistant_color}")
-                header.append(f" {spinner}", style="yellow")
-                renderables.append(header)
-                renderables.append(Text("Waiting for response...", style="dim"))
+        if is_generating:
+            header = Text(f"{assistant_name}:", style=f"bold {assistant_color}")
+            renderables.append(header)
+            renderables.append(Text("Waiting for response...", style="dim"))
 
         return Group(*renderables)
 
     def _render_thinking_block_renderable(
         self,
         content: str,
-        is_streaming: bool = False,
         collapsed: bool = False,
     ) -> Text:
         """Render a thinking/reasoning block with distinctive styling.
 
         Args:
             content: The thinking content to render.
-            is_streaming: Whether the thinking is still streaming.
             collapsed: Whether to show collapsed view.
 
         Returns:
             Rich Text object for the thinking block.
         """
-        spinner = self._get_spinner() if is_streaming else ""
-
         if collapsed:
             # Show collapsed indicator with line count
             line_count = content.count("\n") + 1
             result = Text()
-            result.append(
-                f"◆ Thinking ({line_count} lines)... {spinner}", style=THINKING_COLOR
-            )
+            result.append(f"◆ Thinking ({line_count} lines)...", style=THINKING_COLOR)
             result.append(" (expand with /thinking)", style="dim")
             return result
 
         # Full thinking block with border styling
         lines: list[str] = []
-        lines.append(f"◆ Thinking {spinner}")
+        lines.append("◆ Thinking")
 
         # Indent and dim the thinking content
         for line in content.split("\n"):
@@ -187,9 +143,3 @@ class MarkdownRenderer:
             result.append(line + "\n", style="dim italic")
 
         return result
-
-    def _get_spinner(self) -> str:
-        """Get the current spinner frame and advance to next."""
-        frame = SPINNER_FRAMES[self._spinner_frame % len(SPINNER_FRAMES)]
-        self._spinner_frame += 1
-        return frame

{alloy_runtime_cli-0.2.63 → alloy_runtime_cli-0.2.64}/cli/tui/chat/renderers/plain.py

@@ -25,22 +25,18 @@ class PlainTextRenderer:
     def render(
         self,
         messages: tuple[MessageResponse, ...],
-        streaming_content: str = "",
-        streaming_thinking_content: str = "",
         pending_user_message: str | None = None,
         assistant_name: str = "Assistant",
-        is_streaming: bool = False,
+        is_generating: bool = False,
         thinking_collapsed: bool = False,
     ) -> str:
         """Render messages to a plain text string.
 
         Args:
             messages: Tuple of message responses to render.
-            streaming_content: Partial content being streamed (appended to end).
-            streaming_thinking_content: Partial thinking/reasoning content (ignored in plain).
             pending_user_message: User message shown optimistically before server confirms.
             assistant_name: Name to display for assistant (agent name or model).
-            is_streaming: Whether currently streaming a response.
+            is_generating: Whether currently waiting for the final response.
             thinking_collapsed: Whether thinking blocks are collapsed (ignored in plain).
 
         Returns:
@@ -68,12 +64,9 @@ class PlainTextRenderer:
             lines.append(pending_user_message)
             lines.append("")
 
-        # Show streaming response
-        if streaming_content or is_streaming:
+        # Show in-flight response placeholder
+        if is_generating:
             lines.append(f"{assistant_name}:")
-            if streaming_content:
-                lines.append(streaming_content)
-            else:
-                lines.append("...")
+            lines.append("Waiting for response...")
 
         return "\n".join(lines)