django-agent-studio 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

django_agent_studio/agents/dynamic.py

@@ -626,8 +626,13 @@ class DynamicAgentRuntime(AgentRuntime):
             return ""
     
     def _build_tool_schemas(self, config: dict) -> list:
-        """Build OpenAI-format tool schemas from config."""
+        """Build OpenAI-format tool schemas from config.
+
+        Includes both regular tools and sub-agent tools.
+        """
         schemas = []
+
+        # Add regular tools
         for tool in config.get("tools", []):
             # Skip the _meta field when building schema
             schema = {
@@ -635,22 +640,68 @@ class DynamicAgentRuntime(AgentRuntime):
                 "function": tool.get("function", {}),
             }
             schemas.append(schema)
+
+        # Add sub-agent tools in OpenAI format
+        for sub_tool in config.get("sub_agent_tools", []):
+            schema = {
+                "type": "function",
+                "function": {
+                    "name": sub_tool.get("name"),
+                    "description": sub_tool.get("description", ""),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "message": {
+                                "type": "string",
+                                "description": f"The message or task to send to the {sub_tool.get('name')} agent",
+                            },
+                            "context": {
+                                "type": "string",
+                                "description": "Optional additional context to include",
+                            },
+                        },
+                        "required": ["message"],
+                    },
+                },
+            }
+            schemas.append(schema)
+            logger.debug(f"Added sub-agent tool schema: {sub_tool.get('name')}")
+
         return schemas
 
     def _build_tool_map(self, config: dict) -> dict:
-        """Build a map of tool name to execution info."""
+        """Build a map of tool name to execution info.
+
+        Includes both regular tools and sub-agent tools.
+        """
         tool_map = {}
+
+        # Add regular tools
         for tool in config.get("tools", []):
             func_info = tool.get("function", {})
             tool_name = func_info.get("name")
             if tool_name:
                 # Get execution metadata from _meta field
                 meta = tool.get("_meta", {})
+                # Check both function_path (DynamicTool) and builtin_ref (AgentTool)
                 tool_map[tool_name] = {
-                    "function_path": meta.get("function_path"),
+                    "function_path": meta.get("function_path") or meta.get("builtin_ref"),
                     "tool_id": meta.get("tool_id"),
                     "is_dynamic": meta.get("is_dynamic", False),
+                    "is_sub_agent": False,
                 }
+
+        # Add sub-agent tools
+        for sub_tool in config.get("sub_agent_tools", []):
+            tool_name = sub_tool.get("name")
+            if tool_name:
+                tool_map[tool_name] = {
+                    "is_sub_agent": True,
+                    "agent_slug": sub_tool.get("agent_slug"),
+                    "context_mode": sub_tool.get("context_mode", "message_only"),
+                }
+                logger.debug(f"Added sub-agent tool to map: {tool_name} -> {sub_tool.get('agent_slug')}")
+
         return tool_map
 
     async def _execute_tool(
@@ -661,8 +712,22 @@ class DynamicAgentRuntime(AgentRuntime):
         executor: "DynamicToolExecutor",
         ctx: RunContext,
     ) -> str:
-        """Execute a tool and return its result."""
+        """Execute a tool and return its result.
+
+        Handles both regular tools and sub-agent tools.
+        """
         tool_info = tool_map.get(tool_name, {})
+
+        # Check if this is a sub-agent tool
+        if tool_info.get("is_sub_agent"):
+            return await self._execute_sub_agent_tool(
+                tool_name=tool_name,
+                tool_args=tool_args,
+                tool_info=tool_info,
+                ctx=ctx,
+            )
+
+        # Regular tool execution
         function_path = tool_info.get("function_path")
 
         if not function_path:
@@ -690,3 +755,98 @@ class DynamicAgentRuntime(AgentRuntime):
             logger.exception(f"Error executing tool {tool_name}")
             return json.dumps({"error": str(e)})
 
