django-agent-studio 0.1.4__py3-none-any.whl → 0.1.8__py3-none-any.whl

django_agent_studio/agents/dynamic.py

@@ -92,6 +92,10 @@ class DynamicAgentRuntime(AgentRuntime):
         """Execute the agent with the dynamic configuration and agentic loop."""
         config = self.config
 
+        # Check if memory is enabled (default: True)
+        extra_config = config.get("extra", {})
+        memory_enabled = extra_config.get("memory_enabled", True)
+
         # Build the messages list
         messages = []
 
@@ -108,12 +112,14 @@ class DynamicAgentRuntime(AgentRuntime):
         if rag_context:
             system_prompt = f"{system_prompt}\n\n{rag_context}"
 
-        # Add conversation memories (if we have a conversation_id and user)
-        memory_store = await self._get_memory_store(ctx)
-        if memory_store:
-            memory_context = await self._recall_memories(memory_store)
-            if memory_context:
-                system_prompt = f"{system_prompt}\n\n{memory_context}"
+        # Add conversation memories (if memory is enabled and we have context)
+        memory_store = None
+        if memory_enabled:
+            memory_store = await self._get_memory_store(ctx)
+            if memory_store:
+                memory_context = await self._recall_memories(memory_store)
+                if memory_context:
+                    system_prompt = f"{system_prompt}\n\n{memory_context}"
 
         if system_prompt:
             messages.append({"role": "system", "content": system_prompt})
@@ -121,9 +127,10 @@ class DynamicAgentRuntime(AgentRuntime):
         # Add conversation history
         messages.extend(ctx.input_messages)
 
-        # Build tool schemas - include memory tool
+        # Build tool schemas - include memory tool only if memory is enabled
         tools = self._build_tool_schemas(config)
-        tools.append(MEMORY_TOOL_SCHEMA)  # Add remember tool to all designed agents
+        if memory_enabled:
+            tools.append(MEMORY_TOOL_SCHEMA)
 
         tool_map = self._build_tool_map(config)  # Maps tool name to execution info
 

django_agent_studio/api/urls.py

@@ -242,4 +242,55 @@ urlpatterns = [
         views.AgentSystemDiscoverView.as_view(),
         name="discover_system",
     ),
+
+    # ==========================================================================
+    # Spec Document Endpoints
+    # ==========================================================================
+
+    # List and create spec documents
+    path(
+        "spec-documents/",
+        views.SpecDocumentListCreateView.as_view(),
+        name="spec_document_list",
+    ),
+    path(
+        "spec-documents/<uuid:pk>/",
+        views.SpecDocumentDetailView.as_view(),
+        name="spec_document_detail",
+    ),
+
+    # Link/unlink to agent
+    path(
+        "spec-documents/<uuid:pk>/link/",
+        views.SpecDocumentLinkView.as_view(),
+        name="spec_document_link",
+    ),
+
+    # Version history
+    path(
+        "spec-documents/<uuid:pk>/history/",
+        views.SpecDocumentHistoryView.as_view(),
+        name="spec_document_history",
+    ),
+
+    # Restore version
+    path(
+        "spec-documents/<uuid:pk>/restore/",
+        views.SpecDocumentRestoreView.as_view(),
+        name="spec_document_restore",
+    ),
+
+    # Tree view
+    path(
+        "spec-documents/tree/",
+        views.SpecDocumentTreeView.as_view(),
+        name="spec_document_tree",
+    ),
+
+    # Render as markdown
+    path(
+        "spec-documents/render/",
+        views.SpecDocumentRenderView.as_view(),
+        name="spec_document_render",
+    ),
 ]

django_agent_studio/api/views.py

@@ -1546,3 +1546,382 @@ class AgentSystemDiscoverView(APIView):
             ],
             'total_count': len(agents),
         })
