webagents 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

webagents/agents/skills/robutler/nli/skill.py

@@ -232,14 +232,13 @@ class NLISkill(Skill):
     @prompt(priority=20, scope="all")
     def nli_general_prompt(self, context: Any = None) -> str:
         base_url = self.agent_base_url.rstrip('/')
-        return f"""You are part of a network of AI agents working for their owners. Each agent has their own name and address. 
-
-CRITICAL: When you need to communicate with another agent:
-1. Convert @agentname to the full URL: {base_url}/agents/agentname
-2. Use the nli_tool to send your message to that URL
-3. DO NOT just store or retrieve agent names - actually communicate with them
-
-"""
+        agent_name = self.agent.name if self.agent and hasattr(self.agent, 'name') else None
+        
+        prompt = f"Agents: Convert @name to {base_url}/agents/name, use nli_tool. DON'T call yourself.\n"
+        if agent_name:
+            prompt += f"You are @{agent_name}. NEVER call {base_url}/agents/{agent_name} via NLI!\n"
+        
+        return prompt
     
     @tool(description="Communicate with other WebAgents agents via natural language", scope="all")
     async def nli_tool(self, 
@@ -270,6 +269,15 @@ CRITICAL: When you need to communicate with another agent:
         """
         start_time = datetime.utcnow()
         
+        # CRITICAL: Prevent self-calling via NLI
+        if self.agent and hasattr(self.agent, 'name'):
+            agent_name = self.agent.name
+            # Check if the URL contains the agent's own name
+            if f"/agents/{agent_name}" in agent_url or agent_url.endswith(f"/{agent_name}"):
+                error_msg = f"❌ ERROR: Cannot use nli_tool to call yourself (@{agent_name})! You should execute your own tasks directly instead of delegating to yourself via NLI."
+                self.logger.error(error_msg)
+                return error_msg
+        
         # Validate and normalize parameters
         if authorized_amount is None:
             authorized_amount = self.default_authorization
@@ -295,7 +303,7 @@ CRITICAL: When you need to communicate with another agent:
                     "content": message
                 }
             ],
-            "stream": False,
+            "stream": True,  # Enable streaming to work around LiteLLM bug (non-streaming drops image data)
             "temperature": 0.7,
             "max_tokens": 2048
         }
@@ -323,36 +331,45 @@ CRITICAL: When you need to communicate with another agent:
             # CRITICAL: Forward payment token from current context to enable agent-to-agent billing
             payment_token = None
             
+            self.logger.debug(f"🔐 Token lookup: ctx={ctx is not None}")
+            if ctx:
+                self.logger.debug(f"🔐 Token lookup: ctx attrs={list(vars(ctx).keys())[:10]}")
+            
             # Method 1: Check if payment_token is directly available in context
             if ctx and hasattr(ctx, 'payment_token') and ctx.payment_token:
                 payment_token = ctx.payment_token
-                self.logger.debug(f"🔐 Found payment token in context.payment_token")
+                self.logger.debug(f"🔐 Found payment token in context.payment_token: {payment_token[:20]}...")
             
             # Method 2: Extract from request headers (most common case)
             elif ctx and hasattr(ctx, 'request') and ctx.request:
                 request_headers = getattr(ctx.request, 'headers', {})
+                self.logger.debug(f"🔐 Token lookup: request_headers type={type(request_headers)}")
                 if hasattr(request_headers, 'get'):
+                    self.logger.debug(f"🔐 Token lookup: checking headers for payment token")
                     payment_token = (
                         request_headers.get('X-Payment-Token') or 
                         request_headers.get('x-payment-token') or
                         request_headers.get('payment_token')
                     )
                     if payment_token:
-                        self.logger.debug(f"🔐 Found payment token in request headers")
+                        self.logger.debug(f"🔐 Found payment token in request headers: {payment_token[:20]}...")
+                    else:
+                        self.logger.debug(f"🔐 No payment token in request headers")
             
             # Method 3: Check custom_data for payment context (fallback)
             elif ctx and hasattr(ctx, 'custom_data') and ctx.custom_data:
+                self.logger.debug(f"🔐 Token lookup: checking custom_data")
                 payment_context = ctx.custom_data.get('payment_context')
                 if payment_context and hasattr(payment_context, 'payment_token'):
                     payment_token = payment_context.payment_token
-                    self.logger.debug(f"🔐 Found payment token in custom_data.payment_context")
+                    self.logger.debug(f"🔐 Found payment token in custom_data.payment_context: {payment_token[:20]}...")
             
             # Forward the payment token if found
             if payment_token:
                 headers["X-Payment-Token"] = payment_token
-                self.logger.debug(f"🔐 Forwarding payment token for agent-to-agent communication: {payment_token[:20]}...")
+                self.logger.info(f"🔐 ✅ Forwarding payment token for agent-to-agent communication: {payment_token[:20]}...")
             else:
-                self.logger.debug(f"🔐 No payment token found to forward - target agent may require payment")
+                self.logger.warning(f"🔐 ❌ No payment token found to forward - target agent may require payment")
         except Exception:
             acting_user_id = None
 
@@ -437,17 +454,31 @@ CRITICAL: When you need to communicate with another agent:
                     duration_ms = (datetime.utcnow() - start_time).total_seconds() * 1000
                     
                     if response.status_code == 200:
-                        response_data = response.json()
+                        # Handle streaming response (SSE format)
+                        agent_response = ""
+                        async for line in response.aiter_lines():
+                            if not line or line.strip() == "":
+                                continue
+                            if line.startswith("data: "):
+                                data_str = line[6:]  # Remove "data: " prefix
+                                if data_str == "[DONE]":
+                                    break
+                                try:
+                                    chunk_data = json.loads(data_str)
+                                    if 'choices' in chunk_data and len(chunk_data['choices']) > 0:
+                                        choice = chunk_data['choices'][0]
+                                        # Check delta (streaming) or message (non-streaming)
+                                        for msg_key in ['delta', 'message']:
+                                            if msg_key in choice:
+                                                msg = choice[msg_key]
+                                                if 'content' in msg and msg['content']:
+                                                    agent_response += msg['content']
+                                except json.JSONDecodeError:
+                                    pass  # Skip malformed chunks
                         
-                        # Extract message content from OpenAI-compatible response
-                        if 'choices' in response_data and len(response_data['choices']) > 0:
-                            choice = response_data['choices'][0]
-                            if 'message' in choice and 'content' in choice['message']:
-                                agent_response = choice['message']['content']
-                            else:
-                                agent_response = str(response_data)
-                        else:
-                            agent_response = str(response_data)
+                        if not agent_response:
+                            # Fallback: maybe it's actually not streaming despite request?
+                            agent_response = str(response_data) if 'response_data' in locals() else "No response"
                         
                         # Track successful communication
                         communication = NLICommunication(
@@ -547,6 +578,131 @@ CRITICAL: When you need to communicate with another agent:
             
             return f"❌ Communication error: {error_msg}"
     
+    async def stream_message(
+        self,
+        agent_url: str,
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        authorized_amount: float = None,
+        timeout: float = None
+    ):
+        """Stream response from remote agent via NLI
+        
+        Used by AgentHandoffSkill for streaming remote agent responses.
+        
+        Args:
+            agent_url: Full URL of target agent
+            messages: Conversation messages to send
+            tools: Tools to pass to remote agent
+            authorized_amount: Maximum cost authorization in USD
+            timeout: Request timeout in seconds
+        
+        Yields:
+            OpenAI-compatible streaming chunks from remote agent
+        """
+        # Validate parameters
+        if authorized_amount is None:
+            authorized_amount = self.default_authorization
+        
+        if authorized_amount > self.max_authorization:
+            raise ValueError(f"Authorized amount ${authorized_amount:.2f} exceeds maximum ${self.max_authorization:.2f}")
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        if not HTTPX_AVAILABLE:
+            raise ValueError("HTTP client not available - install httpx")
+        
+        # Prepare streaming request payload
+        payload = {
+            "model": self.agent.name if self.agent else "unknown",
+            "messages": messages,
+            "stream": True,
+            "temperature": 0.7,
+            "max_tokens": 4096
+        }
+        
+        if tools:
+            payload["tools"] = tools
+        
+        # Prepare headers
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": f"WebAgents-NLI/{self.agent.name if self.agent else 'unknown'}",
+            "X-Authorization-Amount": str(authorized_amount),
+            "X-Origin-Agent": self.agent.name if self.agent else "unknown",
+        }
+        
+        # Include Authorization if available
+        bearer = os.getenv('WEBAGENTS_API_KEY') or os.getenv('SERVICE_TOKEN')
+        if bearer:
+            headers["Authorization"] = f"Bearer {bearer}"
+            headers["X-API-Key"] = bearer
+        
+        # Forward payment token if available
+        try:
+            from webagents.server.context.context_vars import get_context as _gc
+            ctx = _gc()
+            payment_token = None
+            
+            if ctx and hasattr(ctx, 'payment_token') and ctx.payment_token:
+                payment_token = ctx.payment_token
+            elif ctx and hasattr(ctx, 'request') and ctx.request:
+                request_headers = getattr(ctx.request, 'headers', {})
+                if hasattr(request_headers, 'get'):
+                    payment_token = (
+                        request_headers.get('X-Payment-Token') or 
+                        request_headers.get('x-payment-token')
+                    )
+            
+            if payment_token:
+                headers["X-Payment-Token"] = payment_token
+                self.logger.info(f"🔐 Forwarding payment token for streaming handoff")
+        except Exception:
+            pass
+        
+        # Stream from remote agent
+        self.logger.info(f"🌊 Starting streaming handoff to: {agent_url}")
+        
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                async with client.stream(
+                    "POST",
+                    f"{agent_url}/chat/completions",
+                    json=payload,
+                    headers=headers
+                ) as response:
+                    response.raise_for_status()
+                    
+                    # Parse SSE stream
+                    async for line in response.aiter_lines():
+                        if not line or line.startswith(':'):
+                            continue
+                        
+                        if line.startswith('data: '):
+                            data = line[6:]  # Remove 'data: ' prefix
+                            
+                            if data == '[DONE]':
+                                self.logger.debug("🌊 Stream completed: [DONE]")
+                                break
+                            
+                            try:
+                                chunk = json.loads(data)
+                                yield chunk
+                            except json.JSONDecodeError as e:
+                                self.logger.warning(f"Invalid JSON chunk: {data[:100]}")
+                                continue
+        
+        except httpx.HTTPStatusError as e:
+            self.logger.error(f"Remote agent HTTP error: {e.response.status_code}")
+            raise
+        except httpx.TimeoutException:
+            self.logger.error(f"Remote agent timeout after {timeout}s")
+            raise
+        except Exception as e:
+            self.logger.error(f"Remote agent streaming error: {e}")
+            raise
+    
     # @tool(description="List known agent endpoints and their statistics", scope="owner")
     async def list_known_agents(self, context=None) -> str:
         """

webagents/agents/skills/robutler/payments/exceptions.py

@@ -103,12 +103,13 @@ class PaymentTokenInvalidError(PaymentError):
 
 
 class InsufficientBalanceError(PaymentError):
-    """Raised when payment token balance is insufficient"""
+    """Raised when payment token or account balance is insufficient"""
     
     def __init__(self, 
                  current_balance: float,
                  required_balance: float,
-                 token_prefix: Optional[str] = None):
+                 token_prefix: Optional[str] = None,
+                 is_token_balance: bool = True):
         context = {
             'current_balance': current_balance,
             'required_balance': required_balance,
@@ -116,12 +117,21 @@ class InsufficientBalanceError(PaymentError):
         }
         if token_prefix:
             context['token_prefix'] = token_prefix
