connectonion 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

connectonion/__init__.py

@@ -1,6 +1,6 @@
 """ConnectOnion - A simple agent framework with behavior tracking."""
 
-__version__ = "0.5.8"
+__version__ = "0.5.10"
 
 # Auto-load .env files for the entire framework
 from dotenv import load_dotenv
@@ -15,6 +15,7 @@ from .tool_factory import create_tool_from_function
 from .llm import LLM
 from .logger import Logger
 from .llm_do import llm_do
+from .transcribe import transcribe
 from .prompts import load_system_prompt
 from .xray import xray
 from .decorators import replay, xray_replay
@@ -40,6 +41,7 @@ __all__ = [
     "Logger",
     "create_tool_from_function",
     "llm_do",
+    "transcribe",
     "load_system_prompt",
     "xray",
     "replay",

connectonion/cli/commands/copy_commands.py

@@ -0,0 +1,116 @@
+"""
+Purpose: CLI command to copy built-in tools and plugins to user's project for customization
+LLM-Note:
+  Dependencies: imports from [shutil, pathlib, typing, rich] | imported by [cli/main.py via handle_copy()]
+  Data flow: user runs `co copy <name>` → looks up name in TOOLS/PLUGINS registry → finds source via module.__file__ → copies to ./tools/ or ./plugins/
+  State/Effects: creates tools/ or plugins/ directory if needed | copies .py files from installed package to user's project
+  Integration: exposes handle_copy() for CLI | uses Python import system to find installed package location (cross-platform)
+"""
+
+import shutil
+from pathlib import Path
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+# Registry of copyable tools
+TOOLS = {
+    "gmail": "gmail.py",
+    "outlook": "outlook.py",
+    "google_calendar": "google_calendar.py",
+    "microsoft_calendar": "microsoft_calendar.py",
+    "memory": "memory.py",
+    "web_fetch": "web_fetch.py",
+    "shell": "shell.py",
+    "diff_writer": "diff_writer.py",
+    "todo_list": "todo_list.py",
+    "slash_command": "slash_command.py",
+}
+
+# Registry of copyable plugins
+PLUGINS = {
+    "re_act": "re_act.py",
+    "eval": "eval.py",
+    "image_result_formatter": "image_result_formatter.py",
+    "shell_approval": "shell_approval.py",
+    "gmail_plugin": "gmail_plugin.py",
+    "calendar_plugin": "calendar_plugin.py",
+}
+
+
+def handle_copy(
+    names: List[str],
+    list_all: bool = False,
+    path: Optional[str] = None,
+    force: bool = False
+):
+    """Copy built-in tools and plugins to user's project."""
+
+    # Show list if requested or no names provided
+    if list_all or not names:
+        show_available_items()
+        return
+
+    # Get source directories using import system (works for installed packages)
+    import connectonion.useful_tools as tools_module
+    import connectonion.useful_plugins as plugins_module
+
+    useful_tools_dir = Path(tools_module.__file__).parent
+    useful_plugins_dir = Path(plugins_module.__file__).parent
+
+    current_dir = Path.cwd()
+
+    for name in names:
+        name_lower = name.lower()
+
+        # Check if it's a tool
+        if name_lower in TOOLS:
+            source = useful_tools_dir / TOOLS[name_lower]
+            dest_dir = Path(path) if path else current_dir / "tools"
+            copy_file(source, dest_dir, force)
+
+        # Check if it's a plugin
+        elif name_lower in PLUGINS:
+            source = useful_plugins_dir / PLUGINS[name_lower]
+            dest_dir = Path(path) if path else current_dir / "plugins"
+            copy_file(source, dest_dir, force)
+
+        else:
+            console.print(f"[red]Unknown: {name}[/red]")
+            console.print("Use [cyan]co copy --list[/cyan] to see available items")
+
+
+def copy_file(source: Path, dest_dir: Path, force: bool):
+    """Copy a single file to destination."""
+    if not source.exists():
+        console.print(f"[red]Source not found: {source}[/red]")
+        return
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / source.name
+
+    if dest.exists() and not force:
+        console.print(f"[yellow]Skipped: {dest} (exists, use --force)[/yellow]")
+        return
+
+    shutil.copy2(source, dest)
+    console.print(f"[green]✓ Copied: {dest}[/green]")
+
+
+def show_available_items():
+    """Display available tools and plugins."""
+    table = Table(title="Available Items to Copy")
+    table.add_column("Name", style="cyan")
+    table.add_column("Type", style="green")
+    table.add_column("File")
+
+    for name, file in sorted(TOOLS.items()):
+        table.add_row(name, "tool", file)
+
+    for name, file in sorted(PLUGINS.items()):
+        table.add_row(name, "plugin", file)
+
+    console.print(table)
+    console.print("\n[dim]Usage: co copy <name> [--path ./custom/][/dim]")

connectonion/cli/main.py

@@ -11,7 +11,7 @@ LLM-Note:
 
 import typer
 from rich.console import Console
-from typing import Optional
+from typing import Optional, List
 
 from .. import __version__
 
@@ -54,6 +54,7 @@ def _show_help():
     console.print("[bold]Commands:[/bold]")
     console.print("  [green]create[/green]  <name>     Create new project")
     console.print("  [green]init[/green]              Initialize in current directory")
+    console.print("  [green]copy[/green]   <name>     Copy tool/plugin source to project")
     console.print("  [green]deploy[/green]            Deploy to ConnectOnion Cloud")
     console.print("  [green]auth[/green]              Authenticate for managed keys")
     console.print("  [green]status[/green]            Check account balance")
@@ -139,6 +140,18 @@ def browser(command: str = typer.Argument(..., help="Browser command")):
     handle_browser(command)
 
 
+@app.command()
+def copy(
+    names: List[str] = typer.Argument(None, help="Tool or plugin names to copy"),
+    list_all: bool = typer.Option(False, "--list", "-l", help="List available items"),
+    path: Optional[str] = typer.Option(None, "--path", "-p", help="Custom destination path"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),
+):
+    """Copy built-in tools/plugins to customize."""
+    from .commands.copy_commands import handle_copy
+    handle_copy(names=names or [], list_all=list_all, path=path, force=force)
+
+
 def cli():
     """Entry point."""
     app()

connectonion/connect.py

@@ -1,40 +1,70 @@
 """
-Purpose: Client interface for connecting to remote agents via relay network using INPUT/OUTPUT protocol
+Purpose: Client interface for connecting to remote agents via HTTP or relay network
 LLM-Note:
-  Dependencies: imports from [asyncio, json, uuid, websockets] | imported by [__init__.py, tests/test_connect.py, examples/] | tested by [tests/test_connect.py, tests/integration/manual/network_connect_manual.py]
-  Data flow: user calls connect(address, relay_url) → creates RemoteAgent instance → user calls .input(prompt) → _send_task() creates WebSocket to relay /ws/input → sends INPUT message with {type, input_id, to, prompt} → waits for OUTPUT response from relay → returns result string OR raises ConnectionError
-  State/Effects: establishes temporary WebSocket connection per task (no persistent connection) | sends INPUT messages to relay | receives OUTPUT/ERROR messages | no file I/O or global state | asyncio.run() blocks on .input(), await on .input_async()
-  Integration: exposes connect(address, relay_url), RemoteAgent class with .input(prompt, timeout), .input_async(prompt, timeout) | default relay_url="wss://oo.openonion.ai/ws/announce" | address format: 0x + 64 hex chars (Ed25519 public key) | complements host() with relay_url which listens for INPUT on relay | Protocol: INPUT type with to/prompt fields → OUTPUT type with input_id/result fields
-  Performance: creates new WebSocket connection per input() call (no connection pooling) | default timeout=30s | async under the hood (asyncio.run wraps for sync API) | no caching or retry logic
-  Errors: raises ImportError if websockets not installed | raises ConnectionError for ERROR responses from relay | raises ConnectionError for unexpected response types | asyncio.TimeoutError if no response within timeout | WebSocket connection errors bubble up
+  Dependencies: imports from [asyncio, json, uuid, time, aiohttp, websockets, address] | imported by [__init__.py, tests/test_connect.py, examples/] | tested by [tests/test_connect.py]
+  Data flow: connect(address, keys) → RemoteAgent → input() → discover endpoints → try HTTP first → fallback to relay → return result
+  State/Effects: caches discovered endpoint for reuse | optional signing with keys parameter
+  Integration: exposes connect(address, keys, relay_url), RemoteAgent class with .input(), .input_async()
+  Performance: discovery cached per RemoteAgent instance | HTTPS tried first (direct), relay as fallback
 
 Connect to remote agents on the network.
 
-Simple function-based API for using remote agents.
+Smart discovery: tries HTTP endpoints first, falls back to relay.
+Always signs requests when keys are provided.
 """
 
 import asyncio
 import json
+import time
 import uuid
+from typing import Any, Dict, List, Optional
+
+from . import address as addr
 
 
 class RemoteAgent:
     """
     Interface to a remote agent.
 
-    Minimal MVP: Just input() method.
+    Supports:
+    - Discovery via relay API
+    - Direct HTTP POST to agent /input endpoint
+    - WebSocket relay fallback
+    - Signed requests when keys provided
+    - Multi-turn conversations via session management
+
+    Usage:
+        # Standard Python scripts
+        agent = connect("0x...")
+        result = agent.input("Hello")
+
+        # Jupyter notebooks or async code
+        agent = connect("0x...")
+        result = await agent.input_async("Hello")
     """
 
-    def __init__(self, address: str, relay_url: str):
-        self.address = address
+    def __init__(
+        self,
+        agent_address: str,
+        *,
+        keys: Optional[Dict[str, Any]] = None,
+        relay_url: str = "wss://oo.openonion.ai/ws/announce"
+    ):
+        self.address = agent_address
+        self._keys = keys
         self._relay_url = relay_url
+        self._cached_endpoint: Optional[str] = None
+        self._session: Optional[Dict[str, Any]] = None  # Multi-turn conversation state
 
     def input(self, prompt: str, timeout: float = 30.0) -> str:
         """
         Send task to remote agent and get response (sync version).
 
-        Use this in normal synchronous code.
-        For async code, use input_async() instead.
+        Automatically maintains conversation context across calls.
+
+        Note:
+            This method cannot be used inside an async context (e.g., Jupyter notebooks,
+            async functions). Use input_async() instead in those environments.
 
         Args:
             prompt: Task/prompt to send
@@ -43,17 +73,32 @@ class RemoteAgent:
         Returns:
             Agent's response string
 
+        Raises:
+            RuntimeError: If called from within a running event loop
+
         Example:
             >>> translator = connect("0x3d40...")
             >>> result = translator.input("Translate 'hello' to Spanish")
+            >>> # Continue conversation
+            >>> result2 = translator.input("Now translate it to French")
         """
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "input() cannot be used inside async context (e.g., Jupyter notebooks). "
+                "Use 'await agent.input_async()' instead."
+            )
+        except RuntimeError as e:
+            if "input() cannot be used" in str(e):
+                raise
+            # No running loop - safe to proceed
         return asyncio.run(self._send_task(prompt, timeout))
 
     async def input_async(self, prompt: str, timeout: float = 30.0) -> str:
         """
         Send task to remote agent and get response (async version).
 
-        Use this when calling from async code.
+        Automatically maintains conversation context across calls.
 
         Args:
             prompt: Task/prompt to send
@@ -61,42 +106,93 @@ class RemoteAgent:
 
         Returns:
             Agent's response string
-
-        Example:
-            >>> remote = connect("0x3d40...")
-            >>> result = await remote.input_async("Translate 'hello' to Spanish")
         """
         return await self._send_task(prompt, timeout)
 
