django-agent-content 0.1.2__py3-none-any.whl

agent_content/__init__.py

@@ -0,0 +1,8 @@
+"""Let AI agents edit a Django site's content through a small, permission-checked JSON API.
+
+Apps say what may be edited in an `agent_resources.py` (see registry.py); keys are managed in admin
+or with `manage.py agent_content_key`."""
+
+from .registry import Action, Inline, Relation, Resource, register, slug_defaults
+
+__all__ = ['Action', 'Inline', 'Relation', 'Resource', 'register', 'slug_defaults']

agent_content/admin.py

@@ -0,0 +1,51 @@
+from django.contrib import admin, messages
+from django.utils import timezone
+from django.utils.html import format_html
+from django.utils.module_loading import import_string
+
+from . import conf
+from .models import APIKey
+
+# a site using an admin theme (e.g. Unfold) sets AGENT_CONTENT_ADMIN_BASE to the theme's ModelAdmin
+BaseAdmin = import_string(conf.get('AGENT_CONTENT_ADMIN_BASE'))
+
+
+@admin.register(APIKey)
+class APIKeyAdmin(BaseAdmin):
+    list_display = ['label', 'user', 'key_start', 'state', 'expires_at', 'last_used_at', 'created_at']
+    list_filter = ['user']
+    search_fields = ['label', 'prefix', 'user__username']
+    actions = ['revoke_keys']
+    fields = ['user', 'label', 'expires_at']
+
+    def get_readonly_fields(self, request, obj=None):
+        # once created, only the label and expiry can change; the key itself never does
+        return ['user', 'key_start', 'state', 'created_at', 'last_used_at', 'revoked_at'] if obj else []
+
+    def get_fields(self, request, obj=None):
+        return self.fields + (['key_start', 'state', 'created_at', 'last_used_at', 'revoked_at'] if obj else [])
+
+    @admin.display(description='Key')
+    def key_start(self, key):
+        return f'{key.prefix}…'
+
+    @admin.display(description='Status')
+    def state(self, key):
+        return key.status
+
+    def save_model(self, request, obj, form, change):
+        if change:
+            return super().save_model(request, obj, form, change)
+        raw = obj.assign_new_key()
+        super().save_model(request, obj, form, change)
+        self.message_user(request, format_html(
+            'New key for {}: <code style="user-select:all">{}</code> Copy it now: it won\'t be shown again.', obj.user, raw,
+        ), messages.WARNING)
+
+    def has_delete_permission(self, request, obj=None):
+        return False  # revoke instead, so the history of which key did what stays readable
+
+    @admin.action(description='Revoke selected keys')
+    def revoke_keys(self, request, queryset):
+        count = queryset.filter(revoked_at__isnull=True).update(revoked_at=timezone.now())
+        self.message_user(request, f'Revoked {count} key(s).')

agent_content/apps.py

@@ -0,0 +1,13 @@
+from django.apps import AppConfig
+from django.utils.module_loading import autodiscover_modules
+
+
+class AgentContentConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'agent_content'
+    verbose_name = 'Agent content'
+
+    def ready(self):
+        # load every app's agent_resources.py (or the AGENT_CONTENT_MODULE name), like admin.py is loaded
+        from . import conf
+        autodiscover_modules(conf.get('AGENT_CONTENT_MODULE'))

agent_content/auth.py

@@ -0,0 +1,51 @@
+import json
+from functools import wraps
+
+from django.http import JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+
+from . import conf
+from .models import APIKey, KeyUsage
+
+
+def error(status, message, **extra):
+    return JsonResponse({'error': message, **extra}, status=status)
+
+
+def agent_view(view):
+    """Every API request: HTTPS, an API key (not a session, so no CSRF), rate and size limits, JSON body.
+    The view runs with request.user set to the key's user and request.data holding the parsed body."""
+
+    @csrf_exempt
+    @wraps(view)
+    def wrapper(request, *args, **kwargs):
+        if conf.get('AGENT_CONTENT_REQUIRE_HTTPS') and not request.is_secure():
+            return error(403, 'HTTPS is required.')
+
+        scheme, _, raw = request.headers.get('Authorization', '').partition(' ')
+        key = APIKey.find(raw.strip()) if scheme.lower() == 'bearer' and raw else None
+        if key is None:
+            response = error(401, 'A valid API key is required: Authorization: Bearer <key>.')
+            response['WWW-Authenticate'] = 'Bearer'
+            return response
+
+        if KeyUsage.hit(key) > conf.get('AGENT_CONTENT_RATE_LIMIT'):
+            return error(429, 'Too many requests. Try again in a minute.')
+        key.touch()
+
+        request.data = {}
+        if request.method in ('POST', 'PUT', 'PATCH'):
+            if len(request.body) > conf.get('AGENT_CONTENT_MAX_BODY'):
+                return error(413, 'The request body is too large.')
+            try:
+                request.data = json.loads(request.body or b'{}')
+            except ValueError:
+                return error(400, 'The request body must be JSON.')
+            if not isinstance(request.data, dict):
+                return error(400, 'The request body must be a JSON object.')
+
+        request.user = key.user
+        request.agent_key = key
+        return view(request, *args, **kwargs)
+
+    return wrapper

agent_content/conf.py

@@ -0,0 +1,23 @@
+"""Settings, each optional. Override any of them in the project's settings.py."""
+
+from django.conf import settings
+
+DEFAULTS = {
+    # the file each app uses to register what agents may edit
+    'AGENT_CONTENT_MODULE': 'agent_resources',
+    # admin base class for the API key admin, e.g. 'unfold.admin.ModelAdmin'
+    'AGENT_CONTENT_ADMIN_BASE': 'django.contrib.admin.ModelAdmin',
+    # requests per minute per key
+    'AGENT_CONTENT_RATE_LIMIT': 120,
+    # largest accepted request body, in bytes
+    'AGENT_CONTENT_MAX_BODY': 1_000_000,
+    # refuse plain http; None means "only when DEBUG is off"
+    'AGENT_CONTENT_REQUIRE_HTTPS': None,
+}
+
+
+def get(name):
+    value = getattr(settings, name, DEFAULTS[name])
+    if name == 'AGENT_CONTENT_REQUIRE_HTTPS' and value is None:
+        return not settings.DEBUG
+    return value

