acontext 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

acontext/agent/prompts.py

@@ -92,5 +92,8 @@ Container environment:
 - Standard Unix utilities available (grep, sed, awk, etc.)
 - Archive tools: tar, unzip, zip
 - Additional tools: ripgrep, fd, sqlite3, jq, imagemagick
-- Do not try to install new packages and libraries with pip as there is no internet access
+- You can install new packages with pip if needed (internet access is available)
+
+
+Remember to always export your artifacts at the end of your task so that the user can view them.
 """

acontext/agent/sandbox.py

@@ -10,6 +10,15 @@ from .prompts import SANDBOX_TEXT_EDITOR_REMINDER, SANDBOX_BASH_REMINDER, SKILL_
 from ..client import AcontextClient
 from ..async_client import AcontextAsyncClient
 
+MAX_OUTPUT_CHARS = 20000
+
+
+def truncate_output(text: str, max_chars: int = MAX_OUTPUT_CHARS) -> str:
+    """Truncate text to max_chars, appending a truncation flag if needed."""
+    if len(text) > max_chars:
+        return text[:max_chars] + "...[truncated]"
+    return text
+
 
 class MountedSkill(TypedDict):
     name: str
@@ -191,8 +200,8 @@ class BashTool(BaseTool):
 
         return json.dumps(
             {
-                "stdout": result.stdout,
-                "stderr": result.stderr,
+                "stdout": truncate_output(result.stdout),
+                "stderr": truncate_output(result.stderr),
                 "exit_code": result.exit_code,
             }
         )
@@ -213,8 +222,8 @@ class BashTool(BaseTool):
 
         return json.dumps(
             {
-                "stdout": result.stdout,
-                "stderr": result.stderr,
+                "stdout": truncate_output(result.stdout),
+                "stderr": truncate_output(result.stderr),
                 "exit_code": result.exit_code,
             }
         )
@@ -248,27 +257,34 @@ class TextEditorTool(BaseTool):
             "command": {
                 "type": "string",
                 "enum": ["view", "create", "str_replace"],
-                "description": "The operation to perform: 'view', 'create', or 'str_replace'",
+                "description": (
+                    "Perform only text operations: 'view', 'create', or 'str_replace'. "
+                    "Required parameters per command: "
+                    "'view' requires path (view_range is optional); "
+                    "'create' requires path and file_text; "
+                    "'str_replace' requires path, old_str, and new_str."
+                ),
             },
             "path": {
                 "type": "string",
-                "description": "The file path in the sandbox (e.g., '/workspace/script.py')",
+                "description": "Required for all commands. The file path in the sandbox (e.g., '/workspace/script.py')",
             },
             "file_text": {
                 "type": ["string", "null"],
-                "description": "For 'create' command: the content to write to the file",
+                "description": "Required for 'create' command. The content to write to the file.",
             },
             "old_str": {
                 "type": ["string", "null"],
-                "description": "For 'str_replace' command: the exact string to find and replace",
+                "description": "Required for 'str_replace' command. The exact string to find and replace.",
             },
             "new_str": {
                 "type": ["string", "null"],
-                "description": "For 'str_replace' command: the string to replace old_str with",
+                "description": "Required for 'str_replace' command. The string to replace old_str with.",
             },
             "view_range": {
                 "type": ["array", "null"],
-                "description": "For 'view' command: optional [start_line, end_line] to view specific lines",
+                "items": {"type": "integer"},
+                "description": "Optional for 'view' command. An array [start_line, end_line] to view specific lines. If not provided, shows the first 200 lines.",
             },
         }
 

acontext/agent/text_editor.py

@@ -1,11 +1,21 @@
 """Text editor file operations for sandbox environments."""
 
 import base64
+import posixpath
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .sandbox import AsyncSandboxContext, SandboxContext
 
+MAX_CONTENT_CHARS = 20000
+
+
+def truncate_content(text: str, max_chars: int = MAX_CONTENT_CHARS) -> str:
+    """Truncate text to max_chars, appending a truncation flag if needed."""
+    if len(text) > max_chars:
+        return text[:max_chars] + "...[truncated]"
+    return text
+
 
 def escape_for_shell(s: str) -> str:
     """Escape a string for safe use in shell commands."""
@@ -32,51 +42,53 @@ def view_file(
     Returns:
         A dict with file content and metadata, or error information.
     """
