fruxon 0.2.0__tar.gz → 0.3.1__tar.gz

{fruxon-0.2.0 → fruxon-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fruxon
-Version: 0.2.0
+Version: 0.3.1
 Summary: The Fruxon SDK is a lightweight Python client for integrating with the Fruxon platform.
 Author-email: Hagai Cohen <hagai@fruxon.com>
 Maintainer-email: Hagai Cohen <hagai@fruxon.com>
@@ -45,6 +45,38 @@ pip install fruxon
 
 ## Features
 
+### Python Client — Execute agents via API
+
+```python
+from fruxon import FruxonClient
+
+client = FruxonClient(api_key="frx_...", tenant="acme-corp")
+
+result = client.execute("support-agent", parameters={"question": "How do I reset my password?"})
+print(result.response)
+print(f"{result.trace.duration}ms | ${result.trace.total_cost:.4f}")
+
+# Multi-turn conversation
+result2 = client.execute("support-agent", parameters={"question": "Tell me more"}, session_id=result.session_id)
+```
+
+### `fruxon run` — Execute agents from the CLI
+
+```bash
+# Basic execution
+fruxon run my-agent -t acme-corp -k frx_...
+
+# With parameters
+fruxon run my-agent -t acme-corp -p question="Hello" -p lang=en
+
+# Full JSON output (for scripting)
+fruxon run my-agent -t acme-corp --json
+
+# Use environment variable for API key
+export FRUXON_API_KEY=frx_...
+fruxon run my-agent -t acme-corp
+```
+
 ### `fruxon export` — Consolidate multi-file agents
 
 Export a multi-file Python agent project into a single file for importing into Fruxon.
@@ -71,6 +103,3 @@ fruxon export graph.py --copy
 3. Traces all local imports using Python's AST (skips third-party packages)
 4. Outputs a single consolidated file with all local code and source markers
 
-## Credits
-
-Built by [Fruxon](https://fruxon.com).

{fruxon-0.2.0 → fruxon-0.3.1}/README.md

@@ -15,6 +15,38 @@ pip install fruxon
 
 ## Features
 
+### Python Client — Execute agents via API
+
+```python
+from fruxon import FruxonClient
+
+client = FruxonClient(api_key="frx_...", tenant="acme-corp")
+
+result = client.execute("support-agent", parameters={"question": "How do I reset my password?"})
+print(result.response)
+print(f"{result.trace.duration}ms | ${result.trace.total_cost:.4f}")
+
+# Multi-turn conversation
+result2 = client.execute("support-agent", parameters={"question": "Tell me more"}, session_id=result.session_id)
+```
+
+### `fruxon run` — Execute agents from the CLI
+
+```bash
+# Basic execution
+fruxon run my-agent -t acme-corp -k frx_...
+
+# With parameters
+fruxon run my-agent -t acme-corp -p question="Hello" -p lang=en
+
+# Full JSON output (for scripting)
+fruxon run my-agent -t acme-corp --json
+
+# Use environment variable for API key
+export FRUXON_API_KEY=frx_...
+fruxon run my-agent -t acme-corp
+```
+
 ### `fruxon export` — Consolidate multi-file agents
 
 Export a multi-file Python agent project into a single file for importing into Fruxon.
@@ -41,6 +73,3 @@ fruxon export graph.py --copy
 3. Traces all local imports using Python's AST (skips third-party packages)
 4. Outputs a single consolidated file with all local code and source markers
 
-## Credits
-
-Built by [Fruxon](https://fruxon.com).

{fruxon-0.2.0 → fruxon-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fruxon"
-version = "0.2.0"
+version = "0.3.1"
 description = "The Fruxon SDK is a lightweight Python client for integrating with the Fruxon platform."
 readme = "README.md"
 authors = [

fruxon-0.3.1/src/fruxon/__init__.py

@@ -0,0 +1,28 @@
+"""Top-level package for fruxon-sdk."""
+
+__author__ = "Hagai Cohen"
+__email__ = "hagai@fruxon.com"
+
+from fruxon.exceptions import (
+    AuthenticationError,
+    ForbiddenError,
+    FruxonAPIError,
+    FruxonConnectionError,
+    FruxonError,
+    NotFoundError,
+    ValidationError,
+)
+from fruxon.fruxon import ExecutionResult, ExecutionTrace, FruxonClient
+
+__all__ = [
+    "AuthenticationError",
+    "ExecutionResult",
+    "ExecutionTrace",
+    "ForbiddenError",
+    "FruxonAPIError",
+    "FruxonClient",
+    "FruxonConnectionError",
+    "FruxonError",
+    "NotFoundError",
+    "ValidationError",
+]

fruxon-0.3.1/src/fruxon/cli.py

@@ -0,0 +1,165 @@
+"""Console script for fruxon-sdk."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.prompt import IntPrompt
+
+from fruxon.exceptions import FruxonError, MultipleAgentsError
+from fruxon.export import export_agent
+from fruxon.fruxon import FruxonClient
+
+app = typer.Typer(
+    help="Fruxon CLI - tools for working with the Fruxon platform.",
+    pretty_exceptions_enable=False,
+)
+stderr = Console(stderr=True)
+
+
+@app.callback()
+def main():
+    """Fruxon CLI - tools for working with the Fruxon platform."""
+
+
+@app.command()
+def export(
+    entry_point: Annotated[
+        Path | None, typer.Argument(help="Path to the main Python file. Auto-detected if omitted.")
+    ] = None,
+    output: Annotated[
+        Path | None, typer.Option("--output", "-o", help="Write output to file instead of stdout")
+    ] = None,
+    copy: Annotated[bool, typer.Option("--copy", "-c", help="Copy output to clipboard")] = False,
+):
+    """Export a multi-file Python agent into a single file for Fruxon import.
+
+    Auto-detects the agent entry point by scanning for framework imports
+    (LangChain, CrewAI, Google ADK, etc.). You can also specify the entry
+    point explicitly.
+
+    Examples:
+        fruxon export
+        fruxon export graph.py
+        fruxon export my_agent/main.py -o export.py
+        fruxon export --copy
+    """
+    try:
+        result = export_agent(str(entry_point) if entry_point else None, str(output) if output else None, stderr)
+    except MultipleAgentsError as e:
+        choice = IntPrompt.ask(
+            "\nWhich agent do you want to export?",
+            choices=[str(i) for i in range(1, len(e.entry_points) + 1)],
+        )
+        selected_path = e.entry_points[choice - 1][0]
+        result = export_agent(str(selected_path), str(output) if output else None, stderr)
+
+    _handle_output(result, output, copy)
+
+
+def _handle_output(result: str, output: Path | None, copy: bool):
+    """Handle clipboard copy and stdout output."""
+    if copy:
+        _copy_to_clipboard(result)
+
+    if not output and not copy:
+        # Print code to stdout (not stderr) so it can be piped
+        print(result)
+    elif not output and copy:
+        lines = result.count("\n") + 1
+        stderr.print(f"[green]>[/green] {lines} lines ready to paste into Fruxon.")
+
+
+@app.command()
+def run(
+    agent: Annotated[str, typer.Argument(help="Agent identifier to execute")],
+    tenant: Annotated[str, typer.Option("--tenant", "-t", help="Tenant identifier")],
+    api_key: Annotated[str | None, typer.Option("--api-key", "-k", envvar="FRUXON_API_KEY", help="API key")] = None,
+    param: Annotated[
+        list[str] | None, typer.Option("--param", "-p", help="Parameter as key=value (repeatable)")
+    ] = None,
+    session_id: Annotated[str | None, typer.Option("--session", "-s", help="Session ID")] = None,
+    base_url: Annotated[str, typer.Option("--base-url", help="API base URL")] = FruxonClient.DEFAULT_BASE_URL,
+    json_output: Annotated[bool, typer.Option("--json", help="Output full JSON response")] = False,
+):
+    """Execute a Fruxon agent and print the response.
+
+    Examples:
+        fruxon run my-agent -t acme-corp -k frx_...
+        fruxon run my-agent -t acme-corp -p question="Hello" -p lang=en
+        fruxon run my-agent -t acme-corp --session abc123 --json
+    """
+    if not api_key:
+        stderr.print("[bold red]Error:[/bold red] API key required. Use --api-key or set FRUXON_API_KEY.")
+        sys.exit(1)
+
+    parameters: dict[str, object] | None = None
+    if param:
+        parameters = {}
+        for p in param:
+            if "=" not in p:
+                stderr.print(f"[bold red]Error:[/bold red] Invalid parameter format '{p}'. Use key=value.")
+                sys.exit(1)
+            key, value = p.split("=", 1)
+            parameters[key] = value
+
+    client = FruxonClient(api_key=api_key, tenant=tenant, base_url=base_url)
+
+    with stderr.status(f"[bold]Executing agent [cyan]{agent}[/cyan]...[/bold]"):
+        try:
+            result = client.execute(agent, parameters=parameters, session_id=session_id)
+        except FruxonError as e:
+            stderr.print(f"[bold red]Error:[/bold red] {e}")
+            sys.exit(1)
+
+    if json_output:
+        output = {
+            "response": result.response,
+            "sessionId": result.session_id,
+            "executionRecordId": result.execution_record_id,
+            "trace": {
+                "agentId": result.trace.agent_id,
+                "agentRevision": result.trace.agent_revision,
+                "duration": result.trace.duration,
+                "inputCost": result.trace.input_cost,
+                "outputCost": result.trace.output_cost,
+                "totalCost": result.trace.total_cost,
+            },
+            "links": result.links,
+        }
+        Console().print_json(json.dumps(output))
+    else:
+        print(result.response)
+
+    # Summary to stderr so it doesn't pollute piped output
+    duration = result.trace.duration
+    cost = result.trace.total_cost
+    if duration or cost:
+        parts = []
+        if duration:
+            parts.append(f"{duration}ms")
+        if cost:
+            parts.append(f"${cost:.4f}")
+        stderr.print(f"[dim]{' | '.join(parts)}[/dim]")
+
+
+def _copy_to_clipboard(text: str):
+    """Copy text to system clipboard."""
+    import subprocess
+
+    for cmd in [["pbcopy"], ["xclip", "-selection", "clipboard"]]:
+        try:
+            process = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+            process.communicate(text.encode("utf-8"))
+            stderr.print("[green]>[/green] Copied to clipboard.")
+            return
+        except FileNotFoundError:
+            continue
+    stderr.print("[yellow]Clipboard not available. Install xclip or use -o to write to file.[/yellow]")
+
+
+if __name__ == "__main__":
+    app()

fruxon-0.3.1/src/fruxon/exceptions.py

@@ -0,0 +1,45 @@
+"""Exceptions for the Fruxon SDK."""
+
+from pathlib import Path
+
+
+class FruxonError(Exception):
+    """Base exception for all Fruxon SDK errors."""
+
+
+class FruxonAPIError(FruxonError):
+    """Raised when the Fruxon API returns an error response."""
+
+    def __init__(self, status: int, title: str, detail: str):
+        self.status = status
+        self.title = title
+        self.detail = detail
+        super().__init__(f"{status} {title}: {detail}")
+
+
+class AuthenticationError(FruxonAPIError):
+    """Raised on 401 Unauthorized responses."""
+
+
+class ForbiddenError(FruxonAPIError):
+    """Raised on 403 Forbidden responses."""
+
+
+class NotFoundError(FruxonAPIError):
+    """Raised on 404 Not Found responses."""
+
+
+class ValidationError(FruxonAPIError):
+    """Raised on 400 or 422 responses."""
+
+
+class FruxonConnectionError(FruxonError):
+    """Raised when the API is unreachable."""
+
+
+class MultipleAgentsError(FruxonError):
+    """Raised when multiple agent entry points are detected."""
+
+    def __init__(self, entry_points: list[tuple[Path, str]]):
+        self.entry_points = entry_points
+        super().__init__(f"Multiple agents detected: {len(entry_points)} entry points found")

{fruxon-0.2.0 → fruxon-0.3.1}/src/fruxon/export.py

@@ -8,6 +8,12 @@ Supports auto-detection of agent entry points by scanning for framework imports.
 import ast
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+from fruxon.exceptions import MultipleAgentsError as MultipleAgentsError
+
+if TYPE_CHECKING:
+    from rich.console import Console
 
 # Known agent framework module prefixes. A file that imports any of these
 # is considered an agent-related file.
@@ -275,21 +281,38 @@ def find_agent_entry_points(project_root: Path) -> list[tuple[Path, str]]:
     return entry_points
 
 
-def export_agent(entry_path: str | None = None, output_path: str | None = None) -> str:
+def export_agent(
+    entry_path: str | None = None,
+    output_path: str | None = None,
+    console: "Console | None" = None,
+) -> str:
     """Main export function. Returns the consolidated source and optionally writes to file.
 
     If entry_path is None, auto-detects the agent entry point by scanning
     for framework imports. Raises SystemExit on errors.
     """
+
+    def _msg(text: str) -> None:
+        if console:
+            console.print(text, highlight=False)
+        else:
+            print(text, file=sys.stderr)
+
+    def _err(text: str) -> None:
+        if console:
+            console.print(f"[bold red]Error:[/bold red] {text}")
+        else:
+            print(f"Error: {text}", file=sys.stderr)
+
     if entry_path:
         entry_file = Path(entry_path).resolve()
 
         if not entry_file.exists():
-            print(f"Error: File not found: {entry_file}", file=sys.stderr)
+            _err(f"File not found: {entry_file}")
             raise SystemExit(1)
 
         if not entry_file.suffix == ".py":
-            print(f"Error: Entry point must be a .py file, got: {entry_file.suffix}", file=sys.stderr)
+            _err(f"Entry point must be a .py file, got: {entry_file.suffix}")
             raise SystemExit(1)
 
         project_root = find_project_root(entry_file)
@@ -299,39 +322,32 @@ def export_agent(entry_path: str | None = None, output_path: str | None = None)
         entry_points = find_agent_entry_points(project_root)
 
         if not entry_points:
-            print(
-                "Error: No agent framework detected. "
+            _err(
+                "No agent framework detected. "
                 "Make sure you're in a directory with Python agent files, "
-                "or specify the entry point: fruxon export <file.py>",
-                file=sys.stderr,
+                "or specify the entry point: [bold]fruxon export <file.py>[/bold]"
             )
             raise SystemExit(1)
 
         if len(entry_points) == 1:
             entry_file = entry_points[0][0]
             framework = entry_points[0][1]
-            print(f"Detected {framework} agent in {entry_file.relative_to(project_root)}", file=sys.stderr)
+            relative = entry_file.relative_to(project_root)
+            _msg(f"[green]>[/green] Detected [bold]{framework}[/bold] agent in [cyan]{relative}[/cyan]")
         else:
             # Multiple entry points found — let caller handle selection
-            print("Multiple agents detected:", file=sys.stderr)
+            _msg("[yellow]Multiple agents detected:[/yellow]")
             for i, (fp, fw) in enumerate(entry_points, 1):
                 relative = fp.relative_to(project_root) if fp.is_relative_to(project_root) else fp
-                print(f"  {i}. {relative} ({fw})", file=sys.stderr)
+                _msg(f"  [bold]{i}.[/bold] {relative} [dim]({fw})[/dim]")
             raise MultipleAgentsError(entry_points)
 
     result = build_export(entry_file, project_root)
+    file_count = len(collect_files(entry_file, project_root))
 
     if output_path:
         out = Path(output_path)
         out.write_text(result, encoding="utf-8")
-        print(f"Exported to {out}", file=sys.stderr)
+        _msg(f"[green]>[/green] Exported {file_count} file(s) to [cyan]{out}[/cyan]")
 
     return result
-
-
-class MultipleAgentsError(Exception):
-    """Raised when multiple agent entry points are detected."""
-
-    def __init__(self, entry_points: list[tuple[Path, str]]):
-        self.entry_points = entry_points
-        super().__init__(f"Multiple agents detected: {len(entry_points)} entry points found")

fruxon-0.3.1/src/fruxon/fruxon.py

@@ -0,0 +1,150 @@
+"""Fruxon API client for executing agents on the Fruxon platform."""
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+
+from fruxon.exceptions import (
+    AuthenticationError,
+    ForbiddenError,
+    FruxonAPIError,
+    FruxonConnectionError,
+    NotFoundError,
+    ValidationError,
+)
+
+_STATUS_EXCEPTIONS: dict[int, type[FruxonAPIError]] = {
+    400: ValidationError,
+    401: AuthenticationError,
+    403: ForbiddenError,
+    404: NotFoundError,
+    422: ValidationError,
+}
+
+
+@dataclass(frozen=True)
+class ExecutionTrace:
+    """Execution trace metadata."""
+
+    agent_id: str
+    agent_revision: int
+    duration: int
+    input_cost: float
+    output_cost: float
+    total_cost: float
+
+
+@dataclass(frozen=True)
+class ExecutionResult:
+    """Result of an agent execution."""
+
+    response: str
+    trace: ExecutionTrace
+    session_id: str
+    links: list[dict[str, object]]
+    execution_record_id: str
+
+
+class FruxonClient:
+    """Client for the Fruxon platform API."""
+
+    DEFAULT_BASE_URL = "https://api.fruxon.com"
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        tenant: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 120.0,
+    ) -> None:
+        self._api_key = api_key
+        self._tenant = tenant
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+
+    def execute(
+        self,
+        agent: str,
+        *,
+        parameters: dict[str, object] | None = None,
+        attachments: list[dict[str, object]] | None = None,
+        chat_user: dict[str, object] | None = None,
+        session_id: str | None = None,
+    ) -> ExecutionResult:
+        """Execute an agent and return the result.
+
+        Args:
+            agent: The agent identifier.
+            parameters: Execution parameters and inputs.
+            attachments: File attachments.
+            chat_user: Chat user information.
+            session_id: Session identifier for multi-turn conversations.
+        """
+        url = f"{self._base_url}/v1/tenants/{self._tenant}/agents/{agent}:execute"
+
+        body: dict[str, object] = {}
+        if parameters is not None:
+            body["parameters"] = parameters
+        if attachments is not None:
+            body["attachments"] = attachments
+        if chat_user is not None:
+            body["chatUser"] = chat_user
+        if session_id is not None:
+            body["sessionId"] = session_id
+
+        data = json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-KEY": self._api_key,
+            },
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            _raise_api_error(e)
+        except urllib.error.URLError as e:
+            raise FruxonConnectionError(str(e.reason)) from e
+
+        return _parse_execution_result(result)
+
+
+def _raise_api_error(error: urllib.error.HTTPError) -> None:
+    """Parse an HTTP error response and raise the appropriate exception."""
+    try:
+        body = json.loads(error.read().decode("utf-8"))
+        title = body.get("title") or body.get("message") or "Error"
+        detail = body.get("detail") or body.get("details") or ""
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        title = "Error"
+        detail = str(error)
+
+    exc_class = _STATUS_EXCEPTIONS.get(error.code, FruxonAPIError)
+    raise exc_class(status=error.code, title=title, detail=detail) from error
+
+
+def _parse_execution_result(data: dict) -> ExecutionResult:
+    """Parse raw API response into an ExecutionResult."""
+    trace_data: dict = data.get("trace", {})
+    trace = ExecutionTrace(
+        agent_id=trace_data.get("agentId", ""),
+        agent_revision=trace_data.get("agentRevision", 0),
+        duration=trace_data.get("duration", 0),
+        input_cost=trace_data.get("inputCost", 0.0),
+        output_cost=trace_data.get("outputCost", 0.0),
+        total_cost=trace_data.get("totalCost", 0.0),
+    )
+    return ExecutionResult(
+        response=data.get("response", ""),
+        trace=trace,
+        session_id=data.get("sessionId", ""),
+        links=data.get("links", []),
+        execution_record_id=data.get("executionRecordId", ""),
+    )

{fruxon-0.2.0 → fruxon-0.3.1}/src/fruxon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fruxon
-Version: 0.2.0
+Version: 0.3.1
 Summary: The Fruxon SDK is a lightweight Python client for integrating with the Fruxon platform.
 Author-email: Hagai Cohen <hagai@fruxon.com>
 Maintainer-email: Hagai Cohen <hagai@fruxon.com>
@@ -45,6 +45,38 @@ pip install fruxon
 
 ## Features
 
+### Python Client — Execute agents via API
+
+```python
+from fruxon import FruxonClient
+
+client = FruxonClient(api_key="frx_...", tenant="acme-corp")
+
+result = client.execute("support-agent", parameters={"question": "How do I reset my password?"})
+print(result.response)
+print(f"{result.trace.duration}ms | ${result.trace.total_cost:.4f}")
+
+# Multi-turn conversation
+result2 = client.execute("support-agent", parameters={"question": "Tell me more"}, session_id=result.session_id)
+```
+
+### `fruxon run` — Execute agents from the CLI
+
+```bash
+# Basic execution
+fruxon run my-agent -t acme-corp -k frx_...
+
+# With parameters
+fruxon run my-agent -t acme-corp -p question="Hello" -p lang=en
+
+# Full JSON output (for scripting)
+fruxon run my-agent -t acme-corp --json
+
+# Use environment variable for API key
+export FRUXON_API_KEY=frx_...
+fruxon run my-agent -t acme-corp
+```
+
 ### `fruxon export` — Consolidate multi-file agents
 
 Export a multi-file Python agent project into a single file for importing into Fruxon.
@@ -71,6 +103,3 @@ fruxon export graph.py --copy
 3. Traces all local imports using Python's AST (skips third-party packages)
 4. Outputs a single consolidated file with all local code and source markers
 
-## Credits
-
-Built by [Fruxon](https://fruxon.com).

{fruxon-0.2.0 → fruxon-0.3.1}/src/fruxon.egg-info/SOURCES.txt

@@ -11,9 +11,9 @@ src/__init__.py
 src/fruxon/__init__.py
 src/fruxon/__main__.py
 src/fruxon/cli.py
+src/fruxon/exceptions.py
 src/fruxon/export.py
 src/fruxon/fruxon.py
-src/fruxon/utils.py
 src/fruxon.egg-info/PKG-INFO
 src/fruxon.egg-info/SOURCES.txt
 src/fruxon.egg-info/dependency_links.txt
@@ -21,5 +21,6 @@ src/fruxon.egg-info/entry_points.txt
 src/fruxon.egg-info/requires.txt
 src/fruxon.egg-info/top_level.txt
 tests/__init__.py
+tests/test_client.py
 tests/test_export.py
 tests/test_fruxon.py

fruxon-0.3.1/tests/test_client.py

@@ -0,0 +1,268 @@
+"""Tests for the fruxon API client."""
+
+import io
+import json
+import urllib.error
+import urllib.request
+
+import pytest
+
+from fruxon.exceptions import (
+    AuthenticationError,
+    ForbiddenError,
+    FruxonAPIError,
+    FruxonConnectionError,
+    NotFoundError,
+    ValidationError,
+)
+from fruxon.fruxon import (
+    ExecutionResult,
+    ExecutionTrace,
+    FruxonClient,
+    _parse_execution_result,
+)
+
+SAMPLE_RESPONSE = {
+    "response": "Here is your answer.",
+    "trace": {
+        "agentId": "agent-1",
+        "agentRevision": 3,
+        "createdAt": 1700000000,
+        "parameters": {},
+        "startTime": 1700000000,
+        "endTime": 1700000005,
+        "duration": 5000,
+        "traces": [],
+        "result": {"strValue": "Here is your answer."},
+        "inputCost": 0.001,
+        "outputCost": 0.002,
+        "totalCost": 0.003,
+    },
+    "sessionId": "sess-abc",
+    "links": [],
+    "executionRecordId": "rec-123",
+}
+
+
+class _MockResponse:
+    """Mock urllib response with context manager support."""
+
+    def __init__(self, data: dict):
+        self._data = json.dumps(data).encode("utf-8")
+
+    def read(self):
+        return self._data
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
+@pytest.fixture
+def client():
+    return FruxonClient(api_key="test-key", tenant="test-tenant")
+
+
+class TestFruxonClientInit:
+    def test_stores_config(self):
+        c = FruxonClient(api_key="k", tenant="t")
+        assert c._api_key == "k"
+        assert c._tenant == "t"
+        assert c._base_url == "https://api.fruxon.com"
+        assert c._timeout == 120.0
+
+    def test_custom_base_url(self):
+        c = FruxonClient(api_key="k", tenant="t", base_url="https://staging.fruxon.com/")
+        assert c._base_url == "https://staging.fruxon.com"
+
+    def test_custom_timeout(self):
+        c = FruxonClient(api_key="k", tenant="t", timeout=30.0)
+        assert c._timeout == 30.0
+
+
+class TestFruxonClientExecute:
+    def test_sends_correct_request(self, client, monkeypatch):
+        """Verify URL, headers, and body are correctly constructed."""
+        captured = {}
+
+        def mock_urlopen(req, timeout=None):
+            captured["url"] = req.full_url
+            captured["method"] = req.method
+            captured["headers"] = dict(req.headers)
+            captured["body"] = json.loads(req.data.decode("utf-8"))
+            captured["timeout"] = timeout
+            return _MockResponse(SAMPLE_RESPONSE)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        client.execute("my-agent", parameters={"q": "hello"}, session_id="sess-1")
+
+        assert captured["url"] == "https://api.fruxon.com/v1/tenants/test-tenant/agents/my-agent:execute"
+        assert captured["method"] == "POST"
+        assert captured["headers"]["Content-type"] == "application/json"
+        assert captured["headers"]["X-api-key"] == "test-key"
+        assert captured["body"] == {"parameters": {"q": "hello"}, "sessionId": "sess-1"}
+        assert captured["timeout"] == 120.0
+
+    def test_omits_none_fields(self, client, monkeypatch):
+        """Only non-None fields appear in the request body."""
+        captured = {}
+
+        def mock_urlopen(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode("utf-8"))
+            return _MockResponse(SAMPLE_RESPONSE)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        client.execute("my-agent")
+        assert captured["body"] == {}
+
+    def test_maps_chat_user(self, client, monkeypatch):
+        captured = {}
+
+        def mock_urlopen(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode("utf-8"))
+            return _MockResponse(SAMPLE_RESPONSE)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        client.execute("my-agent", chat_user={"id": "user-1", "name": "Alice"})
+        assert captured["body"]["chatUser"] == {"id": "user-1", "name": "Alice"}
+
+    def test_returns_execution_result(self, client, monkeypatch):
+        monkeypatch.setattr(urllib.request, "urlopen", lambda req, timeout=None: _MockResponse(SAMPLE_RESPONSE))
+
+        result = client.execute("my-agent")
+
+        assert isinstance(result, ExecutionResult)
+        assert result.response == "Here is your answer."
+        assert result.session_id == "sess-abc"
+        assert result.execution_record_id == "rec-123"
+        assert isinstance(result.trace, ExecutionTrace)
+        assert result.trace.agent_id == "agent-1"
+        assert result.trace.agent_revision == 3
+        assert result.trace.duration == 5000
+        assert result.trace.input_cost == 0.001
+        assert result.trace.output_cost == 0.002
+        assert result.trace.total_cost == 0.003
+
+
+class TestErrorHandling:
+    def _make_http_error(self, status: int, body: dict | None = None):
+        if body is None:
+            body = {"title": "Test Error", "detail": "Something went wrong"}
+        return urllib.error.HTTPError(
+            url="https://api.fruxon.com/v1/test",
+            code=status,
+            msg="Error",
+            hdrs=None,
+            fp=io.BytesIO(json.dumps(body).encode("utf-8")),
+        )
+
+    def test_401_raises_authentication_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(401)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(AuthenticationError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 401
+
+    def test_403_raises_forbidden_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(403)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(ForbiddenError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 403
+
+    def test_404_raises_not_found_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(404)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(NotFoundError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 404
+
+    def test_400_raises_validation_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(400)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(ValidationError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 400
+
+    def test_422_raises_validation_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(422)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(ValidationError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 422
+
+    def test_unknown_status_raises_api_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise self._make_http_error(500)
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(FruxonAPIError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 500
+
+    def test_malformed_error_body(self, client, monkeypatch):
+        """Non-JSON error response falls back gracefully."""
+        error = urllib.error.HTTPError(
+            url="https://api.fruxon.com/v1/test",
+            code=502,
+            msg="Bad Gateway",
+            hdrs=None,
+            fp=io.BytesIO(b"<html>Bad Gateway</html>"),
+        )
+
+        monkeypatch.setattr(urllib.request, "urlopen", lambda req, timeout=None: (_ for _ in ()).throw(error))
+
+        with pytest.raises(FruxonAPIError) as exc_info:
+            client.execute("my-agent")
+        assert exc_info.value.status == 502
+        assert exc_info.value.title == "Error"
+
+    def test_network_error_raises_connection_error(self, client, monkeypatch):
+        def mock_urlopen(req, timeout=None):
+            raise urllib.error.URLError("Connection refused")
+
+        monkeypatch.setattr(urllib.request, "urlopen", mock_urlopen)
+
+        with pytest.raises(FruxonConnectionError, match="Connection refused"):
+            client.execute("my-agent")
+
+
+class TestParseResult:
+    def test_full_response(self):
+        result = _parse_execution_result(SAMPLE_RESPONSE)
+        assert result.response == "Here is your answer."
+        assert result.session_id == "sess-abc"
+        assert result.execution_record_id == "rec-123"
+        assert result.trace.agent_id == "agent-1"
+        assert result.trace.duration == 5000
+        assert result.trace.total_cost == 0.003
+
+    def test_missing_fields_default(self):
+        result = _parse_execution_result({})
+        assert result.response == ""
+        assert result.session_id == ""
+        assert result.execution_record_id == ""
+        assert result.trace.agent_id == ""
+        assert result.trace.duration == 0
+        assert result.trace.total_cost == 0.0

fruxon-0.2.0/src/fruxon/__init__.py

@@ -1,4 +0,0 @@
-"""Top-level package for fruxon-sdk."""
-
-__author__ = "Hagai Cohen"
-__email__ = "hagai@fruxon.com"

fruxon-0.2.0/src/fruxon/cli.py

@@ -1,85 +0,0 @@
-"""Console script for fruxon-sdk."""
-
-from pathlib import Path
-from typing import Annotated
-
-import typer
-from rich.console import Console
-from rich.prompt import IntPrompt
-
-from fruxon.export import MultipleAgentsError, export_agent
-
-app = typer.Typer(help="Fruxon CLI - tools for working with the Fruxon platform.")
-console = Console()
-
-
-@app.callback()
-def main():
-    """Fruxon CLI - tools for working with the Fruxon platform."""
-
-
-@app.command()
-def export(
-    entry_point: Annotated[
-        Path | None, typer.Argument(help="Path to the main Python file. Auto-detected if omitted.")
-    ] = None,
-    output: Annotated[
-        Path | None, typer.Option("--output", "-o", help="Write output to file instead of stdout")
-    ] = None,
-    copy: Annotated[bool, typer.Option("--copy", "-c", help="Copy output to clipboard")] = False,
-):
-    """Export a multi-file Python agent into a single file for Fruxon import.
-
-    Auto-detects the agent entry point by scanning for framework imports
-    (LangChain, CrewAI, Google ADK, etc.). You can also specify the entry
-    point explicitly.
-
-    Examples:
-        fruxon export
-        fruxon export graph.py
-        fruxon export my_agent/main.py -o export.py
-        fruxon export --copy
-    """
-    try:
-        result = export_agent(str(entry_point) if entry_point else None, str(output) if output else None)
-    except MultipleAgentsError as e:
-        # Prompt user to select which agent to export
-        choice = IntPrompt.ask(
-            "\nWhich agent do you want to export?",
-            choices=[str(i) for i in range(1, len(e.entry_points) + 1)],
-        )
-        selected_path = e.entry_points[choice - 1][0]
-        result = export_agent(str(selected_path), str(output) if output else None)
-
-    _handle_output(result, output, copy)
-
-
-def _handle_output(result: str, output: Path | None, copy: bool):
-    """Handle clipboard copy and stdout output."""
-    if copy:
-        _copy_to_clipboard(result)
-
-    if not output and not copy:
-        console.print(result)
-    elif not output and copy:
-        lines = result.count("\n") + 1
-        console.print(f"[dim]{lines} lines ready to paste into Fruxon.[/dim]")
-
-
-def _copy_to_clipboard(text: str):
-    """Copy text to system clipboard."""
-    import subprocess
-
-    for cmd in [["pbcopy"], ["xclip", "-selection", "clipboard"]]:
-        try:
-            process = subprocess.Popen(cmd, stdin=subprocess.PIPE)
-            process.communicate(text.encode("utf-8"))
-            console.print("[green]Copied to clipboard.[/green]")
-            return
-        except FileNotFoundError:
-            continue
-    console.print("[yellow]Clipboard not available. Install xclip or use -o to write to file.[/yellow]")
-
-
-if __name__ == "__main__":
-    app()

fruxon-0.2.0/src/fruxon/fruxon.py

@@ -1 +0,0 @@
-"""Main module."""

fruxon-0.2.0/src/fruxon/utils.py

@@ -1,2 +0,0 @@
-def do_something_useful():
-    print("Replace this with a utility function")