codexLB-up 1.25.0b10__py3-none-any.whl

app/db/alembic/versions/20260228_020000_align_api_key_limit_enum_types.py

@@ -0,0 +1,104 @@
+"""align api_key_limits enum column types on postgresql
+
+Revision ID: 20260228_020000_align_api_key_limit_enum_types
+Revises: 20260225_000000_add_dashboard_settings_routing_strategy
+Create Date: 2026-02-28
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+from sqlalchemy.sql.sqltypes import TypeEngine
+
+# revision identifiers, used by Alembic.
+revision = "20260228_020000_align_api_key_limit_enum_types"
+down_revision = "20260225_000000_add_dashboard_settings_routing_strategy"
+branch_labels = None
+depends_on = None
+
+_LIMIT_TYPE_VALUES = (
+    "total_tokens",
+    "input_tokens",
+    "output_tokens",
+    "cost_usd",
+)
+
+_LIMIT_WINDOW_VALUES = (
+    "daily",
+    "weekly",
+    "monthly",
+)
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _column_types(connection: Connection, table_name: str) -> dict[str, TypeEngine]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return {}
+    return {
+        str(column["name"]): column["type"]
+        for column in inspector.get_columns(table_name)
+        if column.get("name") is not None and column.get("type") is not None
+    }
+
+
+def _is_named_postgresql_enum(column_type: TypeEngine, enum_name: str) -> bool:
+    enum_values = getattr(column_type, "enums", None)
+    if enum_values is None:
+        return False
+    return getattr(column_type, "name", None) == enum_name
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name != "postgresql":
+        return
+    if not _table_exists(bind, "api_key_limits"):
+        return
+
+    limit_type_enum = sa.Enum(*_LIMIT_TYPE_VALUES, name="limit_type")
+    limit_window_enum = sa.Enum(*_LIMIT_WINDOW_VALUES, name="limit_window")
+    limit_type_enum.create(bind, checkfirst=True)
+    limit_window_enum.create(bind, checkfirst=True)
+
+    column_types = _column_types(bind, "api_key_limits")
+    limit_type_column = column_types.get("limit_type")
+    limit_window_column = column_types.get("limit_window")
+
+    if limit_type_column is not None and not _is_named_postgresql_enum(limit_type_column, "limit_type"):
+        op.execute(
+            sa.text("ALTER TABLE api_key_limits ALTER COLUMN limit_type TYPE limit_type USING limit_type::limit_type")
+        )
+    if limit_window_column is not None and not _is_named_postgresql_enum(limit_window_column, "limit_window"):
+        op.execute(
+            sa.text(
+                "ALTER TABLE api_key_limits "
+                "ALTER COLUMN limit_window TYPE limit_window "
+                "USING limit_window::limit_window"
+            )
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name != "postgresql":
+        return
+    if not _table_exists(bind, "api_key_limits"):
+        return
+
+    column_types = _column_types(bind, "api_key_limits")
+    limit_type_column = column_types.get("limit_type")
+    limit_window_column = column_types.get("limit_window")
+
+    if limit_type_column is not None and _is_named_postgresql_enum(limit_type_column, "limit_type"):
+        op.execute(sa.text("ALTER TABLE api_key_limits ALTER COLUMN limit_type TYPE VARCHAR USING limit_type::text"))
+    if limit_window_column is not None and _is_named_postgresql_enum(limit_window_column, "limit_window"):
+        op.execute(
+            sa.text("ALTER TABLE api_key_limits ALTER COLUMN limit_window TYPE VARCHAR USING limit_window::text")
+        )

app/db/alembic/versions/20260228_030000_add_api_firewall_allowlist.py

@@ -0,0 +1,42 @@
+"""add api_firewall_allowlist table
+
+Revision ID: 20260228_030000_add_api_firewall_allowlist
+Revises: 20260228_020000_align_api_key_limit_enum_types
+Create Date: 2026-02-28
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260228_030000_add_api_firewall_allowlist"
+down_revision = "20260228_020000_align_api_key_limit_enum_types"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+
+    if _table_exists(bind, "api_firewall_allowlist"):
+        return
+
+    op.create_table(
+        "api_firewall_allowlist",
+        sa.Column("ip_address", sa.String(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(), server_default=sa.func.now(), nullable=False),
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if _table_exists(bind, "api_firewall_allowlist"):
+        op.drop_table("api_firewall_allowlist")

app/db/alembic/versions/20260306_000000_add_request_logs_service_tier.py

@@ -0,0 +1,45 @@
+"""add service_tier to request_logs
+
+Revision ID: 20260306_000000_add_request_logs_service_tier
+Revises: 20260228_030000_add_api_firewall_allowlist
+Create Date: 2026-03-06
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260306_000000_add_request_logs_service_tier"
+down_revision = "20260228_030000_add_api_firewall_allowlist"
+branch_labels = None
+depends_on = None
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {column["name"] for column in inspector.get_columns(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "request_logs")
+    if not columns or "service_tier" in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.add_column(sa.Column("service_tier", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "request_logs")
+    if "service_tier" not in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.drop_column("service_tier")

app/db/alembic/versions/20260307_000000_add_api_key_enforcement_fields.py

@@ -0,0 +1,56 @@
+"""add api key enforcement fields
+
+Revision ID: 20260307_000000_add_api_key_enforcement_fields
+Revises: 20260306_000000_add_request_logs_service_tier
+Create Date: 2026-03-07
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260307_000000_add_api_key_enforcement_fields"
+down_revision = "20260306_000000_add_request_logs_service_tier"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "api_keys"):
+        return
+
+    existing_columns = _columns(bind, "api_keys")
+    with op.batch_alter_table("api_keys") as batch_op:
+        if "enforced_model" not in existing_columns:
+            batch_op.add_column(sa.Column("enforced_model", sa.String(), nullable=True))
+        if "enforced_reasoning_effort" not in existing_columns:
+            batch_op.add_column(sa.Column("enforced_reasoning_effort", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "api_keys"):
+        return
+
+    existing_columns = _columns(bind, "api_keys")
+    with op.batch_alter_table("api_keys") as batch_op:
+        if "enforced_reasoning_effort" in existing_columns:
+            batch_op.drop_column("enforced_reasoning_effort")
+        if "enforced_model" in existing_columns:
+            batch_op.drop_column("enforced_model")

app/db/alembic/versions/20260308_000000_add_sqlite_performance_indexes.py

@@ -0,0 +1,41 @@
+"""add performance indexes for sqlite startup query paths
+
+Revision ID: 20260308_000000_add_sqlite_performance_indexes
+Revises: 20260307_000000_add_api_key_enforcement_fields
+Create Date: 2026-03-08
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "20260308_000000_add_sqlite_performance_indexes"
+down_revision = "20260307_000000_add_api_key_enforcement_fields"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute(
+        sa.text(
+            """
+            CREATE INDEX IF NOT EXISTS idx_usage_window_account_latest
+            ON usage_history (coalesce("window", 'primary'), account_id, recorded_at DESC, id DESC)
+            """
+        )
+    )
+    op.execute(
+        sa.text(
+            """
+            CREATE INDEX IF NOT EXISTS idx_logs_requested_at_id
+            ON request_logs (requested_at DESC, id DESC)
+            """
+        )
+    )
+
+
+def downgrade() -> None:
+    op.execute(sa.text("DROP INDEX IF EXISTS idx_logs_requested_at_id"))
+    op.execute(sa.text("DROP INDEX IF EXISTS idx_usage_window_account_latest"))

app/db/alembic/versions/20260309_000000_add_additional_usage_history.py

@@ -0,0 +1,71 @@
+"""add additional_usage_history table
+
+Revision ID: 20260309_000000_add_additional_usage_history
+Revises: 20260309_000000_request_logs_nullable_account_id
+Create Date: 2026-03-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260309_000000_add_additional_usage_history"
+down_revision = "20260309_000000_request_logs_nullable_account_id"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _indexes(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(index["name"]) for index in inspector.get_indexes(table_name) if index.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+
+    if not _table_exists(bind, "additional_usage_history"):
+        op.create_table(
+            "additional_usage_history",
+            sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+            sa.Column("account_id", sa.String(), sa.ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False),
+            sa.Column("limit_name", sa.String(), nullable=False),
+            sa.Column("metered_feature", sa.String(), nullable=False),
+            sa.Column("window", sa.String(), nullable=False),
+            sa.Column("used_percent", sa.Float(), nullable=False),
+            sa.Column("reset_at", sa.Integer(), nullable=True),
+            sa.Column("window_minutes", sa.Integer(), nullable=True),
+            sa.Column("recorded_at", sa.DateTime(), nullable=False, server_default=sa.text("CURRENT_TIMESTAMP")),
+        )
+
+    existing_indexes = _indexes(bind, "additional_usage_history")
+    if "ix_additional_usage_history_account_id" not in existing_indexes:
+        op.create_index("ix_additional_usage_history_account_id", "additional_usage_history", ["account_id"])
+    if "ix_additional_usage_history_recorded_at" not in existing_indexes:
+        op.create_index("ix_additional_usage_history_recorded_at", "additional_usage_history", ["recorded_at"])
+    if "ix_additional_usage_history_composite" not in existing_indexes:
+        op.create_index(
+            "ix_additional_usage_history_composite",
+            "additional_usage_history",
+            ["account_id", "limit_name", "window", "recorded_at"],
+        )
+    # Index for latest_by_account queries that filter on (limit_name, window)
+    if "ix_additional_usage_limit_window" not in existing_indexes:
+        op.create_index(
+            "ix_additional_usage_limit_window",
+            "additional_usage_history",
+            ["limit_name", "window", "account_id", "recorded_at"],
+        )
+
+
+def downgrade() -> None:
+    op.drop_table("additional_usage_history")

app/db/alembic/versions/20260309_000000_request_logs_nullable_account_id.py

@@ -0,0 +1,28 @@
+"""make request_logs.account_id nullable for no-account errors
+
+Revision ID: 20260309_000000_request_logs_nullable_account_id
+Revises: 20260308_000000_add_sqlite_performance_indexes
+Create Date: 2026-03-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "20260309_000000_request_logs_nullable_account_id"
+down_revision = "20260308_000000_add_sqlite_performance_indexes"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.alter_column("account_id", nullable=True)
+
+
+def downgrade() -> None:
+    op.execute(sa.text("DELETE FROM request_logs WHERE account_id IS NULL"))
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.alter_column("account_id", nullable=False)

app/db/alembic/versions/20260310_000000_add_request_logs_transport.py

@@ -0,0 +1,45 @@
+"""add transport to request_logs
+
+Revision ID: 20260310_000000_add_request_logs_transport
+Revises: 20260310_000000_fix_postgresql_enum_value_casing
+Create Date: 2026-03-10
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260310_000000_add_request_logs_transport"
+down_revision = "20260310_000000_fix_postgresql_enum_value_casing"
+branch_labels = None
+depends_on = None
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {column["name"] for column in inspector.get_columns(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "request_logs")
+    if not columns or "transport" in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.add_column(sa.Column("transport", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "request_logs")
+    if "transport" not in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.drop_column("transport")

app/db/alembic/versions/20260310_000000_fix_postgresql_enum_value_casing.py

@@ -0,0 +1,79 @@
+"""fix postgresql enum value casing from uppercase to lowercase
+
+Revision ID: 20260310_000000_fix_postgresql_enum_value_casing
+Revises: 20260309_000000_add_additional_usage_history
+Create Date: 2026-03-10
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "20260310_000000_fix_postgresql_enum_value_casing"
+down_revision = "20260309_000000_add_additional_usage_history"
+branch_labels = None
+depends_on = None
+
+_ENUM_RENAMES: dict[str, list[tuple[str, str]]] = {
+    "account_status": [
+        ("ACTIVE", "active"),
+        ("RATE_LIMITED", "rate_limited"),
+        ("QUOTA_EXCEEDED", "quota_exceeded"),
+        ("PAUSED", "paused"),
+        ("DEACTIVATED", "deactivated"),
+    ],
+    "limit_type": [
+        ("TOTAL_TOKENS", "total_tokens"),
+        ("INPUT_TOKENS", "input_tokens"),
+        ("OUTPUT_TOKENS", "output_tokens"),
+        ("COST_USD", "cost_usd"),
+    ],
+    "limit_window": [
+        ("DAILY", "daily"),
+        ("WEEKLY", "weekly"),
+        ("MONTHLY", "monthly"),
+    ],
+}
+
+
+def _enum_value_exists(bind: sa.engine.Connection, enum_type_name: str, enum_value: str) -> bool:
+    result = bind.execute(
+        sa.text(
+            "SELECT 1 FROM pg_enum e "
+            "JOIN pg_type t ON e.enumtypid = t.oid "
+            "WHERE t.typname = :type_name AND e.enumlabel = :value"
+        ),
+        {"type_name": enum_type_name, "value": enum_value},
+    )
+    return result.scalar() is not None
+
+
+def _rename_enum_values(
+    bind: sa.engine.Connection,
+    enum_type_name: str,
+    renames: list[tuple[str, str]],
+) -> None:
+    for old_value, new_value in renames:
+        if _enum_value_exists(bind, enum_type_name, old_value):
+            bind.execute(sa.text(f"ALTER TYPE {enum_type_name} RENAME VALUE '{old_value}' TO '{new_value}'"))
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name != "postgresql":
+        return
+
+    for enum_type_name, renames in _ENUM_RENAMES.items():
+        _rename_enum_values(bind, enum_type_name, renames)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name != "postgresql":
+        return
+
+    for enum_type_name, renames in _ENUM_RENAMES.items():
+        reverse_renames = [(new_val, old_val) for old_val, new_val in renames]
+        _rename_enum_values(bind, enum_type_name, reverse_renames)

app/db/alembic/versions/20260310_120000_add_sticky_session_kinds_and_affinity_ttl.py

@@ -0,0 +1,110 @@
+"""add sticky session kinds and prompt-cache affinity ttl
+
+Revision ID: 20260310_120000_add_sticky_session_kinds_and_affinity_ttl
+Revises: 20260310_000000_fix_postgresql_enum_value_casing
+Create Date: 2026-03-10
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+# revision identifiers, used by Alembic.
+revision = "20260310_120000_add_sticky_session_kinds_and_affinity_ttl"
+down_revision = "20260310_000000_fix_postgresql_enum_value_casing"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def _indexes(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(index["name"]) for index in inspector.get_indexes(table_name) if index.get("name") is not None}
+
+
+def _prompt_cache_ttl_default() -> int:
+    # Historical default at this revision. This backfill used to read
+    # CODEX_LB_OPENAI_CACHE_AFFINITY_MAX_AGE_SECONDS; that env field was removed
+    # (remove-dead-env-settings) and the dashboard column is the only owner, so
+    # a fresh database bootstrap must not let a removed variable seed the row.
+    # 20260319_100937 raises 300 -> 1800 for rows still at this default.
+    return 300
+
+
+def _sticky_session_kind_enum() -> sa.Enum:
+    return sa.Enum(
+        "codex_session",
+        "sticky_thread",
+        "prompt_cache",
+        name="sticky_session_kind",
+    )
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    ttl_default = _prompt_cache_ttl_default()
+
+    if _table_exists(bind, "sticky_sessions"):
+        sticky_columns = _columns(bind, "sticky_sessions")
+        if "kind" not in sticky_columns:
+            if bind.dialect.name == "postgresql":
+                _sticky_session_kind_enum().create(bind, checkfirst=True)
+            with op.batch_alter_table("sticky_sessions") as batch_op:
+                batch_op.add_column(
+                    sa.Column(
+                        "kind",
+                        _sticky_session_kind_enum(),
+                        nullable=False,
+                        server_default=sa.text("'sticky_thread'"),
+                    )
+                )
+        if bind.dialect.name == "postgresql":
+            op.execute(sa.text("UPDATE sticky_sessions SET kind = 'sticky_thread' WHERE kind IS NULL"))
+        else:
+            op.execute(sa.text("UPDATE sticky_sessions SET kind = 'sticky_thread' WHERE kind IS NULL OR kind = ''"))
+        sticky_indexes = _indexes(bind, "sticky_sessions")
+        if "idx_sticky_kind_updated_at" not in sticky_indexes:
+            op.execute(sa.text("CREATE INDEX idx_sticky_kind_updated_at ON sticky_sessions (kind, updated_at DESC)"))
+
+    if _table_exists(bind, "dashboard_settings"):
+        dashboard_columns = _columns(bind, "dashboard_settings")
+        if "openai_cache_affinity_max_age_seconds" not in dashboard_columns:
+            with op.batch_alter_table("dashboard_settings") as batch_op:
+                batch_op.add_column(
+                    sa.Column(
+                        "openai_cache_affinity_max_age_seconds",
+                        sa.Integer(),
+                        nullable=False,
+                        server_default=sa.text(str(ttl_default)),
+                    )
+                )
+        bind.execute(
+            sa.text(
+                """
+                UPDATE dashboard_settings
+                SET openai_cache_affinity_max_age_seconds = :ttl_default
+                WHERE openai_cache_affinity_max_age_seconds IS NULL
+                """
+            ),
+            {"ttl_default": ttl_default},
+        )
+
+
+def downgrade() -> None:
+    # Downgrade intentionally keeps additive columns to avoid SQLite table rebuild risk.
+    return