-    # First check if file exists and get total lines
-    check_cmd = f"wc -l < {escape_for_shell(path)} 2>/dev/null || echo 'FILE_NOT_FOUND'"
-    result = ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=check_cmd,
-        timeout=timeout,
-    )
+    escaped_path = escape_for_shell(path)
 
-    if "FILE_NOT_FOUND" in result.stdout or result.exit_code != 0:
-        return {
-            "error": f"File not found: {path}",
-            "stderr": result.stderr,
-        }
-
-    total_lines = int(result.stdout.strip()) if result.stdout.strip().isdigit() else 0
-
-    # Build the view command with line numbers
+    # Build combined command: check existence, get total lines, and view content in one exec
     if view_range and len(view_range) == 2:
         start_line, end_line = view_range
-        cmd = f"sed -n '{start_line},{end_line}p' {escape_for_shell(path)} | nl -ba -v {start_line}"
+        view_cmd = (
+            f"sed -n '{start_line},{end_line}p' {escaped_path} | nl -ba -v {start_line}"
+        )
     else:
-        cmd = f"nl -ba {escape_for_shell(path)}"
+        max_lines = 200
+        view_cmd = f"head -n {max_lines} {escaped_path} | nl -ba"
         start_line = 1
 
+    # Single combined command: outputs "TOTAL:<n>" on first line, then file content
+    cmd = (
+        f"if [ ! -f {escaped_path} ]; then echo 'FILE_NOT_FOUND'; exit 1; fi; "
+        f'echo "TOTAL:$(wc -l < {escaped_path})"; {view_cmd}'
+    )
+
     result = ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
         command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
+    if result.exit_code != 0 or "FILE_NOT_FOUND" in result.stdout:
         return {
-            "error": f"Failed to view file: {path}",
+            "error": f"File not found: {path}",
             "stderr": result.stderr,
         }
 