agent_content/management/commands/agent_content_key.py

@@ -0,0 +1,65 @@
+from datetime import timedelta
+
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+from agent_content.models import APIKey
+from agent_content.registry import resources
+
+
+class Command(BaseCommand):
+    help = ('Create an API key (printed once), or list/revoke keys. The user is created if missing, as a non-staff '
+            'account (it can\'t log into admin) with exactly the permissions the registered resources need.')
+
+    def add_arguments(self, parser):
+        parser.add_argument('--user', default='agent-bot', help='Username the key acts as (default: agent-bot).')
+        parser.add_argument('--label', default='Agent', help='Where the key is used, e.g. "Claude Code, laptop".')
+        expiry = parser.add_mutually_exclusive_group()
+        expiry.add_argument('--days', type=int, help='Expire after this many days.')
+        expiry.add_argument('--never', action='store_true', help='Never expire (the default).')
+        parser.add_argument('--no-grant', action='store_true', help='Don\'t change the user\'s permissions.')
+        parser.add_argument('--list', action='store_true', help='List keys instead of creating one.')
+        parser.add_argument('--revoke', metavar='PREFIX', help='Revoke the key starting with PREFIX, or "all" for the user\'s keys.')
+
+    def handle(self, *args, **options):
+        User = get_user_model()
+        if options['list']:
+            for key in APIKey.objects.select_related('user'):
+                self.stdout.write(f'{key.prefix}…  {key.status:8} {key.user}  {key.label}  '
+                                  f'expires {key.expires_at or "never"}  last used {key.last_used_at or "never"}')
+            return
+
+        if options['revoke']:
+            keys = APIKey.objects.filter(revoked_at__isnull=True)
+            keys = keys.filter(user__username=options['user']) if options['revoke'] == 'all' else keys.filter(prefix__startswith=options['revoke'])
+            count = keys.update(revoked_at=timezone.now())
+            self.stdout.write(self.style.SUCCESS(f'Revoked {count} key(s).'))
+            return
+
+        user, created = User.objects.get_or_create(
+            username=options['user'], defaults={'is_staff': False, 'is_active': True})
+        if created:
+            user.set_unusable_password()
+            user.save()
+        if not options['no_grant']:
+            self.grant(user)
+
+        expires = timezone.now() + timedelta(days=options['days']) if options['days'] else None
+        key, raw = APIKey.generate(user, options['label'], expires)
+        self.stdout.write(self.style.SUCCESS(f'Key for {user} ({"expires " + str(expires.date()) if expires else "never expires"}):'))
+        self.stdout.write(raw)
+        self.stdout.write('Copy it now: it is not stored and won\'t be shown again.')
+
+    def grant(self, user):
+        needed = set().union(*(r.permissions() for r in resources().values())) if resources() else set()
+        if not needed:
+            raise CommandError('No agent resources are registered (no agent_resources.py found).')
+        for perm in sorted(needed):
+            app_label, codename = perm.split('.')
+            try:
+                user.user_permissions.add(Permission.objects.get(content_type__app_label=app_label, codename=codename))
+            except Permission.DoesNotExist:
+                raise CommandError(f'Permission {perm} does not exist. Run migrate first.')
+        self.stdout.write(f'{user} can: {", ".join(sorted(needed))}')

agent_content/management/commands/agent_content_scaffold.py

@@ -0,0 +1,63 @@
+from pathlib import Path
+
+from django.apps import apps
+from django.core.management.base import BaseCommand, CommandError
+from django.db import models
+
+from agent_content import conf
+
+HEADER = '''"""What AI agents may edit in this app, through agent_content's API.
+
+Everything below starts commented out: uncomment the models and fields agents should be able to change.
+Only listed fields are exposed. Docs: the Resource options in agent_content/registry.py.
+"""
+
+from agent_content import Inline, Relation, Resource, register, slug_defaults  # noqa: F401
+
+'''
+
+
+class Command(BaseCommand):
+    help = 'Write a starter agent_resources.py for an app, listing its models and editable fields (all commented out).'
+
+    def add_arguments(self, parser):
+        parser.add_argument('app_label')
+
+    def handle(self, app_label, **options):
+        try:
+            config = apps.get_app_config(app_label)
+        except LookupError:
+            raise CommandError(f'No installed app "{app_label}".')
+        path = Path(config.path) / f'{conf.get("AGENT_CONTENT_MODULE")}.py'
+        if path.exists():
+            raise CommandError(f'{path} already exists; not overwriting it.')
+
+        blocks = [self.block(model) for model in config.get_models()]
+        imports = f'# from .models import {", ".join(m.__name__ for m in config.get_models())}\n\n' if blocks else ''
+        path.write_text(HEADER + imports + '\n\n'.join(blocks) + '\n')
+        self.stdout.write(self.style.SUCCESS(f'Wrote {path}. Review it, uncomment what agents may edit, then restart.'))
+
+    def block(self, model):
+        fields, relations = [], []
+        for field in model._meta.get_fields():
+            if not getattr(field, 'concrete', False) or field.auto_created or not field.editable:
+                continue
+            if isinstance(field, (models.FileField, models.AutoField)) or field.name in ('password', 'is_superuser', 'is_staff'):
+                continue
+            fields.append(field.name)
+            if field.many_to_one or field.many_to_many:
+                relations.append(field.name)
+        lookup = 'slug' if any(f.name == 'slug' for f in model._meta.fields) else 'pk'
+        lines = [
+            f'# register(Resource(',
+            f'#     {model.__name__},',
+            f'#     lookup={lookup!r},',
+            f'#     fields={fields!r},',
+            f'#     # read_only=[],            # readable but not writable, e.g. status or dates',
+            f'#     # create=False,            # True to allow new ones; set defaults={{...}} to force e.g. a draft status',
+        ]
+        if relations:
+            rel = ', '.join(f'{name!r}: Relation("name")' for name in relations)
+            lines.append(f'#     # relations={{{rel}}},  # refer to related objects by a field instead of id')
+        lines.append('# ))')
+        return '\n'.join(lines)