-    async def _send_task(self, prompt: str, timeout: float) -> str:
-        """
-        Send input via relay and wait for output.
+    def reset_conversation(self):
+        """Clear conversation history and start fresh."""
+        self._session = None
 
-        MVP: Uses relay to route INPUT/OUTPUT messages between agents.
-        """
+    def _sign_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Sign a payload if keys are available."""
+        if not self._keys:
+            return {"prompt": payload.get("prompt", "")}
+
+        canonical = json.dumps(payload, sort_keys=True, separators=(',', ':'))
+        signature = addr.sign(self._keys, canonical.encode())
+        return {
+            "payload": payload,
+            "from": self._keys["address"],
+            "signature": signature.hex()
+        }
+
+    async def _discover_endpoints(self) -> List[str]:
+        """Query relay API for agent endpoints."""
+        import aiohttp
+
+        # Convert wss://oo.openonion.ai/ws/announce to https://oo.openonion.ai
+        base_url = self._relay_url.replace("wss://", "https://").replace("ws://", "http://")
+        base_url = base_url.replace("/ws/announce", "")
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{base_url}/api/relay/agents/{self.address}") as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    if data.get("online"):
+                        return data.get("endpoints", [])
+        return []
+
+    def _create_signed_body(self, prompt: str) -> Dict[str, Any]:
+        """Create signed request body for agent /input endpoint."""
+        payload = {"prompt": prompt, "to": self.address, "timestamp": int(time.time())}
+        body = self._sign_payload(payload)
+        if self._session:
+            body["session"] = self._session
+        return body
+
+    async def _send_http(self, endpoint: str, prompt: str, timeout: float) -> str:
+        """Send request via direct HTTP POST to agent /input endpoint."""
+        import aiohttp
+
+        body = self._create_signed_body(prompt)
+
+        async with aiohttp.ClientSession() as http_session:
+            async with http_session.post(
+                f"{endpoint}/input",
+                json=body,
+                timeout=aiohttp.ClientTimeout(total=timeout)
+            ) as resp:
+                data = await resp.json()
+                if not resp.ok:
+                    raise ConnectionError(data.get("error", f"HTTP {resp.status}"))
+                # Save session for conversation continuation
+                if "session" in data:
+                    self._session = data["session"]
+                return data.get("result", "")
+
+    async def _send_relay(self, prompt: str, timeout: float) -> str:
+        """Send request via WebSocket relay."""
         import websockets
 
         input_id = str(uuid.uuid4())
-
-        # Connect to relay input endpoint
         relay_input_url = self._relay_url.replace("/ws/announce", "/ws/input")
 
         async with websockets.connect(relay_input_url) as ws:
-            # Send INPUT message
+            payload = {"prompt": prompt, "to": self.address, "timestamp": int(time.time())}
+            signed = self._sign_payload(payload)
+
             input_message = {
                 "type": "INPUT",
                 "input_id": input_id,
                 "to": self.address,
-                "prompt": prompt
+                **signed
             }
 
             await ws.send(json.dumps(input_message))
 
-            # Wait for OUTPUT
             response_data = await asyncio.wait_for(ws.recv(), timeout=timeout)
             response = json.loads(response_data)
 
-            # Return result
             if response.get("type") == "OUTPUT" and response.get("input_id") == input_id:
                 return response.get("result", "")
             elif response.get("type") == "ERROR":
@@ -104,25 +200,73 @@ class RemoteAgent:
             else:
                 raise ConnectionError(f"Unexpected response: {response}")
 
+    async def _send_task(self, prompt: str, timeout: float) -> str:
+        """
+        Send task using best available connection method.
+
+        Priority:
+        1. Cached endpoint (if previously successful)
+        2. Discovered HTTPS endpoints
+        3. Discovered HTTP endpoints
+        4. Relay fallback
+        """
+        # Try cached endpoint first
+        if self._cached_endpoint:
+            try:
+                return await self._send_http(self._cached_endpoint, prompt, timeout)
+            except Exception:
+                self._cached_endpoint = None  # Clear failed cache
+
+        # Discover endpoints
+        endpoints = await self._discover_endpoints()
+
+        # Sort: HTTPS first, then HTTP
+        endpoints.sort(key=lambda e: (0 if e.startswith("https://") else 1))
+
+        # Try each endpoint
+        for endpoint in endpoints:
+            try:
+                result = await self._send_http(endpoint, prompt, timeout)
+                self._cached_endpoint = endpoint  # Cache successful endpoint
+                return result
+            except Exception:
+                continue
+
+        # Fallback to relay
+        return await self._send_relay(prompt, timeout)
+
     def __repr__(self):
         short = self.address[:12] + "..." if len(self.address) > 12 else self.address
         return f"RemoteAgent({short})"
 
 
-def connect(address: str, relay_url: str = "wss://oo.openonion.ai/ws/announce") -> RemoteAgent:
+def connect(
+    address: str,
+    *,
+    keys: Optional[Dict[str, Any]] = None,
+    relay_url: str = "wss://oo.openonion.ai/ws/announce"
+) -> RemoteAgent:
     """
     Connect to a remote agent.
 
     Args:
         address: Agent's public key address (0x...)
