feat(provider): support Codex subscriptions with ChatGPT sign-in (#2513)

* feat(provider): support Codex subscriptions with ChatGPT sign-in

* style: format Codex live integration test

* fix(provider): preserve Codex identity in temporary model tests

* fix(web): portal provider selector without dialog overflow

* fix(web): allow native scrolling in provider dropdown

* fix(provider): surface safe Codex quota and upstream errors

* fix(web): provide reliable Codex copy feedback in dialogs

* feat(provider): confirm cascade deletion from edit dialog

* fix(persistence): discard connections after failed commit

* fix(web): polish provider loading and confirmation motion

---------

Co-authored-by: dadachann <185672915+dadachann@users.noreply.github.com>

src/langbot/pkg/persistence/alembic/versions/0022_codex_credentials.py

@@ -0,0 +1,48 @@
+"""Add isolated server-only Codex credentials and tenant RLS.
+
+Revision ID: 0022_codex_credentials
+Revises: 0021_merge_reasoning_config
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+revision = '0022_codex_credentials'
+down_revision = '0021_merge_reasoning_config'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    # Fresh startup creates ORM metadata before running Alembic.
+    if 'codex_credentials' not in sa.inspect(conn).get_table_names():
+        op.create_table(
+            'codex_credentials',
+            sa.Column('provider_uuid', sa.String(255), primary_key=True),
+            sa.Column('workspace_uuid', sa.String(36), nullable=False),
+            sa.Column('payload', sa.JSON(), nullable=False),
+            sa.Column('version', sa.Integer(), nullable=False),
+            sa.Column('lease_owner', sa.String(64), nullable=True),
+            sa.Column('lease_until', sa.Float(), nullable=False),
+            sa.ForeignKeyConstraint(
+                ['workspace_uuid', 'provider_uuid'],
+                ['model_providers.workspace_uuid', 'model_providers.uuid'],
+                name='fk_codex_credentials_workspace_provider',
+                ondelete='CASCADE',
+            ),
+        )
+        op.create_index('ix_codex_credentials_workspace', 'codex_credentials', ['workspace_uuid'])
+    if conn.dialect.name == 'postgresql':
+        op.execute('ALTER TABLE codex_credentials ENABLE ROW LEVEL SECURITY')
+        op.execute('ALTER TABLE codex_credentials FORCE ROW LEVEL SECURITY')
+        op.execute('DROP POLICY IF EXISTS langbot_workspace_isolation ON codex_credentials')
+        expression = "workspace_uuid::text = NULLIF(current_setting('langbot.workspace_uuid', true), '')"
+        op.execute(
+            f'CREATE POLICY langbot_workspace_isolation ON codex_credentials '
+            f'FOR ALL USING ({expression}) WITH CHECK ({expression})'
+        )
+
+
+def downgrade() -> None:
+    op.drop_table('codex_credentials')

src/langbot/pkg/persistence/mgr.py

@@ -62,6 +62,7 @@ _ALEMBIC_TENANT_TABLES = {
     'binary_storages',
     'mcp_servers',
     'model_providers',
+    'codex_credentials',
     'llm_models',
     'embedding_models',
     'rerank_models',

src/langbot/pkg/persistence/tenant_uow.py

@@ -51,6 +51,7 @@ TENANT_TABLE_COLUMNS: dict[str, str] = {
     'binary_storages': 'workspace_uuid',
     'mcp_servers': 'workspace_uuid',
     'model_providers': 'workspace_uuid',
+    'codex_credentials': 'workspace_uuid',
     'llm_models': 'workspace_uuid',
     'embedding_models': 'workspace_uuid',
     'rerank_models': 'workspace_uuid',
@@ -852,7 +853,30 @@ class TenantScopedAsyncSession(sqlalchemy_asyncio.AsyncSession):
         self._require_owner_task()
         self._enter_internal_access()
         try:
-            await transaction.commit()
+            # Retain the actual connection before COMMIT: after a failed SQLite
+            # COMMIT the logical transaction is inactive, but the DBAPI writer
+            # can still hold PENDING/RESERVED locks. Session.close()/rollback()
+            # alone can then return that poisoned connection to the pool.
+            connection = await super().connection()
+            try:
+                await transaction.commit()
+            except BaseException as exc:
+                cleanup = asyncio.create_task(connection.invalidate())
+                # Invalidation does not access the task-owned Session. Shield
+                # physical cleanup, including against repeated cancellation,
+                # before the owner closes the Session and releases its scope.
+                while not cleanup.done():
+                    try:
+                        await asyncio.shield(cleanup)
+                    except asyncio.CancelledError:
+                        continue
+                    except BaseException:
+                        break
+                try:
+                    cleanup.result()
+                except BaseException as cleanup_error:
+                    exc.add_note(f'Failed to invalidate transaction connection: {cleanup_error!r}')
+                raise
         finally:
             self._exit_internal_access()
 
@@ -1369,6 +1393,7 @@ class TenantUnitOfWork:
             state.mark_rollback_only(exc_value)
         rollback_only = state.rollback_only
         committed = False
+        transaction_error: BaseException | None = None
         try:
             if exc_type is None and not rollback_only:
                 await typing.cast(TenantScopedAsyncSession, session)._commit_owned_transaction(
@@ -1381,6 +1406,9 @@ class TenantUnitOfWork:
                     _UOW_SESSION_CONTROL_CAPABILITY,
                     transaction,
                 )
+        except BaseException as exc:
+            transaction_error = exc
+            raise
         finally:
             try:
                 if self._active_transaction is not None and self._context_token is not None:
@@ -1388,6 +1416,10 @@ class TenantUnitOfWork:
                 await typing.cast(TenantScopedAsyncSession, session)._close_owned_session(
                     _UOW_SESSION_CONTROL_CAPABILITY
                 )
+            except BaseException as cleanup_error:
+                if transaction_error is None:
+                    raise
+                transaction_error.add_note(f'Failed to close transaction Session: {cleanup_error!r}')
             finally:
                 if self._database_operation_token is not None:
                     _DATABASE_OPERATION_TRANSACTION.reset(self._database_operation_token)