agent_content/migrations/0001_initial.py

@@ -0,0 +1,47 @@
+# Generated by Django 5.2.17 on 2026-10-14 09:06
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='APIKey',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('label', models.CharField(help_text='Where it is used, e.g. "Claude Code on my laptop".', max_length=100)),
+                ('prefix', models.CharField(editable=False, help_text='The start of the key, to recognise it.', max_length=12)),
+                ('key_hash', models.CharField(editable=False, max_length=64, unique=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('expires_at', models.DateTimeField(blank=True, help_text='Empty means it never expires.', null=True)),
+                ('last_used_at', models.DateTimeField(blank=True, editable=False, null=True)),
+                ('revoked_at', models.DateTimeField(blank=True, editable=False, null=True)),
+                ('user', models.ForeignKey(help_text='The key acts as this user, with its permissions. Use a dedicated user, e.g. "agent-bot".', on_delete=django.db.models.deletion.CASCADE, related_name='agent_keys', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'API key',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='KeyUsage',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('minute', models.DateTimeField()),
+                ('count', models.PositiveIntegerField(default=0)),
+                ('key', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='+', to='agent_content.apikey')),
+            ],
+            options={
+                'constraints': [models.UniqueConstraint(fields=('key', 'minute'), name='agent_content_usage_once_per_minute')],
+            },
+        ),
+    ]

agent_content/models.py

@@ -0,0 +1,102 @@
+import hashlib
+import secrets
+
+from django.conf import settings
+from django.db import models
+from django.db.models import F
+from django.utils import timezone
+
+PREFIX = 'ac_'
+
+
+def _hash(raw):
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+class APIKey(models.Model):
+    """A key an agent sends as `Authorization: Bearer <key>`. Only its hash is stored; the key is shown once."""
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='agent_keys',
+        help_text='The key acts as this user, with its permissions. Use a dedicated user, e.g. "agent-bot".',
+    )
+    label = models.CharField(max_length=100, help_text='Where it is used, e.g. "Claude Code on my laptop".')
+    prefix = models.CharField(max_length=12, editable=False, help_text='The start of the key, to recognise it.')
+    key_hash = models.CharField(max_length=64, unique=True, editable=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    expires_at = models.DateTimeField(null=True, blank=True, help_text='Empty means it never expires.')
+    last_used_at = models.DateTimeField(null=True, blank=True, editable=False)
+    revoked_at = models.DateTimeField(null=True, blank=True, editable=False)
+
+    class Meta:
+        verbose_name = 'API key'
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.label} ({self.prefix}…)'
+
+    def assign_new_key(self):
+        """Give this (unsaved) key its secret. Returns the raw key: it exists only here, so show it to the person now."""
+        raw = PREFIX + secrets.token_urlsafe(32)
+        self.prefix, self.key_hash = raw[:10], _hash(raw)
+        return raw
+
+    @classmethod
+    def generate(cls, user, label, expires_at=None):
+        key = cls(user=user, label=label, expires_at=expires_at)
+        raw = key.assign_new_key()
+        key.save()
+        return key, raw
+
+    @classmethod
+    def find(cls, raw):
+        """The usable key for a raw value, or None (unknown, revoked, expired, or its user is inactive)."""
+        key = cls.objects.select_related('user').filter(key_hash=_hash(raw)).first()
+        return key if key and key.is_usable else None
+
+    @property
+    def is_usable(self):
+        expired = self.expires_at is not None and self.expires_at <= timezone.now()
+        return self.revoked_at is None and not expired and self.user.is_active
+
+    @property
+    def status(self):
+        if self.revoked_at:
+            return 'revoked'
+        if self.expires_at and self.expires_at <= timezone.now():
+            return 'expired'
+        return 'active'
+
+    def revoke(self):
+        if not self.revoked_at:
+            self.revoked_at = timezone.now()
+            self.save(update_fields=['revoked_at'])
+
+    def touch(self):
+        """Record use, at most once a minute, so busy agents don't write on every request."""
+        now = timezone.now()
+        if not self.last_used_at or (now - self.last_used_at).total_seconds() > 60:
+            APIKey.objects.filter(pk=self.pk).update(last_used_at=now)
+
+
+class KeyUsage(models.Model):
+    """Requests per key per minute, for the rate limit. Old rows are removed as new minutes start."""
+
+    key = models.ForeignKey(APIKey, on_delete=models.CASCADE, related_name='+')
+    minute = models.DateTimeField()
+    count = models.PositiveIntegerField(default=0)
+
+    class Meta:
+        constraints = [models.UniqueConstraint(fields=['key', 'minute'], name='agent_content_usage_once_per_minute')]
+
+    @classmethod
+    def hit(cls, key):
+        """Count a request; returns how many this key made in the current minute."""
+        minute = timezone.now().replace(second=0, microsecond=0)
+        if not cls.objects.filter(key=key, minute=minute).update(count=F('count') + 1):
+            _, created = cls.objects.get_or_create(key=key, minute=minute, defaults={'count': 1})
+            if created:
+                cls.objects.filter(minute__lt=minute).delete()
+            else:
+                cls.objects.filter(key=key, minute=minute).update(count=F('count') + 1)
+        return cls.objects.get(key=key, minute=minute).count

agent_content/registry.py

