indent 0.1.17__tar.gz → 0.1.19__tar.gz

{indent-0.1.17 → indent-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indent
-Version: 0.1.17
+Version: 0.1.19
 Summary: Indent is an AI Pair Programmer
 Author-email: Sashank Thupukari <sashank@exponent.run>
 Requires-Python: <3.13,>=3.10

{indent-0.1.17 → indent-0.1.19}/exponent/__init__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.17'
-__version_tuple__ = version_tuple = (0, 1, 17)
+__version__ = version = '0.1.19'
+__version_tuple__ = version_tuple = (0, 1, 19)
 
 __commit_id__ = commit_id = None

{indent-0.1.17 → indent-0.1.19}/exponent/core/remote_execution/cli_rpc_types.py

@@ -51,6 +51,7 @@ class ErrorToolResult(ToolResult, tag="error"):
 
 
 READ_TOOL_NAME = "read"
+READ_TOOL_ARTIFACT_NAME = "read_tool_artifact"
 
 
 class ReadToolInput(ToolInput, tag=READ_TOOL_NAME):
@@ -80,6 +81,15 @@ class ReadToolResult(ToolResult, tag=READ_TOOL_NAME):
         return "\n".join(lines)
 
 
+class ReadToolArtifactResult(ToolResult, tag=READ_TOOL_ARTIFACT_NAME):
+    s3_uri: str
+    file_path: str
+    media_type: str
+
+    def to_text(self) -> str:
+        return f"[Image artifact uploaded to {self.s3_uri}]"
+
+
 LIST_TOOL_NAME = "ls"
 
 
@@ -217,6 +227,7 @@ PartialToolResultType = PartialBashToolResult
 
 ToolResultType = (
     ReadToolResult
+    | ReadToolArtifactResult
     | WriteToolResult
     | ListToolResult
     | GlobToolResult
@@ -273,6 +284,16 @@ class KeepAliveCliChatResponse(msgspec.Struct, tag="keep_alive_cli_chat"):
     pass
 
 
+class GenerateUploadUrlRequest(msgspec.Struct, tag="generate_upload_url"):
+    s3_key: str
+    content_type: str
+
+
+class GenerateUploadUrlResponse(msgspec.Struct, tag="generate_upload_url"):
+    upload_url: str
+    s3_uri: str
+
+
 class CliRpcRequest(msgspec.Struct):
     request_id: str
     request: (
@@ -283,6 +304,7 @@ class CliRpcRequest(msgspec.Struct):
         | BatchToolExecutionRequest
         | SwitchCLIChatRequest
         | KeepAliveCliChatRequest
+        | GenerateUploadUrlRequest
     )
 
 
@@ -305,4 +327,5 @@ class CliRpcResponse(msgspec.Struct):
         | HttpResponse
         | SwitchCLIChatResponse
         | KeepAliveCliChatResponse
+        | GenerateUploadUrlResponse
     )

{indent-0.1.17 → indent-0.1.19}/exponent/core/remote_execution/client.py

@@ -31,6 +31,8 @@ from exponent.core.remote_execution.cli_rpc_types import (
     CliRpcResponse,
     ErrorResponse,
     ErrorToolResult,
+    GenerateUploadUrlRequest,
+    GenerateUploadUrlResponse,
     GetAllFilesRequest,
     GetAllFilesResponse,
     HttpRequest,
@@ -115,6 +117,13 @@ class RemoteExecutionClient:
         # Track last request time for timeout functionality
         self._last_request_time: float | None = None
 
+        # Track pending upload URL requests
+        self._pending_upload_requests: dict[
+            str, asyncio.Future[GenerateUploadUrlResponse]
+        ] = {}
+        self._upload_request_lock = asyncio.Lock()
+        self._websocket: ClientConnection | None = None
+
     @property
     def working_directory(self) -> str:
         return self.current_session.working_directory
@@ -186,7 +195,21 @@ class RemoteExecutionClient:
         self._last_request_time = time.time()
 
         msg_data = json.loads(msg)
-        if msg_data["type"] != "request":
+        if msg_data["type"] == "result":
+            data = json.dumps(msg_data["data"])
+            try:
+                response = msgspec.json.decode(data, type=CliRpcResponse)
+                if isinstance(response.response, GenerateUploadUrlResponse):
+                    async with self._upload_request_lock:
+                        if response.request_id in self._pending_upload_requests:
+                            future = self._pending_upload_requests.pop(
+                                response.request_id
+                            )
+                            future.set_result(response.response)
+            except Exception as e:
+                logger.error(f"Error handling upload URL response: {e}")
+            return None
+        elif msg_data["type"] != "request":
             return None
 
         data = json.dumps(msg_data["data"])
@@ -445,6 +468,8 @@ class RemoteExecutionClient:
         if connection_tracker is not None:
             await connection_tracker.set_connected(True)
 
+        self._websocket = websocket
+
         beats: asyncio.Queue[HeartbeatInfo] = asyncio.Queue()
         requests: asyncio.Queue[CliRpcRequest] = asyncio.Queue()
         results: asyncio.Queue[CliRpcResponse] = asyncio.Queue()
@@ -579,6 +604,38 @@ class RemoteExecutionClient:
         logger.info(f"Heartbeat response: {connected_state}")
         return connected_state
 
+    async def request_upload_url(
+        self, s3_key: str, content_type: str
+    ) -> GenerateUploadUrlResponse:
+        if self._websocket is None:
+            raise RuntimeError("No active websocket connection")
+
+        request_id = str(uuid.uuid4())
+        request = CliRpcRequest(
+            request_id=request_id,
+            request=GenerateUploadUrlRequest(s3_key=s3_key, content_type=content_type),
+        )
+
+        future: asyncio.Future[GenerateUploadUrlResponse] = asyncio.Future()
+        async with self._upload_request_lock:
+            self._pending_upload_requests[request_id] = future
+
+        try:
+            await self._websocket.send(
+                json.dumps({"type": "request", "data": msgspec.to_builtins(request)})
+            )
+
+            response = await asyncio.wait_for(future, timeout=30)
+            return response
+        except TimeoutError:
+            async with self._upload_request_lock:
+                self._pending_upload_requests.pop(request_id, None)
+            raise RuntimeError("Timeout waiting for upload URL response")
+        except Exception as e:
+            async with self._upload_request_lock:
+                self._pending_upload_requests.pop(request_id, None)
+            raise e
+
     async def handle_request(self, request: CliRpcRequest) -> CliRpcResponse:
         # Update last request time for timeout functionality
         self._last_request_time = time.time()
@@ -593,7 +650,7 @@ class RemoteExecutionClient:
                     )
                 else:
                     raw_result = await execute_tool(  # type: ignore[assignment]
-                        request.request.tool_input, self.working_directory
+                        request.request.tool_input, self.working_directory, self
                     )
                 tool_result = truncate_result(raw_result)
                 return CliRpcResponse(
@@ -620,7 +677,9 @@ class RemoteExecutionClient:
                             )
                         )
                     else:
-                        coros.append(execute_tool(tool_input, self.working_directory))
+                        coros.append(
+                            execute_tool(tool_input, self.working_directory, self)
+                        )
 
                 results: list[ToolResultType | BaseException] = await asyncio.gather(
                     *coros, return_exceptions=True

{indent-0.1.17 → indent-0.1.19}/exponent/core/remote_execution/tool_execution.py

@@ -1,8 +1,10 @@
+import asyncio
 import logging
 import uuid
 from collections.abc import Callable
 from pathlib import Path
 from time import time
+from typing import TYPE_CHECKING
 
 from anyio import Path as AsyncPath
 
@@ -19,6 +21,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
     GrepToolResult,
     ListToolInput,
     ListToolResult,
+    ReadToolArtifactResult,
     ReadToolInput,
     ReadToolResult,
     ToolInputType,
@@ -26,6 +29,9 @@ from exponent.core.remote_execution.cli_rpc_types import (
     WriteToolInput,
     WriteToolResult,
 )
+
+if TYPE_CHECKING:
+    from exponent.core.remote_execution.client import RemoteExecutionClient
 from exponent.core.remote_execution.code_execution import (
     execute_code_streaming,
 )
@@ -45,10 +51,12 @@ logger = logging.getLogger(__name__)
 
 
 async def execute_tool(
-    tool_input: ToolInputType, working_directory: str
+    tool_input: ToolInputType,
+    working_directory: str,
+    upload_client: "RemoteExecutionClient | None" = None,
 ) -> ToolResultType:
     if isinstance(tool_input, ReadToolInput):
-        return await execute_read_file(tool_input, working_directory)
+        return await execute_read_file(tool_input, working_directory, upload_client)
     elif isinstance(tool_input, WriteToolInput):
         return await execute_write_file(tool_input, working_directory)
     elif isinstance(tool_input, ListToolInput):
@@ -69,9 +77,20 @@ def truncate_result[T: ToolResultType](tool_result: T) -> T:
     return truncate_tool_result(tool_result)
 
 
+def is_image_file(file_path: str) -> tuple[bool, str | None]:
+    ext = Path(file_path).suffix.lower()
+    if ext == ".png":
+        return (True, "image/png")
+    elif ext in [".jpg", ".jpeg"]:
+        return (True, "image/jpeg")
+    return (False, None)
+
+
 async def execute_read_file(  # noqa: PLR0911, PLR0915
-    tool_input: ReadToolInput, working_directory: str
-) -> ReadToolResult | ErrorToolResult:
+    tool_input: ReadToolInput,
+    working_directory: str,
+    upload_client: "RemoteExecutionClient | None" = None,
+) -> ReadToolResult | ReadToolArtifactResult | ErrorToolResult:
     # Validate absolute path requirement
     if not tool_input.file_path.startswith("/"):
         return ErrorToolResult(
@@ -87,6 +106,44 @@ async def execute_read_file(  # noqa: PLR0911, PLR0915
 
     file = AsyncPath(working_directory, tool_input.file_path)
 
+    # Check if this is an image file and we have an upload client
+    is_image, media_type = is_image_file(tool_input.file_path)
+    if is_image and media_type and upload_client is not None:
+        try:
+            import urllib.request
+
+            file_name = Path(tool_input.file_path).name
+            s3_key = f"images/{uuid.uuid4()}/{file_name}"
+
+            upload_response = await upload_client.request_upload_url(s3_key, media_type)
+
+            f = await file.open("rb")
+            async with f:
+                file_data = await f.read()
+
+                def _upload() -> int:
+                    req = urllib.request.Request(
+                        upload_response.upload_url,
+                        data=file_data,
+                        headers={"Content-Type": media_type},
+                        method="PUT",
+                    )
+                    with urllib.request.urlopen(req) as resp:
+                        status: int = resp.status
+                        return status
+
+                status = await asyncio.to_thread(_upload)
+                if status != 200:
+                    raise RuntimeError(f"Upload failed with status {status}")
+
+            return ReadToolArtifactResult(
+                s3_uri=upload_response.s3_uri,
+                file_path=tool_input.file_path,
+                media_type=media_type,
+            )
+        except Exception as e:
+            return ErrorToolResult(error_message=f"Failed to upload image to S3: {e!s}")
+
     try:
         exists = await file.exists()
     except (OSError, PermissionError) as e:

{indent-0.1.17 → indent-0.1.19}/exponent/core/remote_execution/truncation.py

@@ -11,6 +11,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
     GlobToolResult,
     GrepToolResult,
     ListToolResult,
+    ReadToolArtifactResult,
     ReadToolResult,
     ToolResult,
     WriteToolResult,
@@ -173,6 +174,14 @@ class TailTruncation(TruncationStrategy):
         return replace(result, **updates)
 
 
+class NoOpTruncation(TruncationStrategy):
+    def should_truncate(self, result: ToolResult) -> bool:
+        return False
+
+    def truncate(self, result: ToolResult) -> ToolResult:
+        return result
+
+
 class StringListTruncation(TruncationStrategy):
     """Truncation for lists of strings that limits both number of items and individual string length."""
 
@@ -264,6 +273,7 @@ class StringListTruncation(TruncationStrategy):
 
 TRUNCATION_REGISTRY: dict[type[ToolResult], TruncationStrategy] = {
     ReadToolResult: StringFieldTruncation("content"),
+    ReadToolArtifactResult: NoOpTruncation(),
     WriteToolResult: StringFieldTruncation("message"),
     BashToolResult: TailTruncation("shell_output"),
     GrepToolResult: StringListTruncation("matches"),