+        
+        # Distinguish between token balance (can retry with new token) 
+        # and account balance (user needs to add credits)
+        if is_token_balance:
+            error_code = "INSUFFICIENT_TOKEN_BALANCE"
+            user_message = f"Payment token has insufficient balance (${current_balance:.2f} < ${required_balance:.2f}). Requesting fresh token..."
+        else:
+            error_code = "INSUFFICIENT_ACCOUNT_BALANCE"
+            user_message = f"Your account has insufficient credits. You need ${required_balance:.2f} but only have ${current_balance:.2f}. Please add more credits."
             
         super().__init__(
             message=f"Insufficient balance: ${current_balance:.2f} < ${required_balance:.2f} required",
-            error_code="INSUFFICIENT_BALANCE",
+            error_code=error_code,
             context=context,
-            user_message=f"Insufficient credits. You have ${current_balance:.2f} but need ${required_balance:.2f}. Please add more credits to your account."
+            user_message=user_message
         )
 
 
@@ -213,12 +223,22 @@ def create_token_invalid_error(token_prefix: Optional[str] = None,
 
 def create_insufficient_balance_error(current_balance: float,
                                     required_balance: float,
-                                    token_prefix: Optional[str] = None) -> InsufficientBalanceError:
-    """Create an insufficient balance error"""
+                                    token_prefix: Optional[str] = None,
+                                    is_token_balance: bool = True) -> InsufficientBalanceError:
+    """Create an insufficient balance error
+    
+    Args:
+        current_balance: Current balance available
+        required_balance: Minimum balance required
+        token_prefix: Optional token identifier prefix
+        is_token_balance: True if checking token balance (can retry with fresh token),
+                         False if checking account balance (user needs to add credits)
+    """
     return InsufficientBalanceError(
         current_balance=current_balance,
         required_balance=required_balance,
-        token_prefix=token_prefix
+        token_prefix=token_prefix,
+        is_token_balance=is_token_balance
     )
 
 

