django-agentic 0.3.0__py3-none-any.whl

django_agentic/__init__.py

@@ -0,0 +1,44 @@
+"""django-agentic: AI framework for Django — LangGraph + LangChain.
+
+Add 'django_agentic' to INSTALLED_APPS, run migrations, configure models in admin.
+
+Checkpointer Configuration
+--------------------------
+Chat history is stored via LangGraph checkpointers. Configure in settings:
+
+    DJANGO_AGENTIC = {
+        "CHECKPOINTER": <checkpointer_instance>,
+    }
+
+Default: InMemorySaver (works out of the box, loses history on server restart).
+
+For production with PostgreSQL:
+
+    # pip install langgraph-checkpoint-postgres
+    from langgraph.checkpoint.postgres import PostgresSaver
+    DJANGO_AGENTIC = {
+        "CHECKPOINTER": PostgresSaver.from_conn_string(
+            "postgresql://user:pass@host:5432/dbname"
+        ),
+    }
+    # Call DJANGO_AGENTIC["CHECKPOINTER"].setup() once (e.g. in a management command
+    # or AppConfig.ready()) to create the checkpoint tables.
+
+For production with Redis:
+
+    # pip install langgraph-checkpoint-redis
+    from langgraph.checkpoint.redis import RedisSaver
+    DJANGO_AGENTIC = {
+        "CHECKPOINTER": RedisSaver(redis_url="redis://localhost:6379"),
+    }
+
+For SQLite (local dev with persistence across restarts):
+
+    # pip install langgraph-checkpoint-sqlite
+    import sqlite3
+    from langgraph.checkpoint.sqlite import SqliteSaver
+    DJANGO_AGENTIC = {
+        "CHECKPOINTER": SqliteSaver(sqlite3.connect("checkpoints.db", check_same_thread=False)),
+    }
+"""
+__version__ = "0.3.0"

django_agentic/admin.py