+        keys: Signing keys from address.load() - required for strict trust agents
         relay_url: Relay server URL (default: production)
 
     Returns:
         RemoteAgent interface
 
     Example:
-        >>> from connectonion import connect
-        >>> translator = connect("0x3d4017c3...")
-        >>> result = translator.input("Translate 'hello' to Spanish")
+        >>> from connectonion import connect, address
+        >>>
+        >>> # Simple (unsigned)
+        >>> agent = connect("0x3d4017c3...")
+        >>> result = agent.input("Hello")
+        >>>
+        >>> # With signing (for strict trust agents)
+        >>> keys = address.load(Path(".co"))
+        >>> agent = connect("0x3d4017c3...", keys=keys)
+        >>> result = agent.input("Hello")
     """
-    return RemoteAgent(address, relay_url)
+    return RemoteAgent(address, keys=keys, relay_url=relay_url)

connectonion/host.py

@@ -9,7 +9,13 @@ Trust parameter accepts three forms:
 3. Agent: Custom Agent instance for verification
 
 All forms create a trust agent behind the scenes.
+
+Worker Isolation:
+Each request gets a fresh deep copy of the agent template.
+This ensures complete isolation - tools with state (like BrowserTool)
+don't interfere between concurrent requests.
 """
+import copy
 import hashlib
 import json
 import logging