+    async def _execute_sub_agent_tool(
+        self,
+        tool_name: str,
+        tool_args: dict,
+        tool_info: dict,
+        ctx: RunContext,
+    ) -> str:
+        """Execute a sub-agent tool by invoking the sub-agent.
+
+        Args:
+            tool_name: Name of the sub-agent tool
+            tool_args: Arguments passed to the tool (message, context)
+            tool_info: Tool metadata including agent_slug and context_mode
+            ctx: Parent agent's run context
+
+        Returns:
+            JSON string with the sub-agent's response
+        """
+        from agent_runtime_core.multi_agent import (
+            AgentTool as AgentToolCore,
+            InvocationMode,
+            ContextMode,
+            invoke_agent,
+        )
+        from django_agent_runtime.runtime.registry import get_runtime_async
+
+        sub_agent_slug = tool_info.get("agent_slug")
+        context_mode_str = tool_info.get("context_mode", "message_only")
+
+        # Map context_mode string to enum
+        context_mode_map = {
+            'message_only': ContextMode.MESSAGE_ONLY,
+            'summary': ContextMode.SUMMARY,
+            'full': ContextMode.FULL,
+        }
+        context_mode = context_mode_map.get(context_mode_str, ContextMode.MESSAGE_ONLY)
+
+        message = tool_args.get("message", "")
+        additional_context = tool_args.get("context")
+
+        if not message:
+            return json.dumps({"error": "Missing required parameter: message"})
+
+        try:
+            # Get the sub-agent's runtime
+            sub_agent_runtime = await get_runtime_async(sub_agent_slug)
+
+            # Create an AgentTool wrapper for the sub-agent
+            agent_tool = AgentToolCore(
+                agent=sub_agent_runtime,
+                name=tool_name,
+                description=f"Sub-agent: {sub_agent_slug}",
+                invocation_mode=InvocationMode.DELEGATE,
+                context_mode=context_mode,
+                metadata={
+                    'sub_agent_slug': sub_agent_slug,
+                    'parent_run_id': str(ctx.run_id) if ctx.run_id else None,
+                },
+            )
+
+            # Get conversation history from parent context
+            conversation_history = list(ctx.input_messages)
+
+            # Invoke the sub-agent
+            logger.info(f"Invoking sub-agent '{sub_agent_slug}' via tool '{tool_name}'")
+            result = await invoke_agent(
+                agent_tool=agent_tool,
+                message=message,
+                parent_ctx=ctx,
+                conversation_history=conversation_history,
+                additional_context=additional_context,
+            )
+
+            logger.info(f"Sub-agent '{sub_agent_slug}' completed for tool '{tool_name}'")
+
+            return json.dumps({
+                "response": result.response,
+                "sub_agent": result.sub_agent_key,
+                "handoff": result.handoff,
+            })
+
+        except KeyError as e:
+            logger.error(f"Sub-agent not found: {sub_agent_slug} - {e}")
+            return json.dumps({
+                "error": f"Sub-agent not found: {sub_agent_slug}",
+                "tool": tool_name,
+            })
+        except Exception as e:
+            logger.exception(f"Error invoking sub-agent '{sub_agent_slug}'")
+            return json.dumps({
+                "error": str(e),
+                "tool": tool_name,
+                "sub_agent": sub_agent_slug,
+            })
+

django_agent_studio/api/serializers.py

@@ -503,8 +503,8 @@ class AgentSystemVersionSerializer(serializers.ModelSerializer):
 class AgentSystemListSerializer(serializers.ModelSerializer):
     """Serializer for listing AgentSystems."""
 
-    entry_agent_name = serializers.CharField(source='entry_agent.name', read_only=True)
-    entry_agent_slug = serializers.CharField(source='entry_agent.slug', read_only=True)
+    entry_agent = serializers.SerializerMethodField()
+    members = AgentSystemMemberSerializer(many=True, read_only=True)
     member_count = serializers.SerializerMethodField()
     active_version = serializers.SerializerMethodField()
 
@@ -516,8 +516,7 @@ class AgentSystemListSerializer(serializers.ModelSerializer):
             "name",
             "description",
             "entry_agent",
-            "entry_agent_name",
-            "entry_agent_slug",
+            "members",
             "is_active",
             "member_count",
             "active_version",
@@ -526,6 +525,16 @@ class AgentSystemListSerializer(serializers.ModelSerializer):
         ]
         read_only_fields = ["id", "created_at", "updated_at"]
 
+    def get_entry_agent(self, obj):
+        if obj.entry_agent:
+            return {
+                "id": str(obj.entry_agent.id),
+                "name": obj.entry_agent.name,
+                "slug": obj.entry_agent.slug,
+                "icon": obj.entry_agent.icon,
+            }
+        return None
+
     def get_member_count(self, obj):
         return obj.members.count()
 
@@ -539,8 +548,6 @@ class AgentSystemListSerializer(serializers.ModelSerializer):
 class AgentSystemDetailSerializer(serializers.ModelSerializer):
     """Serializer for AgentSystem detail view."""
 
-    entry_agent_name = serializers.CharField(source='entry_agent.name', read_only=True)
-    entry_agent_slug = serializers.CharField(source='entry_agent.slug', read_only=True)
     members = AgentSystemMemberSerializer(many=True, read_only=True)
     versions = AgentSystemVersionSerializer(many=True, read_only=True)
     dependency_graph = serializers.SerializerMethodField()
@@ -553,8 +560,6 @@ class AgentSystemDetailSerializer(serializers.ModelSerializer):
             "name",
             "description",
             "entry_agent",
-            "entry_agent_name",
-            "entry_agent_slug",
             "is_active",
             "members",
             "versions",
@@ -567,6 +572,20 @@ class AgentSystemDetailSerializer(serializers.ModelSerializer):
     def get_dependency_graph(self, obj):
         return obj.get_dependency_graph()
 
+    def to_representation(self, instance):
+        """Return entry_agent as an object for reading."""
+        data = super().to_representation(instance)
+        if instance.entry_agent:
+            data['entry_agent'] = {
+                "id": str(instance.entry_agent.id),
+                "name": instance.entry_agent.name,
+                "slug": instance.entry_agent.slug,
+                "icon": instance.entry_agent.icon,
+            }
+        else:
+            data['entry_agent'] = None
+        return data
+
 
 class AgentSystemCreateSerializer(serializers.Serializer):
     """Serializer for creating an AgentSystem."""