webagents/agents/skills/robutler/payments/skill.py

@@ -253,7 +253,7 @@ class PaymentSkill(Skill):
     # ===== CONNECTION LIFECYCLE HOOKS =====
     @prompt(priority=20, scope="all")
     def payments_general_prompt(self, context: Any = None) -> str:
-        return "You are part of a network of AI agents working for their owners. You pay each other for services and help the owners make money."
+        return "Agent network: Pay each other for services, help owners earn."
 
     
     @hook("on_connection", priority=10)
@@ -419,6 +419,10 @@ class PaymentSkill(Skill):
             usage_records = getattr(context, 'usage', []) or []
             llm_cost_usd = 0.0
             tool_cost_usd = 0.0
+            
+            # Track detailed breakdown for logging
+            llm_breakdown = []
+            tool_breakdown = []
 
             for record in usage_records:
                 if not isinstance(record, dict):
@@ -428,6 +432,7 @@ class PaymentSkill(Skill):
                     model = record.get('model')
                     prompt_tokens = int(record.get('prompt_tokens') or 0)
                     completion_tokens = int(record.get('completion_tokens') or 0)
+                    self.logger.info(f"💰 PAYMENT: Processing LLM usage - model={model}, tokens={prompt_tokens}+{completion_tokens}")
                     try:
                         if LITELLM_AVAILABLE and cost_per_token and model:
                             p_cost, c_cost = cost_per_token(
@@ -435,23 +440,44 @@ class PaymentSkill(Skill):
                                 prompt_tokens=prompt_tokens,
                                 completion_tokens=completion_tokens
                             )