-    # Count lines in output
-    content_lines = (
-        result.stdout.rstrip("\n").split("\n") if result.stdout.strip() else []
-    )
+    # Parse output: first line is "TOTAL:<n>", rest is content
+    lines = result.stdout.split("\n", 1)
+    total_lines = 0
+    content = ""
+
+    if lines and lines[0].startswith("TOTAL:"):
+        total_str = lines[0][6:].strip()
+        total_lines = int(total_str) if total_str.isdigit() else 0
+        content = lines[1] if len(lines) > 1 else ""
+
+    content_lines = content.rstrip("\n").split("\n") if content.strip() else []
     num_lines = len(content_lines)
 
     return {
         "file_type": "text",
-        "content": result.stdout,
+        "content": truncate_content(content),
         "numLines": num_lines,
         "startLine": start_line if view_range else 1,
         "totalLines": total_lines + 1,  # wc -l doesn't count last line without newline
@@ -97,41 +109,35 @@ def create_file(
     Returns:
         A dict with creation status or error information.
     """
-    # Check if file already exists
-    check_cmd = f"test -f {escape_for_shell(path)} && echo 'EXISTS' || echo 'NEW'"
-    check_result = ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=check_cmd,
-        timeout=timeout,
-    )
-    is_update = "EXISTS" in check_result.stdout
-
-    # Create directory if needed
-    dir_path = "/".join(path.split("/")[:-1])
-    if dir_path:
-        mkdir_cmd = f"mkdir -p {escape_for_shell(dir_path)}"
-        ctx.client.sandboxes.exec_command(
-            sandbox_id=ctx.sandbox_id,
-            command=mkdir_cmd,
-            timeout=timeout,
-        )
-
-    # Write file using base64 encoding to safely transfer content
+    escaped_path = escape_for_shell(path)
     encoded_content = base64.b64encode(file_text.encode()).decode()
-    write_cmd = f"echo {escape_for_shell(encoded_content)} | base64 -d > {escape_for_shell(path)}"
+
+    # Get directory path for mkdir
+    dir_path = posixpath.dirname(path)
+    mkdir_part = f"mkdir -p {escape_for_shell(dir_path)} && " if dir_path else ""
+
+    # Single combined command: check existence, create dir, write file
+    cmd = (
+        f"is_update=$(test -f {escaped_path} && echo 1 || echo 0); "
+        f"{mkdir_part}"
+        f"echo {escape_for_shell(encoded_content)} | base64 -d > {escaped_path} && "
+        f'echo "STATUS:$is_update"'
+    )
 
     result = ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
-        command=write_cmd,
+        command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
+    if result.exit_code != 0 or "STATUS:" not in result.stdout:
         return {
             "error": f"Failed to create file: {path}",
             "stderr": result.stderr,
         }
 
+    is_update = "STATUS:1" in result.stdout
+
     return {
         "is_file_update": is_update,
         "message": f"File {'updated' if is_update else 'created'}: {path}",
@@ -143,6 +149,9 @@ def str_replace(
 ) -> dict:
     """Replace a string in a file.
 
+    Uses a Python script on the sandbox to avoid transferring the entire file.
+    Only the base64-encoded old_str and new_str are sent.
+
     Args:
         ctx: The sandbox context.
         path: The file path to modify.
@@ -151,85 +160,62 @@ def str_replace(
         timeout: Optional timeout for command execution.
 
     Returns:
-        A dict with diff information or error details.
+        A dict with success message or error details.
     """
-    # First read the file content
-    read_cmd = f"cat {escape_for_shell(path)}"
+    old_b64 = base64.b64encode(old_str.encode()).decode()
+    new_b64 = base64.b64encode(new_str.encode()).decode()
+
+    # Write Python script to a temp file and execute it
+    # This avoids shell escaping issues with inline python -c
+    py_script = f'''import sys, base64, os
+old = base64.b64decode("{old_b64}").decode()
+new = base64.b64decode("{new_b64}").decode()
+path = "{path}"
+if not os.path.exists(path):
+    print("FILE_NOT_FOUND")
+    sys.exit(1)
+with open(path, "r") as f:
+    content = f.read()
+count = content.count(old)
+if count == 0:
+    print("NOT_FOUND")
+    sys.exit(0)
+if count > 1:
+    print(f"MULTIPLE:{{count}}")
+    sys.exit(0)
+with open(path, "w") as f:
+    f.write(content.replace(old, new, 1))
+print("SUCCESS")
+'''
+    # Base64 encode the script itself to avoid any escaping issues
+    script_b64 = base64.b64encode(py_script.encode()).decode()
+    cmd = f"echo {escape_for_shell(script_b64)} | base64 -d | python3"
+
     result = ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
-        command=read_cmd,
+        command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
-        return {
-            "error": f"File not found: {path}",
-            "stderr": result.stderr,
-        }
+    output = result.stdout.strip()
 
-    original_content = result.stdout
+    if result.exit_code != 0 or output == "FILE_NOT_FOUND":
+        return {"error": f"File not found: {path}", "stderr": result.stderr}
 
-    # Check if old_str exists in the file
-    if old_str not in original_content:
-        return {
-            "error": f"String not found in file: {old_str[:50]}...",
-        }
+    if output == "NOT_FOUND":
+        return {"error": f"String not found in file: {old_str[:50]}..."}
 
-    # Count occurrences
-    occurrences = original_content.count(old_str)
-    if occurrences > 1:
+    if output.startswith("MULTIPLE:"):
+        count = output.split(":")[1]
         return {
-            "error": f"Multiple occurrences ({occurrences}) of the string found. Please provide more context to make the match unique.",
+            "error": f"Multiple occurrences ({count}) of the string found. "
+            "Please provide more context to make the match unique."
         }
 
-    # Perform the replacement
-    new_content = original_content.replace(old_str, new_str, 1)
-
-    # Find the line numbers affected
-    old_lines = original_content.split("\n")
-    new_lines = new_content.split("\n")
-
-    # Find where the change starts
-    old_start = 1
-    for i, (old_line, new_line) in enumerate(zip(old_lines, new_lines)):
-        if old_line != new_line:
-            old_start = i + 1
-            break
+    if output == "SUCCESS":
+        return {"msg": "Successfully replaced text at exactly one location."}
 
-    # Write the new content
-    encoded_content = base64.b64encode(new_content.encode()).decode()
-    write_cmd = f"echo {escape_for_shell(encoded_content)} | base64 -d > {escape_for_shell(path)}"
-
-    result = ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=write_cmd,
-        timeout=timeout,
-    )
-
-    if result.exit_code != 0:
-        return {
-            "error": f"Failed to write file: {path}",
-            "stderr": result.stderr,
-        }
-
-    # Calculate diff info
-    old_str_lines = old_str.count("\n") + 1
-    new_str_lines = new_str.count("\n") + 1
-
-    # Build diff lines
-    diff_lines = []
-    for line in old_str.split("\n"):
-        diff_lines.append(f"-{line}")
-    for line in new_str.split("\n"):
-        diff_lines.append(f"+{line}")
-
-    return {
-        "oldStart": old_start,
-        "oldLines": old_str_lines,
-        "newStart": old_start,
-        "newLines": new_str_lines,
-        "lines": diff_lines,
-    }
+    return {"error": f"Unexpected response: {output}", "stderr": result.stderr}
 
 
 # ============================================================================
@@ -238,7 +224,10 @@ def str_replace(
 
 
 async def async_view_file(
-    ctx: "AsyncSandboxContext", path: str, view_range: list | None, timeout: float | None
+    ctx: "AsyncSandboxContext",
+    path: str,
+    view_range: list | None,
+    timeout: float | None,
 ) -> dict:
     """View file content with line numbers (async).
 
@@ -251,48 +240,53 @@ async def async_view_file(
     Returns:
         A dict with file content and metadata, or error information.
     """
-    check_cmd = f"wc -l < {escape_for_shell(path)} 2>/dev/null || echo 'FILE_NOT_FOUND'"
-    result = await ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=check_cmd,
-        timeout=timeout,
-    )
-
-    if "FILE_NOT_FOUND" in result.stdout or result.exit_code != 0:
-        return {
-            "error": f"File not found: {path}",
-            "stderr": result.stderr,
-        }
-
-    total_lines = int(result.stdout.strip()) if result.stdout.strip().isdigit() else 0
+    escaped_path = escape_for_shell(path)
 
+    # Build combined command: check existence, get total lines, and view content in one exec
     if view_range and len(view_range) == 2:
         start_line, end_line = view_range
-        cmd = f"sed -n '{start_line},{end_line}p' {escape_for_shell(path)} | nl -ba -v {start_line}"
+        view_cmd = (
+            f"sed -n '{start_line},{end_line}p' {escaped_path} | nl -ba -v {start_line}"
+        )
     else:
-        cmd = f"nl -ba {escape_for_shell(path)}"
+        max_lines = 200
+        view_cmd = f"head -n {max_lines} {escaped_path} | nl -ba"
         start_line = 1
 
+    # Single combined command: outputs "TOTAL:<n>" on first line, then file content
+    cmd = (
+        f"if [ ! -f {escaped_path} ]; then echo 'FILE_NOT_FOUND'; exit 1; fi; "
+        f'echo "TOTAL:$(wc -l < {escaped_path})"; {view_cmd}'
+    )
+
     result = await ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
         command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
+    if result.exit_code != 0 or "FILE_NOT_FOUND" in result.stdout:
         return {
-            "error": f"Failed to view file: {path}",
+            "error": f"File not found: {path}",
             "stderr": result.stderr,
         }
 
-    content_lines = (
-        result.stdout.rstrip("\n").split("\n") if result.stdout.strip() else []
-    )
+    # Parse output: first line is "TOTAL:<n>", rest is content
+    lines = result.stdout.split("\n", 1)
+    total_lines = 0
+    content = ""
+
+    if lines and lines[0].startswith("TOTAL:"):
+        total_str = lines[0][6:].strip()
+        total_lines = int(total_str) if total_str.isdigit() else 0
+        content = lines[1] if len(lines) > 1 else ""
+
+    content_lines = content.rstrip("\n").split("\n") if content.strip() else []
     num_lines = len(content_lines)
 
     return {
         "file_type": "text",
-        "content": result.stdout,
+        "content": truncate_content(content),
         "numLines": num_lines,
         "startLine": start_line if view_range else 1,
         "totalLines": total_lines + 1,
@@ -313,38 +307,35 @@ async def async_create_file(
     Returns:
         A dict with creation status or error information.
     """
-    check_cmd = f"test -f {escape_for_shell(path)} && echo 'EXISTS' || echo 'NEW'"
-    check_result = await ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=check_cmd,
-        timeout=timeout,
-    )
-    is_update = "EXISTS" in check_result.stdout
-
-    dir_path = "/".join(path.split("/")[:-1])
-    if dir_path:
-        mkdir_cmd = f"mkdir -p {escape_for_shell(dir_path)}"
-        await ctx.client.sandboxes.exec_command(
-            sandbox_id=ctx.sandbox_id,
-            command=mkdir_cmd,
-            timeout=timeout,
-        )
-
+    escaped_path = escape_for_shell(path)
     encoded_content = base64.b64encode(file_text.encode()).decode()
-    write_cmd = f"echo {escape_for_shell(encoded_content)} | base64 -d > {escape_for_shell(path)}"
+
+    # Get directory path for mkdir
+    dir_path = posixpath.dirname(path)
+    mkdir_part = f"mkdir -p {escape_for_shell(dir_path)} && " if dir_path else ""
+
+    # Single combined command: check existence, create dir, write file
+    cmd = (
+        f"is_update=$(test -f {escaped_path} && echo 1 || echo 0); "
+        f"{mkdir_part}"
+        f"echo {escape_for_shell(encoded_content)} | base64 -d > {escaped_path} && "
+        f'echo "STATUS:$is_update"'
+    )
 
     result = await ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
-        command=write_cmd,
+        command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
+    if result.exit_code != 0 or "STATUS:" not in result.stdout:
         return {
             "error": f"Failed to create file: {path}",
             "stderr": result.stderr,
         }
 
+    is_update = "STATUS:1" in result.stdout
+
     return {
         "is_file_update": is_update,
         "message": f"File {'updated' if is_update else 'created'}: {path}",
@@ -352,10 +343,17 @@ async def async_create_file(
 
 
 async def async_str_replace(
-    ctx: "AsyncSandboxContext", path: str, old_str: str, new_str: str, timeout: float | None
+    ctx: "AsyncSandboxContext",
+    path: str,
+    old_str: str,
+    new_str: str,
+    timeout: float | None,
 ) -> dict:
     """Replace a string in a file (async).
 
+    Uses a Python script on the sandbox to avoid transferring the entire file.
+    Only the base64-encoded old_str and new_str are sent.
+
     Args:
         ctx: The async sandbox context.
         path: The file path to modify.
@@ -364,73 +362,59 @@ async def async_str_replace(
         timeout: Optional timeout for command execution.
 
     Returns:
-        A dict with diff information or error details.
+        A dict with success message or error details.
     """
-    read_cmd = f"cat {escape_for_shell(path)}"
+    old_b64 = base64.b64encode(old_str.encode()).decode()
+    new_b64 = base64.b64encode(new_str.encode()).decode()
+
+    # Write Python script to a temp file and execute it
+    # This avoids shell escaping issues with inline python -c
+    py_script = f'''import sys, base64, os
+old = base64.b64decode("{old_b64}").decode()
+new = base64.b64decode("{new_b64}").decode()
+path = "{path}"
+if not os.path.exists(path):
+    print("FILE_NOT_FOUND")
+    sys.exit(1)
+with open(path, "r") as f:
+    content = f.read()
+count = content.count(old)
+if count == 0:
+    print("NOT_FOUND")
+    sys.exit(0)
+if count > 1:
+    print(f"MULTIPLE:{{count}}")
+    sys.exit(0)
+with open(path, "w") as f:
+    f.write(content.replace(old, new, 1))
+print("SUCCESS")
+'''
+    # Base64 encode the script itself to avoid any escaping issues
+    script_b64 = base64.b64encode(py_script.encode()).decode()
+    cmd = f"echo {escape_for_shell(script_b64)} | base64 -d | python3"
+
     result = await ctx.client.sandboxes.exec_command(
         sandbox_id=ctx.sandbox_id,
-        command=read_cmd,
+        command=cmd,
         timeout=timeout,
     )
 
-    if result.exit_code != 0:
-        return {
-            "error": f"File not found: {path}",
-            "stderr": result.stderr,
-        }
-
-    original_content = result.stdout
-
-    if old_str not in original_content:
-        return {
-            "error": f"String not found in file: {old_str[:50]}...",
-        }
-
-    occurrences = original_content.count(old_str)
-    if occurrences > 1:
-        return {
-            "error": f"Multiple occurrences ({occurrences}) of the string found. Please provide more context to make the match unique.",
-        }
-
-    new_content = original_content.replace(old_str, new_str, 1)
-
-    old_lines = original_content.split("\n")
-    new_lines = new_content.split("\n")
+    output = result.stdout.strip()
 
-    old_start = 1
-    for i, (old_line, new_line) in enumerate(zip(old_lines, new_lines)):
-        if old_line != new_line:
-            old_start = i + 1
-            break
+    if result.exit_code != 0 or output == "FILE_NOT_FOUND":
+        return {"error": f"File not found: {path}", "stderr": result.stderr}
 
-    encoded_content = base64.b64encode(new_content.encode()).decode()
-    write_cmd = f"echo {escape_for_shell(encoded_content)} | base64 -d > {escape_for_shell(path)}"
+    if output == "NOT_FOUND":
+        return {"error": f"String not found in file: {old_str[:50]}..."}
 
-    result = await ctx.client.sandboxes.exec_command(
-        sandbox_id=ctx.sandbox_id,
-        command=write_cmd,
-        timeout=timeout,
-    )
-
-    if result.exit_code != 0:
+    if output.startswith("MULTIPLE:"):
+        count = output.split(":")[1]
         return {
-            "error": f"Failed to write file: {path}",
-            "stderr": result.stderr,
+            "error": f"Multiple occurrences ({count}) of the string found. "
+            "Please provide more context to make the match unique."
         }
 
-    old_str_lines = old_str.count("\n") + 1
-    new_str_lines = new_str.count("\n") + 1
+    if output == "SUCCESS":
+        return {"msg": "Successfully replaced text at exactly one location."}
 
-    diff_lines = []
-    for line in old_str.split("\n"):
-        diff_lines.append(f"-{line}")
-    for line in new_str.split("\n"):
-        diff_lines.append(f"+{line}")
-
-    return {
-        "oldStart": old_start,
-        "oldLines": old_str_lines,
-        "newStart": old_start,
-        "newLines": new_str_lines,
-        "lines": diff_lines,
-    }
+    return {"error": f"Unexpected response: {output}", "stderr": result.stderr}

{acontext-0.1.4.dist-info → acontext-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: acontext
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python SDK for the Acontext API
 Keywords: acontext,sdk,client,api
 Requires-Dist: httpx>=0.28.1

{acontext-0.1.4.dist-info → acontext-0.1.6.dist-info}/RECORD

@@ -4,10 +4,10 @@ acontext/_utils.py,sha256=GKQH45arKh0sDu64u-5jwrII_ctnU_oChYlgR5lRkfE,1250
 acontext/agent/__init__.py,sha256=lx5HqeVDfIxkbGfAt0ju8hkk8EPsgFvKmMrQzjNXR8w,213
 acontext/agent/base.py,sha256=BDTqfqkPrPzvQIH_llOX6S_bkcDw3E30J5x9yd47Q6g,3526
 acontext/agent/disk.py,sha256=q-3DRkLcQLfdAXADJM3GPo6reWPzhKQrnyBiZdBZvIY,22775
-acontext/agent/prompts.py,sha256=Y20C78f9PacjpyN_I_urQBDzoiAeVSXE4Cj5BV67Qhg,4865
-acontext/agent/sandbox.py,sha256=eGN_yBTo3jWNhxTZMi-Rkr0ALJ6YP5WZbF8u0oBPn2Y,18209
+acontext/agent/prompts.py,sha256=awhYYClNAROnTAfzKKD8G5gHfTFs-1KqMUEWCEnlMMQ,4954
+acontext/agent/sandbox.py,sha256=ziGGs2yqJaik_9o7S3f9G-CzcndmRs9fC3WDUi_UGbI,19016
 acontext/agent/skill.py,sha256=uB7teH7OAk4Cy6pOLRCJFBi5KZbyMMgZSLEt77TLB20,12880
-acontext/agent/text_editor.py,sha256=HsmDexX2wqacaeIwkCyDrojZDQiI9mr4krt6phSKS7g,13247
+acontext/agent/text_editor.py,sha256=mrUtMfAtgpOOwYnh2xQpWRc0lCoE9u2_WMTVRuFiWRQ,13390
 acontext/async_client.py,sha256=WjqW7ruMtlYTBlk6PQ1-1yhjFSBBxGqI3oxrfEqqIpQ,8471
 acontext/client.py,sha256=XggELxXU9-8BcAcHOoiqQZypfPmkhe7SyJ3plHq-A9M,8217
 acontext/client_types.py,sha256=oR6lSDMjEERx0mIVOpKaTXbEu_lfoxe3fDpzA-ALE-8,1063
@@ -36,6 +36,6 @@ acontext/types/skill.py,sha256=v7OAvtkwTeZAkLG7NQMcwFoSJ4g-HDWjPZ4EoMyU3mk,2779
 acontext/types/tool.py,sha256=UlX6JIGRKd96vPayOkyi6pGwFi6w9GwWwAxr4BcqVts,670
 acontext/types/user.py,sha256=dBzHCqULSJ3Sqw7T8nA0U8Sctz76Pd0hm1qsHvtEIBQ,1264
 acontext/uploads.py,sha256=6twnqQOY_eerNuEjeSKsE_3S0IfJUiczXtAy4aXqDl8,1379
-acontext-0.1.4.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-acontext-0.1.4.dist-info/METADATA,sha256=wvxyJ9Rq48wlqsbGdig2RELL5RvXYGtVENosB7a0nGU,888
-acontext-0.1.4.dist-info/RECORD,,
+acontext-0.1.6.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+acontext-0.1.6.dist-info/METADATA,sha256=xUgSw00x4t4EHQR7WLgfwlnjEgXJjD1LH2mk4t_KKSo,888
+acontext-0.1.6.dist-info/RECORD,,

{acontext-0.1.4.dist-info → acontext-0.1.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.26
+Generator: uv 0.9.27
 Root-Is-Purelib: true
 Tag: py3-none-any