@@ -102,17 +108,18 @@ class SessionStorage:
 
 # === Handlers (pure functions) ===
 
-def input_handler(agent, storage: SessionStorage, prompt: str, result_ttl: int,
+def input_handler(agent_template, storage: SessionStorage, prompt: str, result_ttl: int,
                   session: dict | None = None) -> dict:
     """POST /input
 
     Args:
-        agent: The agent to process the request
+        agent_template: The agent template (deep copied per request for isolation)
         storage: SessionStorage for persisting results
         prompt: The user's prompt
         result_ttl: How long to keep the result on server
         session: Optional conversation session for continuation
     """
+    agent = copy.deepcopy(agent_template)
     now = time.time()
 
     # Get or generate session_id
@@ -368,7 +375,12 @@ def admin_logs_handler(agent_name: str) -> dict:
 
 
 def admin_sessions_handler() -> dict:
-    """GET /admin/sessions - return all activity sessions as JSON array."""
+    """GET /admin/sessions - return raw session YAML files as JSON.
+
+    Returns session files as-is (converted from YAML to JSON). Each session
+    contains: name, created, updated, total_cost, total_tokens, turns array.
+    Frontend handles the display logic.
+    """
     import yaml
     sessions_dir = Path(".co/sessions")
     if not sessions_dir.exists():
@@ -381,30 +393,34 @@ def admin_sessions_handler() -> dict:
             if session_data:
                 sessions.append(session_data)
 
-    # Sort by created date descending (newest first)
-    sessions.sort(key=lambda s: s.get("created", ""), reverse=True)
+    # Sort by updated date descending (newest first)
+    sessions.sort(key=lambda s: s.get("updated", s.get("created", "")), reverse=True)
     return {"sessions": sessions}
 
 
 # === Entry Point ===
 
-def _create_handlers(agent, result_ttl: int):
+def _create_handlers(agent_template, result_ttl: int):
     """Create handler dict for ASGI app."""
+    def ws_input(prompt: str) -> str:
+        agent = copy.deepcopy(agent_template)
+        return agent.input(prompt)
+
     return {
-        "input": lambda storage, prompt, ttl, session=None: input_handler(agent, storage, prompt, ttl, session),
+        "input": lambda storage, prompt, ttl, session=None: input_handler(agent_template, storage, prompt, ttl, session),
         "session": session_handler,
         "sessions": sessions_handler,
-        "health": lambda start_time: health_handler(agent, start_time),
-        "info": lambda trust: info_handler(agent, trust),
+        "health": lambda start_time: health_handler(agent_template, start_time),
+        "info": lambda trust: info_handler(agent_template, trust),
         "auth": extract_and_authenticate,
-        "ws_input": agent.input,
+        "ws_input": ws_input,
         # Admin endpoints (auth required via OPENONION_API_KEY)
-        "admin_logs": lambda: admin_logs_handler(agent.name),
+        "admin_logs": lambda: admin_logs_handler(agent_template.name),
         "admin_sessions": admin_sessions_handler,
     }
 
 
-def _start_relay_background(agent, relay_url: str, addr_data: dict):
+def _start_relay_background(agent_template, relay_url: str, addr_data: dict):
     """Start relay connection in background thread.
 
     The relay connection runs alongside the HTTP server, allowing the agent
@@ -415,11 +431,12 @@ def _start_relay_background(agent, relay_url: str, addr_data: dict):
     from . import announce, relay
 
     # Create ANNOUNCE message
-    summary = agent.system_prompt[:1000] if agent.system_prompt else f"{agent.name} agent"
+    summary = agent_template.system_prompt[:1000] if agent_template.system_prompt else f"{agent_template.name} agent"
     announce_msg = announce.create_announce_message(addr_data, summary, endpoints=[])
 
-    # Task handler that routes to agent.input()
+    # Task handler - deep copy for each request
     async def task_handler(prompt: str) -> str:
+        agent = copy.deepcopy(agent_template)
         return agent.input(prompt)
 
     async def relay_loop():

connectonion/transcribe.py

@@ -0,0 +1,245 @@
+"""
+Purpose: Audio transcription utility using Gemini API
+LLM-Note:
+  Dependencies: imports from [os, base64, pathlib, mimetypes, google.generativeai] | imported by [user code] | tested by [tests/test_transcribe.py]
+  Data flow: transcribe(audio, prompt, model) → load audio file → encode base64 → call Gemini API → return text
+  State/Effects: reads audio files from disk | makes Gemini API request | no caching
+  Integration: exposes transcribe(audio, prompt, model, timestamps) | similar pattern to llm_do()
+  Performance: one API call per transcription | files < 20MB use inline, larger use File API
+  Errors: raises ValueError if audio file not found | FileNotFoundError for missing files
+
+Audio transcription utility for ConnectOnion framework.
+
+This module provides the `transcribe()` function - a simple interface for
+converting audio files to text using Gemini's multimodal capabilities.
+
+Usage:
+    >>> from connectonion import transcribe
+
+    # Simple transcription
+    >>> text = transcribe("meeting.mp3")
+
+    # With context hints (improve accuracy for domain-specific terms)
+    >>> text = transcribe("meeting.mp3", prompt="Technical AI discussion, speakers: Aaron, Lisa")
+
+    # Different model
+    >>> text = transcribe("meeting.mp3", model="co/gemini-2.5-flash")
+
+Supported formats: WAV, MP3, AIFF, AAC, OGG, FLAC
+Token cost: 32 tokens per second of audio (1 minute = 1,920 tokens)
+"""
+
+import os
+import base64
+import mimetypes
+from pathlib import Path
+from typing import Optional
+import httpx
+
+
+# MIME type mapping for audio formats
+AUDIO_MIME_TYPES = {
+    ".wav": "audio/wav",
+    ".mp3": "audio/mp3",
+    ".aiff": "audio/aiff",
+    ".aac": "audio/aac",
+    ".ogg": "audio/ogg",
+    ".flac": "audio/flac",
+    ".m4a": "audio/mp4",
+    ".webm": "audio/webm",
+}
+
+# Maximum file size for inline audio (20MB)
+MAX_INLINE_SIZE = 20 * 1024 * 1024
+
+
+def _get_mime_type(file_path: Path) -> str:
+    """Get MIME type for audio file."""
+    suffix = file_path.suffix.lower()
+    if suffix in AUDIO_MIME_TYPES:
+        return AUDIO_MIME_TYPES[suffix]
+    # Fallback to mimetypes library
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    return mime_type or "audio/mpeg"
+
+
+def _get_api_key(model: str) -> str:
+    """Get API key based on model."""
+    if model.startswith("co/"):
+        # Use OpenOnion managed keys
+        api_key = os.getenv("OPENONION_API_KEY")
+        if not api_key:
+            # Try loading from config file
+            config_path = Path.home() / ".connectonion" / ".co" / "config.toml"
+            if config_path.exists():
+                import toml
+                config = toml.load(config_path)
+                api_key = config.get("auth", {}).get("jwt_token")
+        if not api_key:
+            raise ValueError(
+                "OpenOnion API key required for co/ models. "
+                "Run `co auth` to authenticate or set OPENONION_API_KEY."
+            )
+        return api_key
+    else:
+        # Use Gemini API key directly
+        api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Gemini API key required. Set GEMINI_API_KEY environment variable."
+            )
+        return api_key
+
+
+def transcribe(
+    audio: str,
+    prompt: Optional[str] = None,
+    model: str = "co/gemini-3-flash-preview",
+    timestamps: bool = False,
+) -> str:
+    """
+    Transcribe audio file to text using Gemini.
+
+    Args:
+        audio: Path to audio file (WAV, MP3, AIFF, AAC, OGG, FLAC)
+        prompt: Optional context hints for better accuracy
+                (e.g., "Technical AI discussion, speakers: Aaron, Lisa")
+        model: Model to use (default: co/gemini-3-flash-preview)
+        timestamps: If True, include timestamps in output
+
+    Returns:
+        Transcribed text
+
+    Examples:
+        >>> # Simple transcription
+        >>> text = transcribe("meeting.mp3")
+
+        >>> # With context hints
+        >>> text = transcribe("meeting.mp3", prompt="Fix: ConnectOnion, OpenOnion")
+
+        >>> # With timestamps
+        >>> text = transcribe("podcast.mp3", timestamps=True)
+
+    Raises:
+        FileNotFoundError: If audio file doesn't exist
+        ValueError: If API key is missing or invalid audio format
+    """
+    # Validate file exists
+    file_path = Path(audio)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Audio file not found: {audio}")
+
+    # Get file info
+    file_size = file_path.stat().st_size
+    mime_type = _get_mime_type(file_path)
+
+    # Read and encode audio
+    with open(file_path, "rb") as f:
+        audio_bytes = f.read()
+    audio_base64 = base64.standard_b64encode(audio_bytes).decode("utf-8")
+
+    # Build prompt
+    if timestamps:
+        system_prompt = "Transcribe this audio with timestamps in [MM:SS] format."
+    else:
+        system_prompt = "Transcribe this audio accurately."
+
+    if prompt:
+        system_prompt += f" Context: {prompt}"
+
+    # Get API key and model name
+    api_key = _get_api_key(model)
+    actual_model = model[3:] if model.startswith("co/") else model
+
+    # Use OpenOnion proxy for co/ models, direct Gemini API otherwise
+    if model.startswith("co/"):
+        return _transcribe_via_openonion(
+            audio_base64, mime_type, system_prompt, api_key, actual_model
+        )
+    else:
+        return _transcribe_via_gemini(
+            audio_base64, mime_type, system_prompt, api_key, actual_model
+        )
+
+
+def _transcribe_via_gemini(
+    audio_base64: str,
+    mime_type: str,
+    prompt: str,
+    api_key: str,
+    model: str,
+) -> str:
+    """Transcribe using Gemini's OpenAI-compatible endpoint."""
+    import openai
+
+    client = openai.OpenAI(
+        api_key=api_key,
+        base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+    )
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": audio_base64,
+                            "format": mime_type.split("/")[-1],  # e.g., "mp3"
+                        },
+                    },
+                ],
+            }
+        ],
+    )
+
+    return response.choices[0].message.content
+
+
+def _transcribe_via_openonion(
+    audio_base64: str,
+    mime_type: str,
+    prompt: str,
+    api_key: str,
+    model: str,
+) -> str:
+    """Transcribe using OpenOnion proxy (for co/ models)."""
+    # Determine API URL
+    is_dev = os.getenv("OPENONION_DEV") or os.getenv("ENVIRONMENT") == "development"
+    base_url = "http://localhost:8000" if is_dev else "https://oo.openonion.ai"
+
+    # Build request
+    request_body = {
+        "model": model,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": audio_base64,
+                            "format": mime_type.split("/")[-1],
+                        },
+                    },
+                ],
+            }
+        ],
+    }
+
+    response = httpx.post(
+        f"{base_url}/v1/chat/completions",
+        json=request_body,
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=120.0,
+    )
+
+    if response.status_code != 200:
+        raise ValueError(f"Transcription failed: {response.status_code} - {response.text}")
+
+    data = response.json()
+    return data["choices"][0]["message"]["content"]