@@ -0,0 +1,163 @@
+import json
+import datetime
+from django.contrib import admin
+from django.db.models import Sum, Count
+from django.utils import timezone
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+from .models import AIModel, AIUsageLog, SiteAIConfig, UserAIProfile
+
+
+def _daily_usage_chart(qs, title="Usage (Last 30 Days)", days=30):
+    """Generate Chart.js HTML for daily usage trends."""
+    from django.db.models.functions import TruncDate
+    cutoff = timezone.now() - datetime.timedelta(days=days)
+    daily = (
+        qs.filter(created_at__gte=cutoff)
+        .annotate(date=TruncDate("created_at"))
+        .values("date")
+        .annotate(
+            requests=Count("id"), cost=Sum("cost_usd"),
+            input_tokens=Sum("prompt_tokens"), output_tokens=Sum("completion_tokens"),
+            cache_read=Sum("cache_read_tokens"), cache_write=Sum("cache_creation_tokens"),
+        )
+        .order_by("date")
+    )
+    daily_map = {r["date"]: r for r in daily}
+    today = timezone.now().date()
+
+    dates, costs, inputs, outputs, cache_r, cache_w, reqs = [], [], [], [], [], [], []
+    for i in range(days - 1, -1, -1):
+        d = today - datetime.timedelta(days=i)
+        r = daily_map.get(d)
+        dates.append(d.strftime("%b %d"))
+        costs.append(float(r["cost"] or 0) if r else 0)
+        inputs.append(r["input_tokens"] or 0 if r else 0)
+        outputs.append(r["output_tokens"] or 0 if r else 0)
+        cache_r.append(r["cache_read"] or 0 if r else 0)
+        cache_w.append(r["cache_write"] or 0 if r else 0)
+        reqs.append(r["requests"] or 0 if r else 0)
+
+    total_cost = f"${sum(costs):.4f}"
+    total_reqs = sum(reqs)
+    total_tokens = f"{sum(inputs)+sum(outputs)+sum(cache_r)+sum(cache_w):,}"
+    cid = f"aichart_{id(qs) % 99999}"
+    data = json.dumps({"d": dates, "c": costs, "i": inputs,
+                        "o": outputs, "cr": cache_r, "cw": cache_w})
+
+    safe_title = escape(title)
+    js = (
+        '(function(){'
+        'var d=' + data + ';'
+        'var ctx=document.getElementById("' + cid + '");'
+        'if(ctx&&d.d.length>0){new Chart(ctx,{type:"line",data:{labels:d.d,datasets:['
+        '{label:"Cost ($)",data:d.c,borderColor:"rgb(75,192,192)",backgroundColor:"rgba(75,192,192,0.1)",yAxisID:"y",tension:0.3,fill:true},'
+        '{label:"Input",data:d.i,borderColor:"rgb(54,162,235)",backgroundColor:"rgba(54,162,235,0.1)",yAxisID:"y1",tension:0.3,fill:true},'
+        '{label:"Output",data:d.o,borderColor:"rgb(255,159,64)",backgroundColor:"rgba(255,159,64,0.1)",yAxisID:"y1",tension:0.3,fill:true},'
+        '{label:"Cache Read",data:d.cr,borderColor:"rgb(153,102,255)",backgroundColor:"rgba(153,102,255,0.1)",yAxisID:"y1",tension:0.3,fill:true},'
+        '{label:"Cache Write",data:d.cw,borderColor:"rgb(255,99,132)",backgroundColor:"rgba(255,99,132,0.1)",yAxisID:"y1",tension:0.3,fill:true}'
+        ']},options:{responsive:true,interaction:{mode:"index",intersect:false},'
+        'scales:{y:{type:"linear",position:"left",title:{display:true,text:"Cost ($)"},ticks:{callback:function(v){return "$"+v.toFixed(3)}}},'
+        'y1:{type:"linear",position:"right",grid:{drawOnChartArea:false},title:{display:true,text:"Tokens"},'
+        'ticks:{callback:function(v){return v>=1e6?(v/1e6).toFixed(1)+"M":v>=1e3?(v/1e3).toFixed(0)+"K":v}}}'
+        '}}})}})();'
+    )
+    return mark_safe(
+        '<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>'
+        '<div style="background:#fff;padding:20px;border:1px solid #ddd;border-radius:4px;margin:10px 0">'
+        '<h3 style="margin-top:0">' + str(safe_title) + '</h3>'
+        '<div style="display:flex;gap:40px;margin-bottom:15px">'
+        '<div><strong>Requests:</strong> ' + str(total_reqs) + '</div>'
+        '<div><strong>Cost:</strong> ' + str(total_cost) + '</div>'
+        '<div><strong>Tokens:</strong> ' + str(total_tokens) + '</div></div>'
+        '<canvas id="' + cid + '" style="max-height:300px"></canvas></div>'
+        '<script>' + js + '</script>'
+    )
+
+
+@admin.register(AIModel)
+class AIModelAdmin(admin.ModelAdmin):
+    list_display = ("display_name", "name", "model_type", "provider", "input_cost_per_1m", "output_cost_per_1m",
+                    "allowed_for_free", "allowed_for_paid", "active", "total_cost_30d")
+    list_filter = ("model_type", "provider", "active", "allowed_for_free", "allowed_for_paid")
+    list_editable = ("allowed_for_free", "allowed_for_paid", "active")
+    readonly_fields = ("usage_charts",)
+
+    def total_cost_30d(self, obj):
+        cutoff = timezone.now() - datetime.timedelta(days=30)
+        total = obj.usage_logs.filter(created_at__gte=cutoff).aggregate(total=Sum("cost_usd"))["total"]
+        return f"${total:.4f}" if total else "$0"
+    total_cost_30d.short_description = "Cost (30d)"
+
+    def usage_charts(self, obj):
+        if not obj.pk:
+            return "Save the model first to see usage charts."
+        return _daily_usage_chart(obj.usage_logs.all(), f"{obj.display_name or obj.name} — Usage")
+    usage_charts.short_description = "Usage Statistics"
+
+    def get_fieldsets(self, request, obj=None):
+        base = [(None, {"fields": ("name", "display_name", "model_type", "provider",
+                                    "input_cost_per_1m", "output_cost_per_1m",
+                                    "cache_write_cost_per_1m", "cache_read_cost_per_1m",
+                                    "active", "allowed_for_free", "allowed_for_paid",
+                                    "context_window", "max_output_tokens")})]
+        if obj and obj.pk:
+            base.append(("Usage Statistics", {"fields": ("usage_charts",)}))
+        return base
+
+
+@admin.register(SiteAIConfig)
+class SiteAIConfigAdmin(admin.ModelAdmin):
+    list_display = ("__str__", "default_free_model", "default_paid_model", "monthly_free_credits")
+    def formfield_for_foreignkey(self, db_field, request, **kwargs):
+        if db_field.name in ("default_free_model", "default_paid_model"):
+            kwargs["queryset"] = AIModel.objects.filter(active=True, model_type="chat")
+        if db_field.name == "default_free_model":
+            kwargs["queryset"] = kwargs["queryset"].filter(allowed_for_free=True)
+        return super().formfield_for_foreignkey(db_field, request, **kwargs)
+    def has_add_permission(self, request):
+        return not SiteAIConfig.objects.exists()
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+
+@admin.register(UserAIProfile)
+class UserAIProfileAdmin(admin.ModelAdmin):
+    list_display = ("user", "free_monthly_credits", "purchased_credits", "total_credits",
+                    "model_override", "credits_reset_at")
+    list_filter = ("model_override",)
+    search_fields = ("user__email", "user__username")
+    readonly_fields = ("created_at", "updated_at", "usage_charts")
+
+    def total_credits(self, obj):
+        return f"${obj.total_credits:.6f}"
+    total_credits.short_description = "Total"
+
+    def usage_charts(self, obj):
+        if not obj.pk:
+            return "Save the profile first to see usage charts."
+        return _daily_usage_chart(AIUsageLog.objects.filter(user=obj.user), f"{obj.user} — Usage")
+    usage_charts.short_description = "Usage Statistics"
+
+    def get_fieldsets(self, request, obj=None):
+        base = [(None, {"fields": ("user", "free_monthly_credits", "purchased_credits",
+                                    "model_override", "credits_reset_at", "created_at", "updated_at")})]
+        if obj and obj.pk:
+            base.append(("Usage Statistics", {"fields": ("usage_charts",)}))
+        return base
+
+
+@admin.register(AIUsageLog)
+class AIUsageLogAdmin(admin.ModelAdmin):
+    list_display = ("created_at", "workflow", "node", "model_name", "user",
+                    "prompt_tokens", "completion_tokens",
+                    "cache_read_tokens", "cache_creation_tokens",
+                    "cost_usd", "used_free_credits", "used_paid_credits",
+                    "error_type", "duration_ms", "success")
+    list_filter = ("workflow", "model_name", "success", "error_type", "created_at")
+    readonly_fields = ("id", "idempotency_key", "created_at", "request_time", "response_time",
+                       "provider_request_id",
+                       "input_cost_per_1m_at_time", "output_cost_per_1m_at_time",
+                       "cache_write_cost_per_1m_at_time", "cache_read_cost_per_1m_at_time")
+    search_fields = ("workflow", "node", "input_summary", "user__email", "provider_request_id")
+    date_hierarchy = "created_at"

django_agentic/agent.py

@@ -0,0 +1,101 @@
+"""ModelAgent — abstract base for entity-aware AI agents.
+
+Mirrors silverstripe-ai's DataObjectAgent. Consuming app subclasses this
+and implements get_static_instructions(), get_dynamic_context(), get_tools().
+django_ai handles provider, prompt caching, chat history, logging, credits, HITL.
+
+Usage:
+    from django_agentic.agent import ModelAgent
+
+    class MyModelAgent(ModelAgent):
+        def get_static_instructions(self) -> str: ...
+        def get_dynamic_context(self) -> str: ...
+        def get_tools(self) -> list: ...  # optional
+
+Register in settings:
+    DJANGO_AGENTIC = {
+        "AGENT_MAPPINGS": {
+            "myapp.MyModel": "myapp.agents.MyModelAgent",
+        }
+    }
+"""
+
+import abc
+
+from django.db.models import Model
+
+
+class ModelAgent(abc.ABC):
+
+    def __init__(self, user, model_config: "AIModel", entity: Model | None, thread_id: str):
+        self.user = user
+        self.model_config = model_config
+        self.entity = entity
+        self.thread_id = thread_id
+
+    @property
+    def is_collection_mode(self) -> bool:
+        return self.entity is None or not getattr(self.entity, "pk", None)
+
+    @abc.abstractmethod
+    def get_static_instructions(self) -> str:
+        """Cacheable system prompt. Cached by Anthropic for 5 min."""
+
+    @abc.abstractmethod
+    def get_dynamic_context(self) -> str:
+        """Ephemeral context — entity state, date. Rebuilt per request."""
+
+    def get_tools(self) -> list:
+        """LangChain tools the agent can call. Default: no tools (chat-only).
+
+        Return a list of LangChain tool instances (functions decorated with
+        @tool, or BaseTool subclasses). Tools are passed to create_agent
+        which binds them to the LLM automatically.
+        """
+        return []
+
+    def get_tools_requiring_approval(self) -> list[str]:
+        """Tool names requiring HITL approval before execution.
+
+        Return tool names (strings) that should trigger an interrupt before
+        the tool node runs. The frontend receives the pending tool calls and
+        must resume with an approval/rejection decision.
+
+        Maps to silverstripe-ai's ToolApproval middleware concept.
+        """
+        return []
+
+    def summarise_action(self, tool_name: str, tool_input: dict) -> str:
+        """Human-readable summary for a pending tool action (HITL card).
+
+        Override in subclasses for domain-specific summaries.
+        """
+        return f"Execute: {tool_name}"
+
+
+class AgentRegistry:
+    """Maps Django model → agent class via DJANGO_AGENTIC['AGENT_MAPPINGS']."""
+
+    @classmethod
+    def get_agent_class(cls, entity_class_path: str) -> type[ModelAgent]:
+        from django.conf import settings
+        from django.utils.module_loading import import_string
+        mappings = getattr(settings, "DJANGO_AGENTIC", {}).get("AGENT_MAPPINGS", {})
+        if entity_class_path in mappings:
+            return import_string(mappings[entity_class_path])
+        try:
+            entity_class = import_string(entity_class_path)
+            for parent in entity_class.__mro__:
+                if hasattr(parent, "_meta"):
+                    short = f"{parent._meta.app_label}.{parent.__name__}"
+                    if short in mappings:
+                        return import_string(mappings[short])
+        except (ImportError, AttributeError):
+            pass
+        raise ValueError(f"No agent mapping for '{entity_class_path}'.")
+
+    @classmethod
+    def create_for_entity(cls, user, model_config, entity, thread_id: str) -> ModelAgent:
+        path = f"{entity._meta.app_label}.{entity.__class__.__name__}"
+        agent_class = cls.get_agent_class(path)
+        return agent_class(user=user, model_config=model_config, entity=entity, thread_id=thread_id)

django_agentic/apps.py

@@ -0,0 +1,13 @@
+from django.apps import AppConfig
+
+
+class DjangoAIConfig(AppConfig):
+    """Django app configuration for django-agentic.
+
+    Add ``'django_agentic'`` to ``INSTALLED_APPS`` to enable AI model management,
+    credit tracking, usage logging, and agent chat endpoints.
+    """
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_agentic"
+    label = "django_ai"
+    verbose_name = "AI"

django_agentic/context.py

@@ -0,0 +1,5 @@
+"""Context vars for passing user/model through LangGraph workflows."""
+import contextvars
+
+current_ai_user = contextvars.ContextVar("current_ai_user", default=None)
+current_ai_model_name = contextvars.ContextVar("current_ai_model_name", default=None)

django_agentic/credits.py

@@ -0,0 +1,89 @@
+"""Credit system — model selection and atomic deduction."""
+import logging
+from dataclasses import dataclass
+from decimal import Decimal
+from django.db import transaction
+from .models import AIModel, SiteAIConfig, UserAIProfile
+
+logger = logging.getLogger(__name__)
+
+
+class CreditLimitExceeded(Exception):
+    def __init__(self, available: Decimal, required: Decimal):
+        self.available = available
+        self.required = required
+        super().__init__(f"Insufficient credits. Required: ${required}, Available: ${available}.")
+
+
+class AIServiceUnavailable(Exception):
+    pass
+
+
+@dataclass
+class ModelSelection:
+    model: AIModel
+    model_name: str
+    estimated_cost: Decimal
+    purchased_deduct: Decimal
+    free_deduct: Decimal
+    is_free_tier: bool
+
+
+def get_or_create_profile(user) -> UserAIProfile:
+    profile, _ = UserAIProfile.objects.get_or_create(
+        user=user, defaults={"free_monthly_credits": SiteAIConfig.load().monthly_free_credits},
+    )
+    return profile
+
+
+def resolve_model_for_user(user, input_tokens: int = 5000, output_tokens: int = 2000) -> ModelSelection:
+    config = SiteAIConfig.load()
+    profile = get_or_create_profile(user)
+    paid_model = profile.model_override or config.default_paid_model
+    free_model = config.default_free_model
+    if not paid_model:
+        raise AIServiceUnavailable("Paid AI model not configured. Contact admin.")
+    if not free_model:
+        raise AIServiceUnavailable("Free AI model not configured. Contact admin.")
+    if not free_model.allowed_for_free:
+        raise AIServiceUnavailable(f"Default free model '{free_model.display_name}' not allowed for free credits.")
+
+    paid_cost = paid_model.estimate_cost(input_tokens, output_tokens)
+    free_cost = free_model.estimate_cost(input_tokens, output_tokens)
+
+    if user.is_staff:
+        return ModelSelection(paid_model, paid_model.name, paid_cost, Decimal(0), Decimal(0), False)
+
+    if profile.purchased_credits >= paid_cost:
+        return ModelSelection(paid_model, paid_model.name, paid_cost, paid_cost, Decimal(0), False)
+
+    total = profile.purchased_credits + profile.free_monthly_credits
+    if total >= free_cost:
+        used_p = min(profile.purchased_credits, free_cost)
+        return ModelSelection(free_model, free_model.name, free_cost, used_p, free_cost - used_p, True)
+
+    raise CreditLimitExceeded(available=total, required=free_cost)
+
+
+def deduct_credits(user, cost: Decimal, model: AIModel, idempotency_key: str | None = None) -> dict:
+    if user.is_staff:
+        return {"purchased_deduct": Decimal(0), "free_deduct": Decimal(0)}
+    if idempotency_key:
+        from .models import AIUsageLog
+        if AIUsageLog.objects.filter(idempotency_key=idempotency_key).exists():
+            return {"purchased_deduct": Decimal(0), "free_deduct": Decimal(0)}
+
+    profile = get_or_create_profile(user)
+    with transaction.atomic():
+        profile = UserAIProfile.objects.select_for_update().get(pk=profile.pk)
+        can_use_free = getattr(model, "allowed_for_free", True)
+        if can_use_free:
+            used_p = min(profile.purchased_credits, cost)
+            used_f = min(profile.free_monthly_credits, cost - used_p)
+        else:
+            used_p = min(profile.purchased_credits, cost)
+            used_f = Decimal(0)
+        profile.purchased_credits = max(Decimal(0), profile.purchased_credits - used_p)
+        profile.free_monthly_credits = max(Decimal(0), profile.free_monthly_credits - used_f)
+        profile.save(update_fields=["purchased_credits", "free_monthly_credits", "updated_at"])
+    return {"purchased_deduct": used_p, "free_deduct": used_f}

django_agentic/management/__init__.py

@@ -0,0 +1 @@
+# management package

django_agentic/management/commands/__init__.py

@@ -0,0 +1 @@
+# commands package

django_agentic/management/commands/reset_free_credits.py

@@ -0,0 +1,16 @@
+"""Monthly free credit reset. Run via cron on the 1st of each month."""
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from django_agentic.models import SiteAIConfig, UserAIProfile
+
+
+class Command(BaseCommand):
+    help = "Reset free monthly AI credits for all users"
+
+    def handle(self, *args, **options):
+        config = SiteAIConfig.load()
+        amount = config.monthly_free_credits
+        updated = UserAIProfile.objects.all().update(
+            free_monthly_credits=amount, credits_reset_at=timezone.now(),
+        )
+        self.stdout.write(self.style.SUCCESS(f"Reset {updated} profiles to ${amount} free credits."))

django_agentic/migrations/0001_initial.py

@@ -0,0 +1,116 @@
+# Generated by Django 6.0.3 on 2026-04-11 22:33
+
+import django.db.models.deletion
+import uuid
+from decimal import Decimal
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AIModel',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('display_name', models.CharField(blank=True, default='', max_length=200)),
+                ('provider', models.CharField(choices=[('anthropic', 'Anthropic'), ('openai', 'OpenAI'), ('google', 'Google'), ('bedrock', 'AWS Bedrock')], default='anthropic', max_length=50)),
+                ('input_cost_per_1m', models.DecimalField(decimal_places=2, default=0, max_digits=10)),
+                ('output_cost_per_1m', models.DecimalField(decimal_places=2, default=0, max_digits=10)),
+                ('cache_write_cost_per_1m', models.DecimalField(decimal_places=6, default=0, max_digits=10)),
+                ('cache_read_cost_per_1m', models.DecimalField(decimal_places=6, default=0, max_digits=10)),
+                ('active', models.BooleanField(default=True)),
+                ('allowed_for_free', models.BooleanField(default=True)),
+                ('allowed_for_paid', models.BooleanField(default=True)),
+                ('context_window', models.IntegerField(default=200000)),
+                ('max_output_tokens', models.IntegerField(default=8192)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                'db_table': 'ailogs_aimodel',
+                'ordering': ['input_cost_per_1m'],
+            },
+        ),
+        migrations.CreateModel(
+            name='SiteAIConfig',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('monthly_free_credits', models.DecimalField(decimal_places=2, default=Decimal('2.00'), max_digits=10)),
+                ('step_model_config', models.JSONField(blank=True, default=dict)),
+                ('default_free_model', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='django_ai.aimodel')),
+                ('default_paid_model', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='django_ai.aimodel')),
+            ],
+            options={
+                'verbose_name': 'AI Configuration',
+                'verbose_name_plural': 'AI Configuration',
+                'db_table': 'ailogs_siteaiconfig',
+            },
+        ),
+        migrations.CreateModel(
+            name='UserAIProfile',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('free_monthly_credits', models.DecimalField(decimal_places=6, default=Decimal('2.000000'), max_digits=10)),
+                ('purchased_credits', models.DecimalField(decimal_places=6, default=Decimal('0.000000'), max_digits=10)),
+                ('credits_reset_at', models.DateTimeField(blank=True, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('model_override', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='django_ai.aimodel')),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='ai_profile', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'User AI Profile',
+                'db_table': 'ailogs_useraiprofile',
+            },
+        ),
+        migrations.CreateModel(
+            name='AIUsageLog',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('idempotency_key', models.CharField(blank=True, max_length=255, null=True, unique=True)),
+                ('model_name', models.CharField(db_index=True, max_length=100)),
+                ('workflow', models.CharField(db_index=True, max_length=100)),
+                ('node', models.CharField(max_length=100)),
+                ('entity_id', models.CharField(blank=True, default='', max_length=255)),
+                ('input_summary', models.TextField(blank=True, default='')),
+                ('output_json', models.JSONField(default=dict)),
+                ('prompt_tokens', models.IntegerField(blank=True, null=True)),
+                ('completion_tokens', models.IntegerField(blank=True, null=True)),
+                ('total_tokens', models.IntegerField(blank=True, null=True)),
+                ('cache_read_tokens', models.IntegerField(blank=True, null=True)),
+                ('cache_creation_tokens', models.IntegerField(blank=True, null=True)),
+                ('cost_usd', models.DecimalField(blank=True, decimal_places=6, max_digits=10, null=True)),
+                ('input_cost_per_1m_at_time', models.DecimalField(blank=True, decimal_places=2, max_digits=10, null=True)),
+                ('output_cost_per_1m_at_time', models.DecimalField(blank=True, decimal_places=2, max_digits=10, null=True)),
+                ('cache_write_cost_per_1m_at_time', models.DecimalField(blank=True, decimal_places=6, max_digits=10, null=True)),
+                ('cache_read_cost_per_1m_at_time', models.DecimalField(blank=True, decimal_places=6, max_digits=10, null=True)),
+                ('used_free_credits', models.DecimalField(decimal_places=6, default=0, max_digits=10)),
+                ('used_paid_credits', models.DecimalField(decimal_places=6, default=0, max_digits=10)),
+                ('provider_request_id', models.CharField(blank=True, default='', max_length=255)),
+                ('error_type', models.CharField(blank=True, choices=[('', 'None'), ('credit_limit', 'Credit Limit'), ('api_error', 'API Error'), ('validation', 'Validation'), ('context_overflow', 'Context Overflow'), ('unknown', 'Unknown')], default='', max_length=20)),
+                ('request_time', models.DateTimeField(blank=True, null=True)),
+                ('response_time', models.DateTimeField(blank=True, null=True)),
+                ('duration_ms', models.IntegerField(blank=True, null=True)),
+                ('success', models.BooleanField(default=True)),
+                ('error', models.TextField(blank=True, default='')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('ai_model', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='usage_logs', to='django_ai.aimodel')),
+                ('entity_type', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.contenttype')),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='ai_usage_logs', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'db_table': 'ailogs_aiusagelog',
+                'ordering': ['-created_at'],
+                'indexes': [models.Index(fields=['model_name', 'created_at'], name='ailogs_aius_model_n_434025_idx'), models.Index(fields=['workflow', 'created_at'], name='ailogs_aius_workflo_7e02c2_idx'), models.Index(fields=['user', 'created_at'], name='ailogs_aius_user_id_cd756c_idx')],
+            },
+        ),
+    ]