@@ -0,0 +1,118 @@
+"""What agents may edit. Apps describe their models in `agent_resources.py`; the API is built from these descriptions.
+
+    register(Resource(Post, lookup='slug', fields=['title', 'body'], create=True, defaults={'status': 'draft'}))
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from django.utils.text import slugify
+
+
+@dataclass
+class Relation:
+    """How agents refer to a related object (a ForeignKey or ManyToMany field): by `field` instead of its id.
+    With create=True, unknown values are created; create_defaults(value) supplies the other fields (e.g. a slug)."""
+
+    field: str = 'pk'
+    create: bool = False
+    create_defaults: Callable[[str], dict] | None = None
+
+
+def slug_defaults(value):
+    """create_defaults for models with a slug next to the name."""
+    return {'slug': slugify(value)}
+
+
+@dataclass
+class Action:
+    """Something done to one object, e.g. publishing: POST <resource>/<lookup>/<name>/ with params as JSON.
+    fn(obj, data) does it and returns the object. description and params tell agents what it does and takes."""
+
+    fn: Callable
+    description: str = ''
+    params: dict[str, str] = field(default_factory=dict)   # name -> what it is, e.g. {'published_at': 'ISO date, optional'}
+
+
+@dataclass
+class Inline:
+    """Child rows edited as one list, e.g. an article's notes: GET or PUT <resource>/<lookup>/<name>/.
+    PUT replaces the whole list (rows not sent are removed), in the order given."""
+
+    model: Any
+    fk: str
+    fields: list[str]
+    order_field: str | None = None
+
+
+@dataclass
+class Resource:
+    model: Any
+    fields: list[str]                                   # what agents may write (and read)
+    name: str | None = None                             # URL name; default: the model's plural, e.g. "posts"
+    singular: str | None = None                         # one item, for tool names; default: the model's name
+    description: str = ''                               # what this content is, for agents
+    lookup: str = 'pk'                                  # field used in item URLs
+    read_only: list[str] = field(default_factory=list)  # extra fields agents may read but not write
+    computed: dict[str, Callable] = field(default_factory=dict)  # read-only values, e.g. {'url': lambda o: ...}
+    list_fields: list[str] | None = None                # fields in list results; default: lookup + first few
+    relations: dict[str, Relation] = field(default_factory=dict)
+    create: bool = False
+    defaults: dict = field(default_factory=dict)        # forced on create, e.g. {'status': 'draft'}
+    locked_fields: list[str] = field(default_factory=list)   # can't change while locked_if(obj) is true
+    locked_if: Callable | None = None
+    filters: list[str] = field(default_factory=list)    # fields allowed as ?field=value on lists
+    search: Callable | None = None                      # search(queryset, text) for ?q=
+    queryset: Callable | None = None                    # queryset() if not model.objects.all()
+    singleton: Callable | None = None                   # get() for one-object resources (e.g. a site profile)
+    actions: dict[str, Action | Callable] = field(default_factory=dict)   # POST <lookup>/<name>/
+    inlines: dict[str, Inline] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.name is None:
+            self.name = slugify(str(self.model._meta.verbose_name_plural))
+        if self.singular is None:
+            self.singular = self.name if self.singleton else slugify(str(self.model._meta.verbose_name)).replace('-', '_')
+        # a plain function is an action without params; its docstring's first line describes it
+        self.actions = {name: action if isinstance(action, Action)
+                        else Action(action, ((action.__doc__ or '').strip().splitlines() or [''])[0])
+                        for name, action in self.actions.items()}
+        if self.list_fields is None:
+            self.list_fields = list(dict.fromkeys([self.lookup] + self.fields[:2] + self.read_only[:3]))
+
+    @property
+    def label(self):
+        return f'{self.model._meta.app_label}.{self.model._meta.model_name}'
+
+    def get_queryset(self):
+        return self.queryset() if self.queryset else self.model._default_manager.all()
+
+    def permissions(self):
+        """The Django permissions a key's user needs to use this resource fully."""
+        opts = self.model._meta
+        perms = {f'{opts.app_label}.view_{opts.model_name}', f'{opts.app_label}.change_{opts.model_name}'}
+        if self.create:
+            perms.add(f'{opts.app_label}.add_{opts.model_name}')
+        for name, relation in self.relations.items():
+            related = self.model._meta.get_field(name).related_model._meta
+            perms.add(f'{related.app_label}.view_{related.model_name}')
+            if relation.create:
+                perms.add(f'{related.app_label}.add_{related.model_name}')
+        for inline in self.inlines.values():
+            child = inline.model._meta
+            perms |= {f'{child.app_label}.{action}_{child.model_name}' for action in ('view', 'add', 'change', 'delete')}
+        return perms
+
+
+_registry: dict[str, Resource] = {}
+
+
+def register(resource: Resource) -> Resource:
+    if resource.name in _registry:
+        raise ValueError(f'An agent resource named "{resource.name}" is already registered.')
+    _registry[resource.name] = resource
+    return resource
+
+
+def resources() -> dict[str, Resource]:
+    return _registry

agent_content/urls.py

@@ -0,0 +1,12 @@
+from django.urls import path
+
+from . import views
+
+app_name = 'agent_content'
+
+urlpatterns = [
+    path('', views.index, name='index'),
+    path('<slug:name>/', views.collection, name='collection'),
+    path('<slug:name>/<str:lookup>/', views.item, name='item'),
+    path('<slug:name>/<str:lookup>/<slug:sub>/', views.member, name='member'),
+]

agent_content/views.py

@@ -0,0 +1,365 @@
+"""The API, built from the registered resources (see registry.py). JSON in, JSON out; saves go through
+ModelForms and model.save(), so validation and side effects match the admin. Nothing is ever deleted,
+except child rows replaced through an inline."""
+
+from django.contrib.admin.models import ADDITION, CHANGE, LogEntry
+from django.contrib.admin.utils import construct_change_message
+from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist, ValidationError
+from django.db import models, transaction
+from django.forms import modelform_factory
+from django.forms.models import model_to_dict
+from django.http import JsonResponse
+
+from .auth import agent_view, error
+from .registry import resources
+
+API_VERSION = 1
+LIST_LIMIT = 100
+
+
+class APIError(Exception):
+    def __init__(self, status, message, **extra):
+        super().__init__(message)
+        self.response = error(status, message, **extra)
+
+
+# reading
+
+def _value(obj, name, resource):
+    try:
+        field = obj._meta.get_field(name)
+    except FieldDoesNotExist:  # e.g. a property listed in read_only
+        field = None
+    relation = resource.relations.get(name)
+    if field is not None and field.many_to_many:
+        return [getattr(item, relation.field) if relation else item.pk for item in getattr(obj, name).all()]
+    if field is not None and field.many_to_one:
+        related = getattr(obj, name)
+        if related is None:
+            return None
+        return getattr(related, relation.field) if relation else related.pk
+    value = getattr(obj, name)
+    if isinstance(value, models.fields.files.FieldFile):
+        return value.url if value else None
+    return value
+
+
+def serialize(obj, resource, full=True):
+    """All readable fields, computed values and inline lists; or with full=False, just the list fields."""
+    if not full:
+        return {name: _value(obj, name, resource) for name in resource.list_fields}
+    names = dict.fromkeys([resource.lookup] + resource.fields + resource.read_only)
+    data = {name: _value(obj, name, resource) for name in names}
+    data.update({name: fn(obj) for name, fn in resource.computed.items()})
+    data.update({name: _inline_rows(obj, inline) for name, inline in resource.inlines.items()})
+    return data
+
+
+def _inline_rows(obj, inline):
+    rows = inline.model._default_manager.filter(**{inline.fk: obj})
+    if inline.order_field:
+        rows = rows.order_by(inline.order_field, 'pk')
+    return [{name: getattr(row, name) for name in inline.fields} for row in rows]
+
+
+KINDS = {
+    'CharField': 'string', 'SlugField': 'string', 'URLField': 'string', 'EmailField': 'string', 'TextField': 'text',
+    'BooleanField': 'boolean', 'DateTimeField': 'datetime', 'DateField': 'date', 'TimeField': 'time',
+    'DecimalField': 'number', 'FloatField': 'number', 'JSONField': 'json',
+}
+
+
+def _field_info(model, name, required, writable=True, relation=None):
+    """How an agent should fill one field: kind, label, help text, limits, choices."""
+    field = model._meta.get_field(name)
+    internal = field.get_internal_type()
+    if field.many_to_many:
+        kind = 'list'
+    elif field.many_to_one:
+        kind = 'reference'
+    else:
+        kind = KINDS.get(internal, 'integer' if 'Integer' in internal or internal == 'AutoField' else 'string')
+    info = {'kind': kind, 'label': str(field.verbose_name), 'writable': writable, 'required': required}
+    if getattr(field, 'help_text', ''):
+        info['help'] = str(field.help_text)
+    if getattr(field, 'max_length', None) and kind in ('string', 'text'):
+        info['max_length'] = field.max_length
+    if field.choices:
+        info['choices'] = [value for value, _ in field.choices]
+    if relation:
+        info['refer_by'] = relation.field
+        info['creates_missing'] = relation.create
+    return info
+
+
+def describe(resource):
+    """Everything an agent (or an MCP server generating tools) needs to use a resource."""
+    form_fields = modelform_factory(resource.model, fields=resource.fields)().fields
+    fields = {}
+    for name in dict.fromkeys(resource.fields + resource.read_only):
+        try:
+            writable = name in resource.fields
+            required = writable and name in form_fields and form_fields[name].required
+            fields[name] = _field_info(resource.model, name, required, writable, resource.relations.get(name))
+        except FieldDoesNotExist:  # e.g. a property listed in read_only
+            fields[name] = {'kind': 'string', 'writable': False, 'required': False}
+        if name in resource.locked_fields:
+            fields[name]['locked_when_published'] = True
+    inlines = {}
+    for name, inline in resource.inlines.items():
+        child = modelform_factory(inline.model, fields=inline.fields)().fields
+        inlines[name] = {'fields': {f: _field_info(inline.model, f, child[f].required) for f in inline.fields}}
+    return {
+        'name': resource.name,
+        'singular': resource.singular,
+        'model': str(resource.model._meta.verbose_name),
+        'description': resource.description,
+        'singleton': resource.singleton is not None,
+        'lookup': None if resource.singleton else resource.lookup,
+        'create': resource.create,
+        'create_defaults': {key: str(value) for key, value in resource.defaults.items()},
+        'fields': fields,
+        'computed': list(resource.computed),
+        'filters': resource.filters,
+        'search': resource.search is not None,
+        'actions': {name: {'description': action.description, 'params': action.params}
+                    for name, action in resource.actions.items()},
+        'inlines': inlines,
+    }
+
+
+# writing
+
+def _resolve_relations(resource, data):
+    """Turn names (or other refer_by values) into ids, creating missing ones where the relation allows it."""
+    out, errors = dict(data), {}
+    for name, relation in resource.relations.items():
+        if name not in data:
+            continue
+        field = resource.model._meta.get_field(name)
+        manager = field.related_model._default_manager
+
+        def find(value):
+            obj = manager.filter(**{relation.field: value}).first()
+            if obj is None and relation.create:
+                extra = relation.create_defaults(value) if relation.create_defaults else {}
+                obj = manager.create(**{relation.field: value, **extra})
+            return obj
+
+        values = data[name]
+        if field.many_to_many:
+            if not isinstance(values, list):
+                errors[name] = ['Send a list.']
+                continue
+            found = [find(value) for value in values]
+            missing = [value for value, obj in zip(values, found) if obj is None]
+            if missing:
+                errors[name] = [f'Not found: {", ".join(map(str, missing))}.']
+            out[name] = [obj.pk for obj in found if obj]
+        elif values in (None, ''):
+            out[name] = None
+        else:
+            obj = find(values)
+            if obj is None:
+                choices = ', '.join(str(v) for v in manager.values_list(relation.field, flat=True)[:30])
+                errors[name] = [f'No {field.related_model._meta.verbose_name} "{values}". Existing: {choices}.']
+            else:
+                out[name] = obj.pk
+    return out, errors
+
+
+def _current_values(instance, resource):
+    values = model_to_dict(instance, fields=resource.fields)
+    for name, value in values.items():
+        if isinstance(value, list):  # many-to-many: model_to_dict gives objects; forms want ids
+            values[name] = [getattr(item, 'pk', item) for item in value]
+    return values
+
+
+def save(request, resource, instance, data):
+    """Validate and save a create (instance=None) or a partial update. Returns the saved object."""
+    unknown = sorted(set(data) - set(resource.fields))
+    if unknown:
+        raise APIError(400, f'These fields can\'t be written: {", ".join(unknown)}. Writable: {", ".join(resource.fields)}.')
+
+    if instance is not None and resource.locked_if and resource.locked_if(instance):
+        current = _current_values(instance, resource)
+        locked = [name for name in resource.locked_fields if name in data and data[name] != current.get(name)]
+        if locked:
+            raise APIError(400, f'{", ".join(locked)} can\'t change once published (links to it would break).')
+
+    adding = instance is None
+    with transaction.atomic():
+        data, errors = _resolve_relations(resource, data)
+        if errors:
+            transaction.set_rollback(True)
+            raise APIError(400, 'Some fields are invalid.', fields=errors)
+
+        # a create validates every writable field; an update only the ones sent, so the rest stay untouched
+        target = resource.model(**resource.defaults) if adding else instance
+        fields = resource.fields if adding else [name for name in resource.fields if name in data]
+        form = modelform_factory(resource.model, fields=fields)(data=data, instance=target)
+        if not form.is_valid():
+            transaction.set_rollback(True)
+            raise APIError(400, 'Some fields are invalid.', fields={
+                name: [item['message'] for item in items] for name, items in form.errors.get_json_data().items()})
+        obj = form.save()
+        log(request, obj, ADDITION if adding else CHANGE, construct_change_message(form, None, adding))
+    return obj
+
+
+def log(request, obj, flag, message):
+    """Record the change in the admin's history for this object, under the key's user."""
+    if hasattr(LogEntry.objects, 'log_actions'):  # Django 5.1+
+        LogEntry.objects.log_actions(request.user.pk, [obj], flag, message, single_object=True)
+    else:
+        from django.contrib.contenttypes.models import ContentType
+        LogEntry.objects.log_action(request.user.pk, ContentType.objects.get_for_model(obj).pk,
+                                    obj.pk, str(obj), flag, message)
+
+
+def replace_inline(request, resource, obj, name, inline):
+    rows = request.data.get('items')
+    if not isinstance(rows, list):
+        raise APIError(400, f'Send {{"items": [...]}}, each with: {", ".join(inline.fields)}.')
+    Form = modelform_factory(inline.model, fields=inline.fields)
+    forms = [Form(data=row if isinstance(row, dict) else {}) for row in rows]
+    errors = {f'items[{i}]': {k: [e['message'] for e in v] for k, v in form.errors.get_json_data().items()}
+              for i, form in enumerate(forms) if not form.is_valid()}
+    if errors:
+        raise APIError(400, 'Some items are invalid.', fields=errors)
+    with transaction.atomic():
+        inline.model._default_manager.filter(**{inline.fk: obj}).delete()
+        for position, form in enumerate(forms):
+            row = form.save(commit=False)
+            setattr(row, inline.fk, obj)
+            if inline.order_field:
+                setattr(row, inline.order_field, position)
+            row.save()
+        log(request, obj, CHANGE, [{'changed': {'fields': [name]}}])
+
+
+# helpers
+
+def _resource(name):
+    resource = resources().get(name)
+    if resource is None:
+        raise APIError(404, f'No resource "{name}". Available: {", ".join(resources())}.')
+    return resource
+
+
+def _require(request, perm):
+    if not request.user.has_perm(perm):
+        raise APIError(403, f'This key\'s user lacks the permission "{perm}".')
+
+
+def _perm(resource, action):
+    return f'{resource.model._meta.app_label}.{action}_{resource.model._meta.model_name}'
+
+
+def _object(resource, lookup=None):
+    if resource.singleton:
+        return resource.singleton()
+    obj = resource.get_queryset().filter(**{resource.lookup: lookup}).first()
+    if obj is None:
+        raise APIError(404, f'No {resource.model._meta.verbose_name} with {resource.lookup} "{lookup}".')
+    return obj
+
+
+def handles_errors(view):
+    def wrapper(request, *args, **kwargs):
+        try:
+            return view(request, *args, **kwargs)
+        except APIError as exc:
+            return exc.response
+        except ValidationError as exc:
+            return error(400, ' '.join(exc.messages))
+        except ObjectDoesNotExist as exc:
+            return error(404, str(exc))
+    return wrapper
+
+
+def _not_allowed(*methods):
+    response = error(405, f'Use {" or ".join(methods)}.')
+    response['Allow'] = ', '.join(methods)
+    return response
+
+
+# views
+
+@agent_view
+@handles_errors
+def index(request):
+    visible = [r for r in resources().values() if request.user.has_perm(_perm(r, 'view'))]
+    return JsonResponse({'version': API_VERSION, 'resources': [describe(r) for r in visible]})
+
+
+@agent_view
+@handles_errors
+def collection(request, name):
+    resource = _resource(name)
+    if resource.singleton:
+        return _item(request, resource, None)
+    if request.method == 'GET':
+        _require(request, _perm(resource, 'view'))
+        queryset = resource.get_queryset()
+        for key in resource.filters:
+            if key in request.GET:
+                queryset = queryset.filter(**{key: request.GET[key]})
+        if (text := request.GET.get('q', '').strip()) and resource.search:
+            queryset = resource.search(queryset, text)
+        items = list(queryset[:LIST_LIMIT])
+        return JsonResponse({'results': [serialize(obj, resource, full=False) for obj in items]})
+    if request.method == 'POST':
+        if not resource.create:
+            raise APIError(405, f'New {resource.name} can\'t be created through the API.')
+        _require(request, _perm(resource, 'add'))
+        obj = save(request, resource, None, request.data)
+        return JsonResponse(serialize(obj, resource), status=201)
+    return _not_allowed('GET', 'POST')
+
+
+@agent_view
+@handles_errors
+def item(request, name, lookup):
+    return _item(request, _resource(name), lookup)
+
+
+def _item(request, resource, lookup):
+    if request.method == 'GET':
+        _require(request, _perm(resource, 'view'))
+        return JsonResponse(serialize(_object(resource, lookup), resource))
+    if request.method == 'PATCH':
+        _require(request, _perm(resource, 'change'))
+        obj = save(request, resource, _object(resource, lookup), request.data)
+        return JsonResponse(serialize(obj, resource))
+    return _not_allowed('GET', 'PATCH')
+
+
+@agent_view
+@handles_errors
+def member(request, name, lookup, sub):
+    """POST <lookup>/<action>/ runs an action; GET or PUT <lookup>/<inline>/ reads or replaces child rows."""
+    resource = _resource(name)
+    obj = _object(resource, lookup)
+    if sub in resource.actions:
+        if request.method != 'POST':
+            return _not_allowed('POST')
+        _require(request, _perm(resource, 'change'))
+        with transaction.atomic():
+            obj = resource.actions[sub].fn(obj, request.data) or obj
+            log(request, obj, CHANGE, [{'changed': {'fields': [sub]}}])
+        return JsonResponse(serialize(obj, resource))
+    if sub in resource.inlines:
+        inline = resource.inlines[sub]
+        if request.method == 'GET':
+            _require(request, _perm(resource, 'view'))
+            return JsonResponse({'items': _inline_rows(obj, inline)})
+        if request.method == 'PUT':
+            for action in ('add', 'change', 'delete'):
+                _require(request, f'{inline.model._meta.app_label}.{action}_{inline.model._meta.model_name}')
+            replace_inline(request, resource, obj, sub, inline)
+            return JsonResponse({'items': _inline_rows(obj, inline)})
+        return _not_allowed('GET', 'PUT')
+    raise APIError(404, f'No action or list "{sub}" on {resource.name}. '
+                        f'Actions: {", ".join(resource.actions) or "none"}. Lists: {", ".join(resource.inlines) or "none"}.')

django_agent_content-0.1.2.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: django-agent-content
+Version: 0.1.2
+Summary: Django app that lets AI agents and MCP clients (Claude Code, Cursor and others) edit your site's content safely: API keys, permissions, drafts, no deletes.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: django,mcp,model context protocol,ai agents,llm,claude,cms,content api,headless cms,django admin,api keys
+Author: Sushan Poudel
+Requires-Python: >=3.10
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: Django (>=4.2)
+Project-URL: Changelog, https://github.com/hexa01/django-agent-content#changelog
+Project-URL: Documentation, https://github.com/hexa01/django-agent-content#readme
+Project-URL: Homepage, https://github.com/hexa01/django-agent-content
+Project-URL: Issues, https://github.com/hexa01/django-agent-content/issues
+Project-URL: MCP server, https://github.com/hexa01/agent-content-mcp
+Description-Content-Type: text/markdown
+
+# django-agent-content
+
+**Django + MCP: let AI agents edit your site's content, safely.**
+
+Claude Code, Cursor and other MCP clients (through [agent-content-mcp](https://github.com/hexa01/agent-content-mcp)),
+or any HTTP client, can read and edit the models you choose: blog posts, pages, profiles, products. You decide which
+models and fields are editable. Agents use revocable API keys that act as a Django user, so permissions and the admin's
+change history work as usual. New content can be forced to drafts, and nothing is ever deleted.
+
+```
+AI agent ──> MCP server ──HTTPS + API key──> your Django site: /api/agent/ ──> your models (via ModelForms)
+```
+
+## Install
+
+```bash
+pip install "django-agent-content @ https://github.com/hexa01/django-agent-content/archive/refs/tags/v0.1.1.tar.gz"
+```
+
+```python
+# settings.py
+INSTALLED_APPS = [..., 'agent_content']
+
+# urls.py
+path('api/agent/', include('agent_content.urls')),
+```
+
+```bash
+python manage.py migrate
+```
+
+Requires Django 4.2+ and works with any database Django supports: it uses your project's `DATABASES`.
+
+## Say what agents may edit
+
+In each app whose content agents should edit, add `agent_resources.py` (like `admin.py`). Start from a scaffold:
+
+```bash
+python manage.py agent_content_scaffold blog     # writes blog/agent_resources.py, everything commented out
+```
+
+Then uncomment and adjust:
+
+```python
+from agent_content import Action, Relation, Resource, register, slug_defaults
+
+from .models import Post
+
+register(Resource(
+    Post,
+    lookup='slug',                                           # /api/agent/posts/<slug>/
+    fields=['title', 'slug', 'excerpt', 'body', 'category', 'tags'],   # what agents may write
+    read_only=['status', 'published_at'],                    # what they may only read
+    relations={'category': Relation('name'),                 # refer to related objects by name, not id
+               'tags': Relation('name', create=True, create_defaults=slug_defaults)},
+    create=True, defaults={'status': 'draft'},               # new posts are always drafts
+    locked_fields=['slug'], locked_if=lambda post: post.status == 'published',   # links never break
+    filters=['status'],                                      # ?status=draft
+    actions={'publish': Action(publish, 'Make the post public.',            # POST /api/agent/posts/<slug>/publish/
+                               {'published_at': 'ISO date to show, optional'})},
+))
+```
+
+Only listed fields are exposed. Saves go through a ModelForm and your model's `save()`, so validation and side
+effects match the admin.
+
+### Full example
+
+[`tests/testapp`](https://github.com/hexa01/django-agent-content/tree/main/tests/testapp) is a small working app used by the tests:
+[`models.py`](https://github.com/hexa01/django-agent-content/blob/main/tests/testapp/models.py) and its [`agent_resources.py`](https://github.com/hexa01/django-agent-content/blob/main/tests/testapp/agent_resources.py) show most
+options together: references by name, tags created when missing, drafts by default, a slug that locks once
+published, a filter, search, a `publish` action with a parameter, an inline list (an article's notes) and a
+single-object resource (site settings).
+
+### Resource options
+
+| Option | Meaning |
+|---|---|
+| `fields` | Writable (and readable) fields. |
+| `name` | URL name; default: the model's plural, e.g. `posts`. |
+| `lookup` | Field used in item URLs; default `pk`. |
+| `singular` | One item's name, used for tool names (`get_post`); default: the model's name. |
+| `description` | What this content is, shown to agents. |
+| `read_only` | Readable but not writable. |
+| `computed` | Read-only values: `{'url': lambda obj: obj.get_absolute_url()}`. |
+| `list_fields` | Fields shown in lists. |
+| `relations` | `{'field': Relation('name', create=False)}` for ForeignKey/ManyToMany fields. |
+| `create`, `defaults` | Allow creating; `defaults` are forced on create (e.g. a draft status). |
+| `locked_fields`, `locked_if` | Fields that can't change while `locked_if(obj)` is true. |
+| `filters`, `search` | `?field=value` filters; `search(queryset, text)` for `?q=`. |
+| `queryset` | `queryset()` if not `Model.objects.all()`. |
+| `singleton` | `get()` for one-object resources such as site settings: `/api/agent/<name>/`. |
+| `actions` | `{'publish': Action(fn, 'what it does', {'param': 'what it is'})}`: `POST <lookup>/<name>/`; `fn(obj, data)` returns the object. A plain function also works (its docstring describes it). |
+| `inlines` | `{'notes': Inline(Note, fk='article', fields=[...], order_field='position')}`: `GET`/`PUT <lookup>/notes/` replaces the list. |
+
+## API keys
+
+```bash
+python manage.py agent_content_key --label "Claude Code, laptop"           # never expires
+python manage.py agent_content_key --label "CI" --days 90
+python manage.py agent_content_key --list
+python manage.py agent_content_key --revoke ac_Ab12cd      # by prefix, or --revoke all --user agent-bot
+```
+
+The key is printed once; only its SHA-256 hash is stored. By default it acts as the user `agent-bot` (created if
+missing, with no password and no admin access) and is granted exactly the permissions your registered resources need.
+Keys can also be created, revoked and checked (last used, expiry) under **Admin › Agent content › API keys**.
+
+Agents send `Authorization: Bearer <key>`.
+
+## Endpoints
+
+| Request | Does |
+|---|---|
+| `GET /api/agent/` | API version and a description of every resource the key may see: each field's kind, label, help text, limits, choices and whether it's required, plus actions with their params. [agent-content-mcp](https://github.com/hexa01/agent-content-mcp) builds its tools from this. |
+| `GET <name>/` | List (`?field=value`, `?q=`). |
+| `POST <name>/` | Create (when `create=True`). |
+| `GET`, `PATCH <name>/<lookup>/` | Read, or change only the fields sent. |
+| `POST <name>/<lookup>/<action>/` | Run an action. |
+| `GET`, `PUT <name>/<lookup>/<inline>/` | Read or replace child rows. |
+
+Errors are JSON: `{"error": "...", "fields": {"slug": ["..."]}}`, written so an agent can fix its request.
+
+## Settings
+
+All optional.
+
+| Setting | Default | Meaning |
+|---|---|---|
+| `AGENT_CONTENT_MODULE` | `'agent_resources'` | File name looked up in each app. |
+| `AGENT_CONTENT_ADMIN_BASE` | `'django.contrib.admin.ModelAdmin'` | Base class for the key admin, e.g. `'unfold.admin.ModelAdmin'` for Unfold. |
+| `AGENT_CONTENT_RATE_LIMIT` | `120` | Requests per minute per key. |
+| `AGENT_CONTENT_MAX_BODY` | `1000000` | Largest request body in bytes. |
+| `AGENT_CONTENT_REQUIRE_HTTPS` | `None` | Refuse plain HTTP; `None` means "unless `DEBUG`". Behind a proxy, set Django's `SECURE_PROXY_SSL_HEADER`. |
+
+Tip: add `Disallow: /api/` to your `robots.txt`.
+
+## Security
+
+- Keys are hashed, can expire, and can be revoked at any time; keys of inactive users stop working.
+- What a key can do is its user's Django permissions. The API has no delete endpoints (inline lists replace their rows).
+- HTTPS is required outside `DEBUG`; requests are rate-limited and size-limited.
+- Every change is recorded in the admin's history under the key's user.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install "Django>=5.2"
+.venv/bin/python runtests.py            # SQLite, no project needed
+```
+
+## Changelog
+
+- **0.1.2**: package metadata for PyPI (summary, keywords, classifiers, links); README example app and wording.
+- **0.1.1**: updates change only the fields sent (unsent text is left exactly as it was); actions take a
+  description and params (`Action`); the API description adds field kinds, labels, `required`, `singular` and
+  create defaults.
+- **0.1.0**: first release.
+
+## License
+
+MIT
+

django_agent_content-0.1.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+agent_content/__init__.py,sha256=L0Oe9vkh5q3wnoIk1dkjtNmUoM8SXvFju-RGDTtrgqc,403
+agent_content/admin.py,sha256=Hh40TrOaFm7MRwhOEzTReAVRbdPipr8rwsAzClRlHoQ,2144
+agent_content/apps.py,sha256=wmietMxygacqGWutSecMYwnQilbF8nqcFP5DsiJOFNE,471
+agent_content/auth.py,sha256=BIwCsava_BL7PrkW8SCdO3PgNvfml28pksDUeONkHm4,1932
+agent_content/conf.py,sha256=17S7q4Kc-9SmxpJwwwbMzxbBV7qH1s-tfdMbYkehiSU,829
+agent_content/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_content/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_content/management/commands/agent_content_key.py,sha256=YOn_2KcdPqeCg3m-rT2ae_a6dfw-Krbsgp9L5ZVdWGY,3605
+agent_content/management/commands/agent_content_scaffold.py,sha256=Jtc1cPO8cWPV4cSWi0Iu7dggO7BJRUVjztD8SPkcG60,2856
+agent_content/migrations/0001_initial.py,sha256=RPJqJ2QyAN1ygP5wrVrLe1vJfDtZRT_Wk2KiZsxzKZY,2307
+agent_content/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_content/models.py,sha256=eCZDMa0l7blq3B45oi-cgi8tk3uCFG27BpQ5jaw4qwc,4113
+agent_content/registry.py,sha256=wadp1qzgAmmLjrxs_4DoKo3ap8AYTDWIw94dhIlYUxo,5504
+agent_content/urls.py,sha256=V048UfRmwpNEIkQQBVuokj04f4hFlyngQ81Qgfy_ob4,344
+agent_content/views.py,sha256=UYaUJhNzmzXSzE-t1pwB77ZJl7ED8o8JvYfQccwsNz8,15653
+django_agent_content-0.1.2.dist-info/METADATA,sha256=Rn3epAYvuCCfC8-seEvQ2aknQ8KPKmiNc0iIqb_qEUo,9339
+django_agent_content-0.1.2.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+django_agent_content-0.1.2.dist-info/licenses/LICENSE,sha256=HkvALIV_w9d5KzBmCM0H1y24BmWMGIaL3P-EqUHtxhI,1070
+django_agent_content-0.1.2.dist-info/RECORD,,

django_agent_content-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.5.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_agent_content-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sushan Poudel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.