{connectonion-0.5.8.dist-info → connectonion-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: connectonion
-Version: 0.5.8
+Version: 0.5.10
 Summary: A simple Python framework for creating AI agents with behavior tracking
 Project-URL: Homepage, https://github.com/openonion/connectonion
 Project-URL: Documentation, https://docs.connectonion.com

{connectonion-0.5.8.dist-info → connectonion-0.5.10.dist-info}/RECORD

@@ -1,15 +1,15 @@
-connectonion/__init__.py,sha256=pizZ0Tuzkb8z26SqkbZGfK9PpCTaytBdL_WL2TWhiFk,1887
+connectonion/__init__.py,sha256=VHZugKSYm3j_qeLiLS93Ee7mqJJ0uPvl9BtLRkKJkBE,1941
 connectonion/address.py,sha256=YOzpMOej-HqJUE6o0i0fG8rB7HM-Iods36s9OD--5ig,10852
 connectonion/agent.py,sha256=BHnP4N0odXCSn9xT0QnJpXj3VV-E_vUtNXJ0M6k3RNs,18889
 connectonion/announce.py,sha256=47Lxe8S4yyTbpsmYUmakU_DehrGvljyldmPfKnAOrFQ,3365
 connectonion/asgi.py,sha256=VTMwwEWLq5RYvIufRImMcv-AB5D5pZmM8INaXqwUt4Q,9621
 connectonion/auto_debug_exception.py,sha256=iA-b5GC40AI4YVXen2UCkDkfHLVZehFPgZrinIxykWI,8147
-connectonion/connect.py,sha256=dn5dWDkZZpKGW5St-CtAAfTM2-1IOe3luv0vQSA2ogk,5311
+connectonion/connect.py,sha256=dYuBKxUvcNeyR0IbcKrnspwylp7177JmBYz5DsRhiXQ,9794
 connectonion/console.py,sha256=6_J1ItkLJCHDpdJY-tCuw4jMcS09S-a5juZSDSIr1Nc,21254
 connectonion/debugger_ui.py,sha256=QMyoZkhGbt-pStHHjpnCBXtfzvfqPW94tXiL07KZiAw,41741
 connectonion/decorators.py,sha256=YFmZMptcchIgNriKFf_vOyacor5i_j6Cy_igTJhdKm4,7141
 connectonion/events.py,sha256=jJOMt1PhRl-ef4R8-WpAq8pUbZ8GKIl0wOB2kJUVyWg,9151
-connectonion/host.py,sha256=G3b50iuDv8BTOtL-6COOt9KcFVczzl-mROgQQVFFFfk,18690
+connectonion/host.py,sha256=eVB907_oFcn2MH-8fRnhR-_-o17S7JjchkggPS5kLVA,19437
 connectonion/interactive_debugger.py,sha256=XHSCGJp9YV6VAZM1gk_AuxKAdBODJQUcLVWaLuTMqv0,16277
 connectonion/llm.py,sha256=IzjlOT6Dj5xIplIymjcaHZ_abwE5wDHEE4pa8zjlEGY,32952
 connectonion/llm_do.py,sha256=YI7kGFKpB6KUEG_CKtP3Bl4IWmRac7TCa9GK5FSV624,12000
@@ -19,6 +19,7 @@ connectonion/relay.py,sha256=a8wj4UZDZpGEhvpyDuRjZJg1S1VzxqiPioQRLq1EAao,7160
 connectonion/tool_executor.py,sha256=IPCVRS20XOd5JsZrdXRwK-gI6Xb0BtDQ3fCD0qt2dcE,10617
 connectonion/tool_factory.py,sha256=vo4_pyhqKG_OtfpjV15oPG4zlkxn40768PW5pQVtx-g,6704
 connectonion/tool_registry.py,sha256=rTe8RJnWXpmHXWznP468fhWvmRknk-TlF9Iz8G9_qus,4367
+connectonion/transcribe.py,sha256=m2qd7A2qMKFAbmbLLgvcd-yUFz8FHgjUKtvtFffnK00,7730
 connectonion/trust.py,sha256=It4ueuMvCmHOD7FwaV-jSwlonWFsFgNH1gz9fJtmfW4,6692
 connectonion/trust_agents.py,sha256=XDedEhxGRfu9KeYhX-Z1a5tRA-2Zbwz4ztnlA2Lnaf0,2968
 connectonion/trust_functions.py,sha256=jRgfPm5z8oy9x8IYJd20UUMCz7cc1Pd7zyqQK5SDdLc,3564
@@ -26,13 +27,14 @@ connectonion/usage.py,sha256=mS_J5it9NMDI1CjycNUJEnXGNXAo1lQ1ICEZvqftTpU,6205
 connectonion/xray.py,sha256=TA_VychqQRtfSzO3RmTqnDZZNx3LjycbgUWVyMswAIw,18542
 connectonion/cli/__init__.py,sha256=Pd1iKp0rUghs2kmdAhyp9hK8j0uWkNxOagBkdCGrG4I,55
 connectonion/cli/docs.md,sha256=Fk_JT8jFXXDpXTvU0ZUigMW1UR6ERmX-HDheYPPRNY8,3231
-connectonion/cli/main.py,sha256=gV-xAomC-UgA3VG7nUrDg_8AS8XZBxxgNLGL_Yxxzag,6232
+connectonion/cli/main.py,sha256=2FWi-yhnyLQzZl_esOXYY3-u0Q1wbpdE4XG3QYoGm_Q,6893
 connectonion/cli/browser_agent/__init__.py,sha256=xZCoxS3dGVBBMnaasHOE1vxMDdIwUloRP67rGR-4obo,173
 connectonion/cli/browser_agent/browser.py,sha256=EdBAvpcfCHh8q6_-3-LVBw6OHyMYnz1_8m6gryWQdzM,8830
 connectonion/cli/browser_agent/prompt.md,sha256=tF0PhGcl3gkmVK1F5SG9GZwnPPXTZYWEaatAZtOYZZg,4479
 connectonion/cli/commands/__init__.py,sha256=IPZy9NwrE0hs4f7hIqyFM9GjFZpeCS8mC0Jf-5Ooy4c,43
 connectonion/cli/commands/auth_commands.py,sha256=D76_0yd77d23bXRvsTAY6HOcGJswo9-6z2dRi9CR9sE,21635
 connectonion/cli/commands/browser_commands.py,sha256=lB4N6XwP43qdcthwQWlbFU2S3INfxhRDXznAw1PSTsQ,1803
+connectonion/cli/commands/copy_commands.py,sha256=9cRpTFlBKrFXgJw582YJqKLq6o1dmwPB_c9RHEJc76c,3852
 connectonion/cli/commands/create.py,sha256=0TrsPulS6dqwr_gtIWWBQ03Q_BnNro-CV4qOV5VkHAg,22011
 connectonion/cli/commands/deploy_commands.py,sha256=s0bjApUQbNlMGStUSrAB8RqSSewBlHrBL60NWgEIHhc,8248
 connectonion/cli/commands/doctor_commands.py,sha256=EOk8CMclvVqLq4-Dg2JghWehH9VQnthBejrhIBX66_4,7244
@@ -107,7 +109,7 @@ connectonion/useful_tools/slash_command.py,sha256=VKl7SKLyaxHcHwfE8rgzBCQ2-KQtL0
 connectonion/useful_tools/terminal.py,sha256=PtzGHN6vnWROmssi37YOZ5U-d0Z7Fe79bocoKAngoxg,9330
 connectonion/useful_tools/todo_list.py,sha256=wVEt4kt-MczIcP3xvKelfshGHZ6EATpDFzQx0zov8cw,7483
 connectonion/useful_tools/web_fetch.py,sha256=CysJLOdDIkbMVJ12Dj3WgsytLu1-o2wrwNopqA_S1jk,7253
-connectonion-0.5.8.dist-info/METADATA,sha256=u1GuMFftzTCEkj_N_cIfWNv2iEXHSsyHK-ggqin89qY,21902
-connectonion-0.5.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-connectonion-0.5.8.dist-info/entry_points.txt,sha256=XDB-kVN7Qgy4DmYTkjQB_O6hZeUND-SqmZbdoQPn6WA,90
-connectonion-0.5.8.dist-info/RECORD,,
+connectonion-0.5.10.dist-info/METADATA,sha256=1xQJXemh__kTUwluT5sYBIG0FasMf2mfdmLd1QszJxg,21903
+connectonion-0.5.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+connectonion-0.5.10.dist-info/entry_points.txt,sha256=XDB-kVN7Qgy4DmYTkjQB_O6hZeUND-SqmZbdoQPn6WA,90
+connectonion-0.5.10.dist-info/RECORD,,