+
+
+# =============================================================================
+# Spec Document Views
+# =============================================================================
+
+class SpecDocumentListCreateView(APIView):
+    """List all spec documents or create a new one."""
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request):
+        from django_agent_runtime.models import SpecDocument
+
+        root_only = request.query_params.get('root_only', 'false').lower() == 'true'
+        linked_only = request.query_params.get('linked_only', 'false').lower() == 'true'
+
+        if root_only:
+            docs = SpecDocument.objects.filter(parent__isnull=True).select_related('linked_agent').order_by('order', 'title')
+        else:
+            docs = SpecDocument.objects.all().select_related('linked_agent', 'parent').order_by('parent_id', 'order', 'title')
+
+        if linked_only:
+            docs = docs.filter(linked_agent__isnull=False)
+
+        result = []
+        for doc in docs:
+            item = {
+                'id': str(doc.id),
+                'title': doc.title,
+                'parent_id': str(doc.parent_id) if doc.parent_id else None,
+                'order': doc.order,
+                'current_version': doc.current_version,
+                'has_content': bool(doc.content),
+                'content_preview': doc.content[:100] + '...' if len(doc.content) > 100 else doc.content,
+                'created_at': doc.created_at.isoformat(),
+                'updated_at': doc.updated_at.isoformat(),
+            }
+            if doc.linked_agent:
+                item['linked_agent'] = {
+                    'id': str(doc.linked_agent.id),
+                    'slug': doc.linked_agent.slug,
+                    'name': doc.linked_agent.name,
+                }
+            result.append(item)
+
+        return Response({'documents': result, 'count': len(result)})
+
+    def post(self, request):
+        from django_agent_runtime.models import SpecDocument
+
+        title = request.data.get('title')
+        if not title:
+            return Response({'error': 'title is required'}, status=status.HTTP_400_BAD_REQUEST)
+
+        content = request.data.get('content', '')
+        parent_id = request.data.get('parent_id')
+        linked_agent_id = request.data.get('linked_agent_id')
+        order = request.data.get('order', 0)
+
+        parent = None
+        if parent_id:
+            try:
+                parent = SpecDocument.objects.get(id=parent_id)
+            except SpecDocument.DoesNotExist:
+                return Response({'error': f'Parent document not found: {parent_id}'}, status=status.HTTP_404_NOT_FOUND)
+
+        linked_agent = None
+        if linked_agent_id:
+            try:
+                linked_agent = AgentDefinition.objects.get(id=linked_agent_id)
+            except AgentDefinition.DoesNotExist:
+                return Response({'error': f'Agent not found: {linked_agent_id}'}, status=status.HTTP_404_NOT_FOUND)
+
+        doc = SpecDocument.objects.create(
+            title=title,
+            content=content,
+            parent=parent,
+            linked_agent=linked_agent,
+            order=order,
+            owner=request.user,
+        )
+
+        return Response({
+            'id': str(doc.id),
+            'title': doc.title,
+            'current_version': doc.current_version,
+            'message': f'Created spec document: {title}',
+        }, status=status.HTTP_201_CREATED)
+
+
+class SpecDocumentDetailView(APIView):
+    """Get, update, or delete a spec document."""
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.select_related('linked_agent', 'parent').get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        include_children = request.query_params.get('include_children', 'false').lower() == 'true'
+        render_markdown = request.query_params.get('render_markdown', 'false').lower() == 'true'
+
+        result = {
+            'id': str(doc.id),
+            'title': doc.title,
+            'content': doc.content,
+            'parent_id': str(doc.parent_id) if doc.parent_id else None,
+            'order': doc.order,
+            'current_version': doc.current_version,
+            'full_path': doc.get_full_path(),
+            'created_at': doc.created_at.isoformat(),
+            'updated_at': doc.updated_at.isoformat(),
+        }
+
+        if doc.linked_agent:
+            result['linked_agent'] = {
+                'id': str(doc.linked_agent.id),
+                'slug': doc.linked_agent.slug,
+                'name': doc.linked_agent.name,
+            }
+
+        if include_children:
+            descendants = doc.get_descendants()
+            result['children'] = [
+                {
+                    'id': str(d.id),
+                    'title': d.title,
+                    'parent_id': str(d.parent_id) if d.parent_id else None,
+                    'has_content': bool(d.content),
+                    'linked_agent_slug': d.linked_agent.slug if d.linked_agent else None,
+                }
+                for d in descendants
+            ]
+
+        if render_markdown:
+            result['rendered_markdown'] = doc.render_tree_as_markdown()
+
+        return Response(result)
+
+    def put(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        changes = []
+        if 'title' in request.data:
+            doc.title = request.data['title']
+            changes.append('title')
+        if 'content' in request.data:
+            doc.content = request.data['content']
+            changes.append('content')
+        if 'order' in request.data:
+            doc.order = request.data['order']
+            changes.append('order')
+        if 'parent_id' in request.data:
+            parent_id = request.data['parent_id']
+            if parent_id:
+                try:
+                    doc.parent = SpecDocument.objects.get(id=parent_id)
+                except SpecDocument.DoesNotExist:
+                    return Response({'error': f'Parent not found: {parent_id}'}, status=status.HTTP_404_NOT_FOUND)
+            else:
+                doc.parent = None
+            changes.append('parent')
+
+        if changes:
+            doc.save()
+            return Response({
+                'id': str(doc.id),
+                'title': doc.title,
+                'current_version': doc.current_version,
+                'changes': changes,
+                'message': f'Updated: {", ".join(changes)}',
+            })
+        else:
+            return Response({'message': 'No changes specified'})
+
+    def delete(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        title = doc.title
+        children_count = doc.children.count()
+        doc.delete()
+
+        return Response({
+            'message': f'Deleted document: {title}',
+            'deleted_children': children_count,
+        })
+
+
+class SpecDocumentLinkView(APIView):
+    """Link or unlink a spec document to/from an agent."""
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        agent_id = request.data.get('agent_id')
+        if not agent_id:
+            return Response({'error': 'agent_id is required'}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            agent = AgentDefinition.objects.get(id=agent_id)
+        except AgentDefinition.DoesNotExist:
+            return Response({'error': f'Agent not found: {agent_id}'}, status=status.HTTP_404_NOT_FOUND)
+
+        doc.linked_agent = agent
+        doc.save()
+
+        return Response({
+            'message': f"Linked '{doc.title}' to agent '{agent.name}'",
+            'document_id': str(doc.id),
+            'agent_id': str(agent.id),
+            'agent_slug': agent.slug,
+        })
+
+    def delete(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.select_related('linked_agent').get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        if not doc.linked_agent:
+            return Response({'message': 'Document is not linked to any agent'})
+
+        old_agent_name = doc.linked_agent.name
+        doc.linked_agent = None
+        doc.save()
+
+        return Response({
+            'message': f"Unlinked '{doc.title}' from agent '{old_agent_name}'",
+            'document_id': str(doc.id),
+        })
+
+
+class SpecDocumentHistoryView(APIView):
+    """Get version history of a spec document."""
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, pk):
+        from django_agent_runtime.models import SpecDocument
+
+        try:
+            doc = SpecDocument.objects.get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        limit = int(request.query_params.get('limit', 20))
+        versions = doc.versions.all()[:limit]
+
+        return Response({
+            'document_id': str(doc.id),
+            'document_title': doc.title,
+            'current_version': doc.current_version,
+            'versions': [
+                {
+                    'version_number': v.version_number,
+                    'title': v.title,
+                    'content_preview': v.content[:200] + '...' if len(v.content) > 200 else v.content,
+                    'created_at': v.created_at.isoformat(),
+                    'change_summary': v.change_summary or '',
+                }
+                for v in versions
+            ],
+        })
+
+
+class SpecDocumentRestoreView(APIView):
+    """Restore a spec document to a previous version."""
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request, pk):
+        from django_agent_runtime.models import SpecDocument, SpecDocumentVersion
+
+        try:
+            doc = SpecDocument.objects.get(id=pk)
+        except SpecDocument.DoesNotExist:
+            return Response({'error': 'Document not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        version_number = request.data.get('version_number')
+        if version_number is None:
+            return Response({'error': 'version_number is required'}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            version = doc.versions.get(version_number=version_number)
+        except SpecDocumentVersion.DoesNotExist:
+            return Response({'error': f'Version not found: {version_number}'}, status=status.HTTP_404_NOT_FOUND)
+
+        version.restore()
+        doc.refresh_from_db()
+
+        return Response({
+            'message': f'Restored document to version {version_number}',
+            'document_id': str(doc.id),
+            'restored_from_version': version_number,
+            'new_version': doc.current_version,
+        })
+
+
+class SpecDocumentTreeView(APIView):
+    """Get the full document tree structure."""
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request):
+        from django_agent_runtime.models import SpecDocument
+
+        def build_tree(parent_id=None):
+            if parent_id:
+                docs = SpecDocument.objects.filter(parent_id=parent_id).select_related('linked_agent').order_by('order', 'title')
+            else:
+                docs = SpecDocument.objects.filter(parent__isnull=True).select_related('linked_agent').order_by('order', 'title')
+
+            result = []
+            for doc in docs:
+                node = {
+                    'id': str(doc.id),
+                    'title': doc.title,
+                    'has_content': bool(doc.content),
+                    'order': doc.order,
+                    'linked_agent': {
+                        'id': str(doc.linked_agent.id),
+                        'slug': doc.linked_agent.slug,
+                        'name': doc.linked_agent.name,
+                    } if doc.linked_agent else None,
+                    'children': build_tree(doc.id),
+                }
+                result.append(node)
+            return result
+
+        tree = build_tree()
+        return Response({'tree': tree})
+
+
+class SpecDocumentRenderView(APIView):
+    """Render all spec documents as a single markdown document."""
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request):
+        from django_agent_runtime.models import SpecDocument
+
+        root_id = request.query_params.get('root_id')
+
+        if root_id:
+            try:
+                doc = SpecDocument.objects.get(id=root_id)
+                markdown = doc.render_tree_as_markdown()
+                return Response({
+                    'markdown': markdown,
+                    'root_document': doc.title,
+                })
+            except SpecDocument.DoesNotExist:
+                return Response({'error': f'Document not found: {root_id}'}, status=status.HTTP_404_NOT_FOUND)
+        else:
+            roots = SpecDocument.objects.filter(parent__isnull=True).order_by('order', 'title')
+            parts = [root.render_tree_as_markdown() for root in roots]
+
+            return Response({
+                'markdown': '\n\n---\n\n'.join(parts),
+                'root_count': len(parts),
+                'roots': [{'id': str(r.id), 'title': r.title} for r in roots],
+            })