-                            llm_cost_usd += float((p_cost or 0.0) + (c_cost or 0.0))
+                            record_cost = float((p_cost or 0.0) + (c_cost or 0.0))
+                            llm_cost_usd += record_cost
+                            self.logger.info(f"💰 PAYMENT: Calculated cost ${record_cost:.6f} for {model}")
+                            llm_breakdown.append({
+                                'model': model,
+                                'prompt_tokens': prompt_tokens,
+                                'completion_tokens': completion_tokens,
+                                'cost_usd': record_cost
+                            })
                     except Exception as e:
-                        self.logger.debug(f"LLM cost_per_token failed for model {model}: {e}")
+                        self.logger.warning(f"💰 PAYMENT: cost_per_token failed for model {model}: {e}")
                         continue
                 elif record_type == 'tool':
                     pricing = record.get('pricing') or {}
                     credits = pricing.get('credits')
                     if credits is not None:
                         try:
-                            tool_cost_usd += float(credits)
+                            record_cost = float(credits)
+                            tool_cost_usd += record_cost
+                            tool_breakdown.append({
+                                'tool_name': record.get('tool_name', 'unknown'),
+                                'reason': pricing.get('reason', 'Tool usage'),
+                                'credits': record_cost,
+                                'metadata': pricing.get('metadata', {})
+                            })
                         except Exception:
                             continue
 
             # Calculate total to charge using external calculator if provided, else default formula
-            if callable(self.amount_calculator):
+            # Compute default totals
+            subtotal = (llm_cost_usd + tool_cost_usd)
+            default_total = subtotal * (1.0 + (self.agent_pricing_percent / 100.0))
+            
+            # Track if using custom calculator (revenue-sharing model)
+            using_custom_calculator = callable(self.amount_calculator)
+            
+            if using_custom_calculator:
                 try:
-                    # Log inputs and client auth fingerprint used for downstream calls
                     self.logger.debug(
                         f"🧮 Amount calculator input | llm_cost_usd={llm_cost_usd:.6f} "
                         f"tool_cost_usd={tool_cost_usd:.6f} agent_pricing_percent={self.agent_pricing_percent:.2f}% "
@@ -459,20 +485,41 @@ class PaymentSkill(Skill):
                         f"client_key_fp={getattr(self.client, '_api_key_fingerprint', 'na')}"
                     )
                     result = self.amount_calculator(llm_cost_usd, tool_cost_usd, self.agent_pricing_percent)
-                    if inspect.isawaitable(result):
-                        to_charge = float(await result)
-                    else:
-                        to_charge = float(result)
-                    self.logger.debug(f"🧮 Amount calculator output | to_charge={to_charge:.6f}")
+                    to_charge = float(await result) if inspect.isawaitable(result) else float(result)
                 except Exception as e:
-                    self.logger.error(f"Amount calculator failed: {e}; falling back to default formula")
-                    to_charge = (llm_cost_usd + tool_cost_usd) * (1.0 + (self.agent_pricing_percent / 100.0))
+                    self.logger.error(f"Amount calculator failed: {e}; using default total")
+                    to_charge = default_total
+                    using_custom_calculator = False
             else:
-                to_charge = (llm_cost_usd + tool_cost_usd) * (1.0 + (self.agent_pricing_percent / 100.0))
+                to_charge = default_total
 
             if to_charge <= 0:
                 return context
 
+            # Log detailed charge breakdown
+            self.logger.info(f"💰 Payment Breakdown for Agent '{getattr(self.agent, 'name', 'unknown')}':")
+            self.logger.info(f"   📊 LLM Costs: ${llm_cost_usd:.6f}")
+            for llm_record in llm_breakdown:
+                self.logger.info(f"      - {llm_record['model']}: {llm_record['prompt_tokens']}+{llm_record['completion_tokens']} tokens = ${llm_record['cost_usd']:.6f}")
+            
+            self.logger.info(f"   🛠️  Tool Costs: ${tool_cost_usd:.6f}")
+            for tool_record in tool_breakdown:
+                self.logger.info(f"      - {tool_record['tool_name']}: ${tool_record['credits']:.6f} ({tool_record['reason']})")
+            
+            # Display depends on pricing model
+            if using_custom_calculator:
+                # Revenue-sharing model: platform charges user, agent gets a share
+                import os
+                platform_markup = float(os.getenv('ROBUTLER_PLATFORM_MARKUP', '1.75'))
+                platform_charge = subtotal * platform_markup
+                self.logger.info(f"   🏦 Platform Charge to User: ${platform_charge:.6f} (base=${subtotal:.6f} × {platform_markup:.2f})")
+                self.logger.info(f"   💰 Agent Revenue Share: {self.agent_pricing_percent:.2f}% of ${platform_charge:.6f} = ${to_charge:.6f}")
+            else:
+                # Simple markup model
+                markup_dollars = to_charge - subtotal
+                self.logger.info(f"   📈 Agent Markup: {self.agent_pricing_percent:.2f}% (${markup_dollars:.6f})")
+                self.logger.info(f"   💵 Total Charge: ${to_charge:.6f} (subtotal=${subtotal:.6f} + markup=${markup_dollars:.6f})")
+
             # Charge payment token directly
             if payment_context.payment_token:
                 success = await self._charge_payment_token(
@@ -481,10 +528,13 @@ class PaymentSkill(Skill):
                     f"Agent {getattr(self.agent, 'name', 'unknown')} usage (margin {self.agent_pricing_percent:.2f}%)"
                 )
                 if success:
+                    # Mark payment as successful for downstream finalize hooks (e.g., cashback)
+                    setattr(payment_context, 'payment_successful', True)
                     self.logger.info(
                         f"💳 Payment finalized: ${to_charge:.6f} charged to token {payment_context.payment_token[:20]}..."
                     )
                 else:
+                    setattr(payment_context, 'payment_successful', False)
                     self.logger.error(
                         f"💳 Payment failed: ${to_charge:.6f} could not charge token {payment_context.payment_token[:20]}..."
                     )

webagents/agents/skills/robutler/storage/files/skill.py

@@ -267,9 +267,9 @@ class RobutlerFilesSkill(Skill):
                 "error": f"Failed to store file from base64: {str(e)}"
             })
 
-    @tool
+    @tool(description="Get public URLs of YOUR reference content. **WHEN TO USE**: Anytime you need to reference YOUR content/images/files in requests to other agents, you MUST call this tool FIRST to get actual URLs. DO NOT describe or invent file names - get real URLs. **USE CASES**: 1) Getting reference image URLs before image generation, 2) Finding style reference URLs, 3) Listing 'my content'/'my files'/'my public content'. **RETURNS**: Full public URLs (e.g., https://robutler.ai/api/content/public/abc123/image.png) that you pass to other agents. **IMPORTANT**: These URLs are for INTERNAL use (passing to other agents) - do NOT show raw URLs to users unless specifically asked or necessary for context.")
     @pricing(credits_per_call=0.005)
-    async def list_files(
+    async def get_my_public_content_urls(
         self,
         scope: Optional[str] = None
     ) -> str: