tai-sql 0.8.0__tar.gz → 0.8.2__tar.gz

{tai_sql-0.8.0 → tai_sql-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.8.0
+Version: 0.8.2
 Summary: SQL database management and code generation tool
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE

{tai_sql-0.8.0 → tai_sql-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.8.0"
+version = "0.8.2"
 description = "SQL database management and code generation tool"
 license = "LicenseRef-Proprietary"
 license-files = ["LICENSE"]

{tai_sql-0.8.0 → tai_sql-0.8.2}/tai_sql/cli/commands/cmd_schema/schemas/chatbot.py

@@ -6,7 +6,7 @@ from .base import SchemaTemplate
 
 
 class ChatbotSchema(SchemaTemplate):
-    """Plantilla chatbot: Chat, Mensaje, TokenUsage, ToolCall, Modelo, Tarifa, Bolsa,
+    """Plantilla chatbot: Chat, Mensaje, TokenUsage, TokenUsageParte, ToolCall, Sugerencia, Modelo, Tarifa, Bolsa,
     LimitePresupuesto y vistas"""
 
     def get_content(self) -> str:
@@ -105,6 +105,7 @@ class ChatbotSchema(SchemaTemplate):
 
                 token_usage: onetomany[TokenUsage] # Relación one-to-many con la tabla TokenUsage
                 tool_calls: onetomany[ToolCall] # Relación one-to-many con la tabla ToolCall
+                sugerencias: onetomany[Sugerencia] # Lo que se sugiere preguntar tras esta respuesta
 
                 chat: manytoone[Chat] = relation(fields=['chat_id'], references=['id'], backref='messages') # Relación many-to-one con Chat
 
@@ -131,8 +132,19 @@ class ChatbotSchema(SchemaTemplate):
                 tarifa_id: col[bigint | None] = column(index=True, description='Tarifa con la que se valora')
                 bolsa_id: col[bigint | None] = column(index=True, description='Bolsa a la que se carga; vacío si no hay bolsas')
 
+                # De dónde sale y lo exacto que dio el proveedor; de qué se compone va en sus partes
+                # (token_usage_parte). Lo que se cobra sigue siendo prompt_tokens y completion_tokens:
+                # las partes los reparten, y suman lo mismo. Vacíos en los apuntes anteriores
+                origen: col[str | None] = column(index=True, description='De dónde sale: respuesta, subagente, titulo, sugerencias o resumen')
+                llamadas: col[int | None] = column(description='Cuántas llamadas al modelo hizo')
+                cache_read: col[int | None] = column(description='Tokens de la entrada leídos de la caché del proveedor, ya incluidos en prompt_tokens')
+                cache_write: col[int | None] = column(description='Tokens de la entrada escritos en la caché del proveedor, ya incluidos en prompt_tokens')
+                estimado: col[bool | None] = column(description='Si los tokens se estimaron por el texto porque el proveedor no dio el uso: entonces no tiene partes')
+                herramienta: col[str | None] = column(description='La herramienta que creó el sub-agente, si el origen es subagente')
+
                 message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='token_usage', onDelete='set null')
                 chat: manytoone[Chat] = relation(fields=['chat_id'], references=['id'], backref='token_usage', onDelete='set null')
+                partes: onetomany[TokenUsageParte] # De qué se compone: las partes de su entrada y su salida
 
 
             class ToolCall(Table):
@@ -151,6 +163,34 @@ class ChatbotSchema(SchemaTemplate):
                 message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='tool_calls') # Relación many-to-one con Mensaje
 
 
+            class TokenUsageParte(Table):
+                """Tabla con las partes de un apunte de consumo: de qué se compone su entrada y su salida"""
+                __tablename__ = "token_usage_parte"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                tipo: col[str] = column(description="'entrada' o 'salida'")
+                parte: col[str] = column(description='sistema, definiciones, contexto, contexto_herramientas, mensaje, ronda o peticion en la entrada; texto, llamadas_herramienta o razonamiento en la salida')
+                tokens: col[int] = column(description='Los tokens de esta parte: las de un tipo suman los del apunte')
+                token_usage_id: col[bigint] = column(index=True, description='El apunte del que es parte')
+
+                # `apunte` y no `token_usage`: los triggers en cascada comparan las relaciones por su
+                # nombre, sin la ruta, y con el mismo nombre que Mensaje.token_usage, crear un mensaje
+                # con sus apuntes y sus partes subía y bajaba entre apunte y parte sin fin
+                apunte: manytoone[TokenUsage] = relation(fields=['token_usage_id'], references=['id'], backref='partes', onDelete='cascade')
+
+
+            class Sugerencia(Table):
+                """Tabla con lo que se sugiere preguntar tras una respuesta del asistente"""
+                __tablename__ = "sugerencia"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                texto: col[str] = column(description='La sugerencia, escrita como la diría el usuario')
+                posicion: col[int] = column(description='Su orden entre las de la misma respuesta, desde 0')
+                message_id: col[bigint] = column(index=True, description='La respuesta tras la que se sugiere')
+
+                message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='sugerencias', onDelete='cascade')
+
+
             class Modelo(Table):
                 """Tabla que almacena los modelos con los que puede responder el agente"""
                 __tablename__ = "modelo"
@@ -183,6 +223,11 @@ class ChatbotSchema(SchemaTemplate):
                 modelo_id: col[bigint] = column(description='Modelo al que pone precio')
                 precio_input_eur_millon: col[float] = column(default=0.0, description='Euros por millón de tokens de entrada, al precio del proveedor')
                 precio_output_eur_millon: col[float] = column(default=0.0, description='Euros por millón de tokens de salida, al precio del proveedor')
+                # La entrada que sale de la caché del proveedor («cached input») y la que se escribe en ella
+                # («cache writes»: solo OpenAI y Azure desde GPT-5.6) tienen su precio. Vacío es al precio
+                # de entrada, que es lo de una tarifa sin él
+                precio_cache_input_eur_millon: col[float | None] = column(description='Cache input: euros por millón de tokens de entrada leídos de la caché, al precio del proveedor; vacío, al de entrada')
+                precio_cache_write_eur_millon: col[float | None] = column(description='Cache write: euros por millón de tokens de entrada escritos en la caché, al precio del proveedor; vacío, al de entrada')
                 margen: col[float] = column(default=1.0, description='Multiplicador comercial sobre el precio del proveedor')
                 desde: col[date] = column(description='Primer día en que rige')
                 # Una tarifa no se edita ni se borra: se da de alta la siguiente con su `desde` y la
@@ -220,22 +265,6 @@ class ChatbotSchema(SchemaTemplate):
 
             # Definición de vistas
 
-            class UserStats(View):
-                """Vista que muestra estadísticas de usuarios y sus chats"""
-                __tablename__ = "user_stats"
-                __query__ = query('user_stats.sql') # Esto es necesario para usar tai-sql push
-
-                username: col[str]
-                total_chats: col[int]
-                active_chats: col[int]
-                total_messages: col[int]
-                last_activity: col[datetime | None]
-
-                most_used_model: col[str | None]
-                most_used_model_total_tokens: col[int]
-                most_used_model_active_days: col[int]
-
-
             class ConsumoDiario(View):
                 """Vista que muestra el consumo por usuario, día y modelo"""
                 __tablename__ = "consumo_diario"
@@ -253,20 +282,6 @@ class ChatbotSchema(SchemaTemplate):
                 message_count: col[int]
 
 
-            class ChatActivity(View):
-                """Vista que muestra la actividad reciente de chats"""
-                __tablename__ = "chat_activity"
-                __query__ = query('chat_activity.sql')
-
-                chat_id: col[str]
-                chat_title: col[str]
-                username: col[str]
-                message_count: col[int]
-                last_message_timestamp: col[datetime]
-                total_tokens_consumed: col[int]
-                is_active: col[bool]
-
-
             class ConsumoMensual(View):
                 """Vista que muestra el consumo y el coste por usuario, mes y modelo"""
                 __tablename__ = "consumo_mensual"
@@ -300,6 +315,80 @@ class ChatbotSchema(SchemaTemplate):
                 total_tokens: col[int]
 
 
+            class ConsumoApunte(View):
+                """Vista que muestra cada apunte de consumo con su modelo y su coste"""
+                __tablename__ = "consumo_apunte"
+                __query__ = query('consumo_apunte.sql')
+
+                token_usage_id: col[bigint]
+                timestamp: col[datetime]
+                username: col[str]
+                message_id: col[bigint | None]
+                chat_id: col[bigint | None]
+                origen: col[str]
+                llamadas: col[int | None]
+                cache_read: col[int | None]
+                cache_write: col[int | None]
+                estimado: col[bool | None]
+                herramienta: col[str | None]
+                # Las vueltas del agente en el mensaje del que cuelga
+                rondas: col[int | None]
+                tarifa_id: col[bigint | None]
+                # Del modelo de la tarifa: vacíos si el apunte no tiene
+                modelo: col[str | None]
+                provider: col[str | None]
+                model_name: col[str | None]
+                prompt_tokens: col[int]
+                completion_tokens: col[int]
+                total_tokens: col[int]
+                # Como en consumo_mensual: por fila, con el margen y redondeado. Vacíos sin tarifa
+                coste_entrada_eur: col[float | None]
+                coste_salida_eur: col[float | None]
+                coste_eur: col[float | None]
+                # Lo que la caché ahorró frente al precio de entrada (negativo si escribir costó más), y
+                # si la tarifa tiene precio para lo leído
+                ahorro_cache_eur: col[float | None]
+                precio_cache: col[bool]
+
+
+            class ConsumoParte(View):
+                """Vista que muestra cada parte de un apunte de consumo con su coste"""
+                __tablename__ = "consumo_parte"
+                __query__ = query('consumo_parte.sql')
+
+                parte_id: col[bigint]
+                token_usage_id: col[bigint]
+                # Del apunte, para filtrar las partes igual que los apuntes
+                timestamp: col[datetime]
+                username: col[str]
+                modelo: col[str | None]
+                # 'entrada' o 'salida'
+                tipo: col[str]
+                parte: col[str]
+                tokens: col[int]
+                coste_eur: col[float | None]
+
+
+            class Valoracion(View):
+                """Vista que muestra las respuestas valoradas con un comentario"""
+                __tablename__ = "valoracion"
+                __query__ = query('valoracion.sql')
+
+                message_id: col[bigint]
+                timestamp: col[datetime]
+                content: col[str]
+                # 'good' o 'bad'
+                feedback: col[str]
+                feedback_comment: col[str]
+                total_duration_ms: col[int | None]
+                model_name: col[str | None]
+                chat_id: col[bigint]
+                chat_title: col[str | None]
+                username: col[str]
+                # Todo lo que se apuntó con la respuesta: la suya y la de sus sub-agentes
+                total_tokens: col[int | None]
+
+
             class BolsaEstado(View):
                 """Vista que muestra cuánto lleva gastado cada bolsa de consumo"""
                 __tablename__ = "bolsa_estado"
@@ -316,22 +405,6 @@ class ChatbotSchema(SchemaTemplate):
                 estado: col[str]
 
 
-            class TarifaVigente(View):
-                """Vista que muestra la tarifa que rige hoy para cada modelo, a precio de venta"""
-                __tablename__ = "tarifa_vigente"
-                __query__ = query('tarifa_vigente.sql')
-
-                tarifa_id: col[bigint]
-                modelo_id: col[bigint]
-                alias: col[str]
-                provider: col[str]
-                model_name: col[str]
-                precio_input_eur_millon: col[float]
-                precio_output_eur_millon: col[float]
-                desde: col[date]
-                hasta: col[date | None]
-
-
             class TarifaHistorico(View):
                 """Vista que muestra todas las tarifas de cada modelo, a precio de venta"""
                 __tablename__ = "tarifa_historico"
@@ -344,8 +417,12 @@ class ChatbotSchema(SchemaTemplate):
                 model_name: col[str]
                 precio_input_eur_millon: col[float]
                 precio_output_eur_millon: col[float]
+                # Vacíos si la tarifa no los tiene: lo de la caché va al precio de entrada
+                precio_cache_input_eur_millon: col[float | None]
+                precio_cache_write_eur_millon: col[float | None]
                 desde: col[date]
                 hasta: col[date | None]
+                # La que rige hoy: una por modelo como mucho
                 vigente: col[bool]
 
 
@@ -389,7 +466,11 @@ class ChatbotSchema(SchemaTemplate):
                     b.nombre,
                     b.importe_eur,
                     b.created_at,
+                    -- La entrada, a precio de entrada, más lo que cambia la caché: lo leído de ella (cache input) y lo
+                    -- escrito en ella (cache write), cada uno a su precio y, sin él, al de entrada (la diferencia es 0)
                     COALESCE(SUM(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                                       + COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                                       + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
                                        + tu.completion_tokens * t.precio_output_eur_millon)
                                        * t.margen / 1000000)::numeric, 8)), 0)::double precision as consumido_eur,
                     MIN(tu.timestamp) as primer_consumo,
@@ -417,23 +498,6 @@ class ChatbotSchema(SchemaTemplate):
             ORDER BY g.id;
         ''').rstrip()
 
-        chat_activity_sql = dedent('''\
-            -- Vista para actividad de chats
-            SELECT 
-                c.id as chat_id,
-                c.title as chat_title,
-                c.username,
-                COUNT(m.id) as message_count,
-                MAX(m.timestamp) as last_message_timestamp,
-                COALESCE(SUM(tu.total_tokens), 0) as total_tokens_consumed,
-                c.is_active
-            FROM chat c
-            LEFT JOIN mensaje m ON c.id = m.chat_id
-            LEFT JOIN token_usage tu ON m.id = tu.message_id
-            GROUP BY c.id, c.title, c.username, c.is_active
-            ORDER BY last_message_timestamp DESC NULLS LAST;
-        ''').rstrip()
-
         consumo_diario_sql = dedent('''\
             -- Vista para el consumo por usuario, día y modelo. Los tokens y el importe son todos los
             -- apuntes, tengan mensaje o no; los mensajes, los que envió el usuario
@@ -446,7 +510,11 @@ class ChatbotSchema(SchemaTemplate):
                     SUM(tu.prompt_tokens) as total_prompt_tokens,
                     SUM(tu.completion_tokens) as total_completion_tokens,
                     SUM(tu.total_tokens) as total_tokens,
+                    -- La entrada, a precio de entrada, más lo que cambia la caché: lo leído de ella (cache input) y lo
+                    -- escrito en ella (cache write), cada uno a su precio y, sin él, al de entrada (la diferencia es 0)
                     SUM(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                              + COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                              + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
                               + tu.completion_tokens * t.precio_output_eur_millon)
                               * t.margen / 1000000)::numeric, 8))::double precision as total_cost_eur,
                     COUNT(DISTINCT COALESCE(tu.chat_id, me.chat_id)) as chat_count
@@ -512,7 +580,11 @@ class ChatbotSchema(SchemaTemplate):
                     SUM(tu.prompt_tokens) as total_prompt_tokens,
                     SUM(tu.completion_tokens) as total_completion_tokens,
                     SUM(tu.total_tokens) as total_tokens,
+                    -- La entrada, a precio de entrada, más lo que cambia la caché: lo leído de ella (cache input) y lo
+                    -- escrito en ella (cache write), cada uno a su precio y, sin él, al de entrada (la diferencia es 0)
                     SUM(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                              + COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                              + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
                               + tu.completion_tokens * t.precio_output_eur_millon)
                               * t.margen / 1000000)::numeric, 8))::double precision as coste_eur
                 FROM token_usage tu
@@ -561,6 +633,112 @@ class ChatbotSchema(SchemaTemplate):
             ORDER BY mes DESC, username, total_tokens DESC;
         ''').rstrip()
 
+        consumo_apunte_sql = dedent('''\
+            -- Vista con cada apunte de consumo: de dónde sale, con qué modelo y lo exacto que dio el
+            -- proveedor y las vueltas del agente, con su coste calculado como en consumo_mensual (por fila, con el margen y
+            -- redondeado a 8 decimales). Un apunte sin tarifa sale con el modelo y el coste vacíos.
+            -- Un apunte sin origen es 'respuesta' si cuelga de un mensaje, y si no 'sin_clasificar'
+            SELECT
+                tu.id as token_usage_id,
+                tu.timestamp,
+                tu.username,
+                tu.message_id,
+                tu.chat_id,
+                COALESCE(tu.origen, CASE WHEN tu.message_id IS NOT NULL THEN 'respuesta' ELSE 'sin_clasificar' END) as origen,
+                tu.llamadas,
+                tu.cache_read,
+                tu.cache_write,
+                tu.estimado,
+                tu.herramienta,
+                ms.agent_iterations as rondas,
+                tu.tarifa_id,
+                m.alias as modelo,
+                m.provider,
+                m.model_name,
+                tu.prompt_tokens,
+                tu.completion_tokens,
+                tu.total_tokens,
+                -- La entrada, a precio de entrada, más lo que cambia la caché: lo leído de ella (cache input) y lo
+                -- escrito en ella (cache write), cada uno a su precio y, sin él, al de entrada (la diferencia es 0)
+                ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                        + COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                        + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon))
+                       * t.margen / 1000000)::numeric, 8)::double precision as coste_entrada_eur,
+                ROUND((tu.completion_tokens * t.precio_output_eur_millon
+                       * t.margen / 1000000)::numeric, 8)::double precision as coste_salida_eur,
+                ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                        + COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                        + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                        + tu.completion_tokens * t.precio_output_eur_millon)
+                       * t.margen / 1000000)::numeric, 8)::double precision as coste_eur,
+                -- lo que la caché ahorró frente a cobrar la entrada entera a precio de entrada (negativo
+                -- si escribir en ella costó más), y si la tarifa tiene precio de cache input
+                ROUND((-(COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                         + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon))
+                       * t.margen / 1000000)::numeric, 8)::double precision as ahorro_cache_eur,
+                (t.precio_cache_input_eur_millon IS NOT NULL) as precio_cache
+            FROM token_usage tu
+            LEFT JOIN tarifa t ON t.id = tu.tarifa_id
+            LEFT JOIN modelo m ON m.id = t.modelo_id
+            LEFT JOIN mensaje ms ON ms.id = tu.message_id
+            ORDER BY tu.timestamp, tu.id;
+        ''').rstrip()
+
+        consumo_parte_sql = dedent('''\
+            -- Vista con cada parte de un apunte de consumo (token_usage_parte) y su coste, como en
+            -- consumo_apunte: la salida a su precio, y la entrada al precio medio de la de su apunte, que
+            -- reparte lo que cambia la caché (no se sabe qué parte salió de ella). Lleva la fecha, el
+            -- usuario y el modelo del apunte, para filtrar las
+            -- partes igual que los apuntes. Un apunte sin partes no sale: las suyas son el apunte
+            -- entero, que está en consumo_apunte
+            SELECT
+                p.id as parte_id,
+                p.token_usage_id,
+                tu.timestamp,
+                tu.username,
+                m.alias as modelo,
+                p.tipo,
+                p.parte,
+                p.tokens,
+                ROUND((p.tokens * CASE WHEN p.tipo = 'entrada'
+                                       THEN t.precio_input_eur_millon
+                                            + COALESCE((COALESCE(tu.cache_read, 0) * (COALESCE(t.precio_cache_input_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon)
+                                                        + COALESCE(tu.cache_write, 0) * (COALESCE(t.precio_cache_write_eur_millon, t.precio_input_eur_millon) - t.precio_input_eur_millon))
+                                                       / NULLIF(tu.prompt_tokens, 0), 0)
+                                       ELSE t.precio_output_eur_millon END
+                       * t.margen / 1000000)::numeric, 8)::double precision as coste_eur
+            FROM token_usage_parte p
+            JOIN token_usage tu ON tu.id = p.token_usage_id
+            LEFT JOIN tarifa t ON t.id = tu.tarifa_id
+            LEFT JOIN modelo m ON m.id = t.modelo_id
+            WHERE p.tokens <> 0
+            ORDER BY p.id;
+        ''').rstrip()
+
+        valoracion_sql = dedent('''\
+            -- Vista con las respuestas que el usuario valoró con un comentario, con su conversación
+            -- y lo que se apuntó con ellas. Solo las que tienen comentario: la columna feedback nace
+            -- 'good', así que una valoración sin texto no se distingue de un mensaje sin valorar
+            SELECT
+                m.id as message_id,
+                m.timestamp,
+                m.content,
+                m.feedback::text as feedback,
+                m.feedback_comment,
+                m.total_duration_ms,
+                m.model_name,
+                c.id as chat_id,
+                c.title as chat_title,
+                c.username,
+                (SELECT SUM(tu.total_tokens) FROM token_usage tu WHERE tu.message_id = m.id) as total_tokens
+            FROM mensaje m
+            JOIN chat c ON c.id = m.chat_id
+            WHERE m.role = 'asistente'
+              AND m.feedback_comment IS NOT NULL
+              AND trim(m.feedback_comment) <> ''
+            ORDER BY m.timestamp DESC;
+        ''').rstrip()
+
         modelo_disponible_sql = dedent('''\
             -- Vista con el catálogo de modelos; el endpoint y la variable de la clave no salen de aquí
             WITH ventana AS (
@@ -613,6 +791,8 @@ class ChatbotSchema(SchemaTemplate):
                 m.model_name,
                 (v.precio_input_eur_millon * v.margen)::double precision as precio_input_eur_millon,
                 (v.precio_output_eur_millon * v.margen)::double precision as precio_output_eur_millon,
+                (v.precio_cache_input_eur_millon * v.margen)::double precision as precio_cache_input_eur_millon,
+                (v.precio_cache_write_eur_millon * v.margen)::double precision as precio_cache_write_eur_millon,
                 v.desde,
                 v.hasta_efectivo as hasta,
                 (v.desde <= CURRENT_DATE
@@ -622,36 +802,6 @@ class ChatbotSchema(SchemaTemplate):
             ORDER BY m.alias, v.desde DESC;
         ''').rstrip()
 
-        tarifa_vigente_sql = dedent('''\
-            -- Vista con la tarifa que rige hoy para cada modelo, ya a precio de venta: el precio del
-            -- proveedor y el margen no salen de la tabla. La ventana se deriva de la tarifa siguiente,
-            -- así que dar de alta una tarifa nueva no obliga a cerrar la anterior
-            WITH ventana AS (
-                SELECT
-                    t.*,
-                    COALESCE(
-                        t.hasta,
-                        LEAD(t.desde) OVER (PARTITION BY t.modelo_id ORDER BY t.desde) - 1
-                    ) as hasta_efectivo
-                FROM tarifa t
-            )
-            SELECT
-                v.id as tarifa_id,
-                v.modelo_id,
-                m.alias,
-                m.provider,
-                m.model_name,
-                (v.precio_input_eur_millon * v.margen)::double precision as precio_input_eur_millon,
-                (v.precio_output_eur_millon * v.margen)::double precision as precio_output_eur_millon,
-                v.desde,
-                v.hasta_efectivo as hasta
-            FROM ventana v
-            JOIN modelo m ON m.id = v.modelo_id
-            WHERE v.desde <= CURRENT_DATE
-              AND (v.hasta_efectivo IS NULL OR v.hasta_efectivo >= CURRENT_DATE)
-            ORDER BY m.alias;
-        ''').rstrip()
-
         tokens_mensaje_sql = dedent('''\
             -- Vista con los tokens de cada mensaje; no lleva importes a propósito: es la única que
             -- puede leer cualquier usuario
@@ -670,42 +820,6 @@ class ChatbotSchema(SchemaTemplate):
             GROUP BY tu.message_id, m.chat_id, c.username, m.model_name, m.provider;
         ''').rstrip()
 
-        user_stats_sql = dedent('''\
-            -- Vista para estadísticas de usuarios
-            WITH top_model AS (
-                SELECT DISTINCT ON (c.username)
-                    c.username,
-                    m.model_name,
-                    SUM(tu.total_tokens) AS total_tokens,
-                    COUNT(DISTINCT DATE(tu.timestamp)) AS active_days
-                FROM chat c
-                JOIN mensaje m ON c.id = m.chat_id
-                JOIN token_usage tu ON m.id = tu.message_id
-                GROUP BY c.username, m.model_name
-                ORDER BY c.username, SUM(tu.total_tokens) DESC
-            )
-
-            SELECT
-                c.username,
-                COUNT(DISTINCT c.id) AS total_chats,
-                COUNT(DISTINCT CASE WHEN c.is_active THEN c.id END) AS active_chats,
-                COUNT(DISTINCT m.id) AS total_messages,
-                MAX(m.timestamp) AS last_activity,
-
-                tm.model_name AS most_used_model,
-                tm.total_tokens AS most_used_model_total_tokens,
-                tm.active_days AS most_used_model_active_days
-
-            FROM chat c
-            LEFT JOIN mensaje m ON c.id = m.chat_id
-            LEFT JOIN top_model tm ON c.username = tm.username
-            GROUP BY
-                c.username,
-                tm.model_name,
-                tm.total_tokens,
-                tm.active_days;
-        ''').rstrip()
-
         usuario_consumo_sql = dedent('''\
             -- Vista con los usuarios a los que se mide el consumo. Es la que leen sus pantallas:
             -- /rbac/{realm}/user pide administración del realm y la contraseña no sale de aquí
@@ -723,12 +837,12 @@ class ChatbotSchema(SchemaTemplate):
         ''').rstrip()
 
         (views_dir / 'bolsa_estado.sql').write_text(bolsa_estado_sql, encoding='utf-8')
-        (views_dir / 'chat_activity.sql').write_text(chat_activity_sql, encoding='utf-8')
+        (views_dir / 'consumo_apunte.sql').write_text(consumo_apunte_sql, encoding='utf-8')
+        (views_dir / 'consumo_parte.sql').write_text(consumo_parte_sql, encoding='utf-8')
         (views_dir / 'consumo_diario.sql').write_text(consumo_diario_sql, encoding='utf-8')
         (views_dir / 'consumo_mensual.sql').write_text(consumo_mensual_sql, encoding='utf-8')
         (views_dir / 'modelo_disponible.sql').write_text(modelo_disponible_sql, encoding='utf-8')
         (views_dir / 'tarifa_historico.sql').write_text(tarifa_historico_sql, encoding='utf-8')
-        (views_dir / 'tarifa_vigente.sql').write_text(tarifa_vigente_sql, encoding='utf-8')
         (views_dir / 'tokens_mensaje.sql').write_text(tokens_mensaje_sql, encoding='utf-8')
-        (views_dir / 'user_stats.sql').write_text(user_stats_sql, encoding='utf-8')
         (views_dir / 'usuario_consumo.sql').write_text(usuario_consumo_sql, encoding='utf-8')
+        (views_dir / 'valoracion.sql').write_text(valoracion_sql, encoding='utf-8')

{tai_sql-0.8.0 → tai_sql-0.8.2}/tai_sql/generators/python_client/templates/domain/dtos.py.jinja2

@@ -221,10 +221,28 @@ class {{ model.name }}Read(PrettyModel):
 
     {% if not model.is_view %}
     @classmethod
+{% if _all_vector_cols %}
+    def from_created_instance(
+        cls,
+        instance: {{ model.name }},
+        included: set[str],
+        excluded: str=None,
+        include_vectors: bool = False,
+    ) -> {{ model.name }}Read:
+{% else %}
     def from_created_instance(cls, instance: {{ model.name }}, included: set[str], excluded: str=None) -> {{ model.name }}Read:
+{% endif %}
+        {% if _all_vector_cols %}
+        # Como `from_instance`: los vectores solo si se piden. Son miles de números por fila, y
+        # lo que se acaba de crear se devuelve entero (`create_many` de mil filas eran millones).
+        # Las filas anidadas los dejan fuera siempre, como las relaciones de `from_instance`.
+        {% endif %}
         dto_data = {
             {% for column in model.columns %}
-            {% if not column.hash %}
+            {% if column.hash %}
+            {% elif column.type == 'vector' %}
+            '{{ column.name }}': instance.{{ column.name }} if include_vectors else None,
+            {% else %}
             '{{ column.name }}': instance.{{ column.name }},
             {% endif %}
             {% endfor %}

{tai_sql-0.8.0 → tai_sql-0.8.2}/tai_sql/generators/python_client/templates/macros/write.jinja2

@@ -139,11 +139,15 @@
         return len({{ await_keyword -}} cls.create_many([{{ model.name }}Create.from_dict(record) for record in records_data]))
         {% endif %}
 
+{% set _created_vector_cols = model.columns | selectattr('type', 'equalto', 'vector') | list %}
     @classmethod
     @{{ error_handler_name }}
     {{ def_keyword }} create(
         cls, 
         {{ model.tablename }}: {{ model.name }}Create,
+{% if _created_vector_cols %}
+        include_vectors: bool = False,
+{% endif %}
         session: Optional[{{ session_type }}] = None
     ) -> {{ model.name }}Read:
         """
@@ -151,6 +155,10 @@
         
         Args:
             {{ model.tablename }}: Datos del {{ model.tablename }} a crear
+{% if _created_vector_cols %}
+            include_vectors: Si True, el registro devuelto lleva sus columnas vectoriales. Por
+                defecto no, como en `find`: se guardan igual, solo no se devuelven.
+{% endif %}
             session: Sesión existente (opcional)
             
         Returns:
@@ -173,7 +181,11 @@
 {% endif %}
             {{ await_keyword -}} session.flush()
             {{ await_keyword -}} cls._on_create_after(new_instance, included, session)
+{% if _created_vector_cols %}
+            return {{ model.name }}Read.from_created_instance(new_instance, included, include_vectors=include_vectors)
+{% else %}
             return {{ model.name }}Read.from_created_instance(new_instance, included)
+{% endif %}
 
         if session is not None:
             data = {{ await_keyword -}} _execute_create(session)
@@ -199,6 +211,9 @@
     {{ def_keyword }} create_many(
         cls, 
         records: List[{{ model.name }}Create], 
+{% if _created_vector_cols %}
+        include_vectors: bool = False,
+{% endif %}
         session: Optional[{{ session_type }}] = None
     ) -> List[{{ model.name }}Read]:
         """
@@ -206,6 +221,10 @@
         
         Args:
             records: Lista de {{ model.name }}Create con los datos de los registros
+{% if _created_vector_cols %}
+            include_vectors: Si True, los registros devueltos llevan sus columnas vectoriales. Por
+                defecto no, como en `find_many`: con mil filas serían millones de números.
+{% endif %}
             session: Sesión existente (opcional)
             
         Returns:
@@ -240,7 +259,11 @@
             # Los DTO se construyen después de los triggers `after`, como en `create`: lo que
             # escriban en la fila tiene que salir en lo que se devuelve
             return [
+{% if _created_vector_cols %}
+                {{ model.name }}Read.from_created_instance(instance, included, include_vectors=include_vectors)
+{% else %}
                 {{ model.name }}Read.from_created_instance(instance, included)
+{% endif %}
                 for instance, included in creadas
             ]