django_agentic/migrations/0002_add_model_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.0.3 on 2026-04-11 22:56
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_ai', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='aimodel',
+            name='model_type',
+            field=models.CharField(choices=[('chat', 'Chat / Generation'), ('embedding', 'Embedding'), ('transcription', 'Transcription'), ('image', 'Image Generation')], db_index=True, default='chat', max_length=20),
+        ),
+    ]

django_agentic/migrations/0003_remove_db_table_overrides.py

@@ -0,0 +1,44 @@
+# Generated by Django 6.0.3 on 2026-04-13 00:36
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_ai', '0002_add_model_type'),
+    ]
+
+    operations = [
+        migrations.RenameIndex(
+            model_name='aiusagelog',
+            new_name='django_ai_a_model_n_053a01_idx',
+            old_name='ailogs_aius_model_n_434025_idx',
+        ),
+        migrations.RenameIndex(
+            model_name='aiusagelog',
+            new_name='django_ai_a_workflo_9b3be0_idx',
+            old_name='ailogs_aius_workflo_7e02c2_idx',
+        ),
+        migrations.RenameIndex(
+            model_name='aiusagelog',
+            new_name='django_ai_a_user_id_6d10e0_idx',
+            old_name='ailogs_aius_user_id_cd756c_idx',
+        ),
+        migrations.AlterModelTable(
+            name='aimodel',
+            table=None,
+        ),
+        migrations.AlterModelTable(
+            name='aiusagelog',
+            table=None,
+        ),
+        migrations.AlterModelTable(
+            name='siteaiconfig',
+            table=None,
+        ),
+        migrations.AlterModelTable(
+            name='useraiprofile',
+            table=None,
+        ),
+    ]