django_agent_studio/branding.py

@@ -0,0 +1,103 @@
+"""
+Branding configuration for Django Agent Studio.
+
+This module provides customizable branding settings that can be overridden
+in Django settings via the AGENT_STUDIO_BRANDING dictionary.
+
+Example settings.py configuration:
+
+    AGENT_STUDIO_BRANDING = {
+        'app_name': 'My Agent Studio',
+        'logo_svg': '<svg>...</svg>',  # Custom logo SVG
+        'colors': {
+            'primary': '#00142E',
+            'accent': '#4fc4f7',
+            'secondary': '#253547',
+        },
+    }
+"""
+
+from django.conf import settings
+
+
+# Default branding configuration
+DEFAULT_BRANDING = {
+    # Application name
+    'app_name': 'Agent Studio',
+    
+    # Logo - SVG markup (displayed in header)
+    # Default is a simple "AS" text logo
+    'logo_svg': '''
+        <svg viewBox="0 0 80 32" fill="none" xmlns="http://www.w3.org/2000/svg" class="h-7">
+            <text x="0" y="24" fill="currentColor" font-family="system-ui, -apple-system, sans-serif" font-size="24" font-weight="700">AS</text>
+        </svg>
+    ''',
+    
+    # Whether to show app name next to logo
+    'show_app_name': True,
+    
+    # Colors - these are the defaults (professional blue/cyan theme)
+    'colors': {
+        # Primary color - used for header, primary buttons, main text
+        'primary': '#00142E',
+        'primary_light': '#0a2540',
+        'primary_dark': '#000d1f',
+        
+        # Accent color - used for highlights, focus rings, CTAs
+        'accent': '#4fc4f7',
+        'accent_light': '#7dd3fc',
+        'accent_dark': '#3db8eb',
+        
+        # Secondary color - used for secondary backgrounds, gradients
+        'secondary': '#253547',
+        'secondary_light': '#334155',
+        'secondary_dark': '#1e293b',
+    },
+    
+    # Chat widget primary color (used by agent-frontend)
+    'chat_primary_color': '#00142E',
+    
+    # Custom CSS to inject (optional)
+    'custom_css': '',
+}
+
+
+def get_branding():
+    """
+    Get the merged branding configuration.
+    
+    Merges user settings from AGENT_STUDIO_BRANDING with defaults.
+    """
+    user_branding = getattr(settings, 'AGENT_STUDIO_BRANDING', {})
+    
+    # Deep merge colors
+    merged = DEFAULT_BRANDING.copy()
+    
+    for key, value in user_branding.items():
+        if key == 'colors' and isinstance(value, dict):
+            # Merge colors dict
+            merged['colors'] = {**DEFAULT_BRANDING['colors'], **value}
+        else:
+            merged[key] = value
+    
+    return merged
+
+
+def branding_context_processor(request):
+    """
+    Django context processor that adds branding to all templates.
+    
+    Add to settings.py TEMPLATES['OPTIONS']['context_processors']:
+        'django_agent_studio.branding.branding_context_processor',
+    """
+    branding = get_branding()
+    
+    return {
+        'studio_branding': branding,
+        'studio_app_name': branding['app_name'],
+        'studio_logo_svg': branding['logo_svg'],
+        'studio_show_app_name': branding['show_app_name'],
+        'studio_colors': branding['colors'],
+        'studio_chat_primary_color': branding['chat_primary_color'],
+        'studio_custom_css': branding['custom_css'],
+    }

django_agent_studio/static/agent-frontend/chat-widget.css

@@ -89,6 +89,7 @@
 
 /* Widget container */
 .cw-widget {
+  position: relative;
   width: 380px;
   height: 500px;
   background: var(--cw-bg);
@@ -1272,6 +1273,57 @@
   margin-top: 2px;
 }
 
+/* Thinking Toggle */
+.cw-model-selector {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.cw-model-selector > .cw-model-btn {
+  flex: 1;
+}
+
+.cw-thinking-toggle {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border: 1px solid var(--cw-border);
+  border-radius: var(--cw-radius-sm);
+  background: var(--cw-bg);
+  cursor: pointer;
+  transition: all 0.2s ease;
+  flex-shrink: 0;
+}
+
+.cw-thinking-toggle:hover {
+  border-color: var(--cw-primary);
+  background: var(--cw-bg-muted);
+}
+
+.cw-thinking-toggle.cw-thinking-enabled {
+  background: rgba(0, 102, 204, 0.15);
+  border-color: var(--cw-primary);
+}
+
+.cw-thinking-toggle:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.cw-thinking-icon {
+  font-size: 18px;
+}
+
+.cw-thinking-badge {
+  margin-left: 4px;
+  font-size: 12px;
+  opacity: 0.7;
+}
+
 /* ============================================================================
    Tool Call Cards (Claude-style)
    ============================================================================ */