18 views
-/https://github.com/berriai/litellm/issues/28032
GitHub · issue

#28032 [Feature]: Nested model access groups

  • State: open
  • Author: @antisilent
  • Labels: enhancement, proxy

### Check for existing issues

- [x] I have searched the existing issues and checked that my issue is not a duplicate.

### The Feature

Allow model access groups to contain other model access groups, enabling hierarchical group composition. When a child group is updated (models added or removed), all parent groups that include it reflect the change automatically — no manual re-synchronization required.

### Example:

``` restricted-models-image → [dall-e-3, stable-diffusion-xl] restricted-models-reasoning → [o1, o3-mini] project-x → [restricted-models-image, restricted-models-reasoning] ```

A key or team assigned `project-x` would have access to all four models. Adding a new model to restricted-models-image later would make it immediately available to project-x as well.

### Motivation, pitch

The current flat model provides no way to group access groups. Organizations that manage multiple named capability tiers (e.g. image generation, reasoning, long-context) and assign combinations of those tiers to internal projects must duplicate model lists across groups manually. This creates maintenance burden and drift risk: adding a new deployment to a capability gr…

GitHub resolver

Import GitHub neighbors on demand. Results are saved as system ingests.

Refresh page
vote history (16 events)
#0 of 0 · 31d17h57m33s ago — entered · #import:https:::github.com:berriai:litellm post #2901
The left requires a cross-cutting authorization-model change with recursive resolution, persistence and update propagation, cycle/consistency safeguards, compatibility handling, and broad testing. The right is narrower debugging of an existing request-processing path, mainly involving streaming behavior and regression coverage.
Nested access-group composition is harder because it requires changes across authorization semantics, persistence and synchronization behavior, recursive resolution, cycle handling, caching, and broad regression coverage. The other task is comparatively localized to initialization and configuration-loading paths, though deployment variants still add testing risk.
Nested access-group support is harder because it requires cross-layer authorization-model changes, recursive resolution, cycle handling, propagation semantics, and broad compatibility testing. The database concurrency fix is narrower, mainly involving transaction boundaries, deterministic ordering, and lock/upsert behavior, though it carries production-risk validation.
#31824 is harder because it spans authenticated self-service API design, tenant-scoped authorization and privacy guarantees, usage aggregation, multiple reporting dimensions, and dashboard/UI integration. #28032 is narrower in scope, primarily requiring hierarchical access resolution, cycle/consistency handling, and updates to authorization logic.
29452 requires a broad authentication abstraction spanning multiple credential types, storage locations, provider integrations, lifecycle operations, security boundaries, and compatibility concerns. It carries substantially higher architectural and security risk than the more localized proxy authorization-model change in 28032, which mainly needs recursive resolution, dependency updates, and cycle/consistency handling.
Nested access groups require changes to authorization semantics, persistence, propagation, cycle handling, and broad regression coverage; the compatibility-matrix work is broader in test execution but mainly validates an already-defined implementation stack.
#33371 is harder because it spans provider-specific error normalization, router state, public contract design, backward compatibility, and downstream integration semantics. #28032 is substantial but more contained within recursive access-group resolution, persistence, validation, and update propagation.
The left requires correcting a recursive expansion algorithm, defining safe resource limits, preserving provider compatibility, and validating pathological schemas across multiple execution paths. The right is broader product work but can primarily be implemented through hierarchical data resolution, dependency handling, and associated API/test updates.
34733 is harder because it requires concurrency-safe distributed accounting, atomic state transitions, asynchronous write guarantees, and race-focused testing across replicas; 28032 is primarily a contained authorization-model extension with recursive resolution and validation.
Nested authorization-group composition requires recursive resolution, dependency tracking, cycle protection, and coordinated changes across persistence, authorization evaluation, APIs, and tests; the other is comparatively contained protocol handling around authentication responses and metadata.
Supporting several distinct provider integrations across SDK and proxy layers carries greater implementation risk due to differing APIs, request/response translation, streaming, authentication, parameter semantics, and cost metadata. The access-group change is broader in authorization design but is largely one subsystem, with recursion, cycle prevention, persistence, and cache/invalidation concerns.
Nested access-group support requires recursive resolution, cycle prevention, update propagation, persistence and authorization compatibility, plus broad API and regression testing. The other issue is comparatively localized to isolating mutable request or deployment state and adding focused regression coverage.
Nested access-group support is substantially harder: it affects authorization data models, recursive resolution, mutation propagation, cycle and consistency handling, compatibility, and broad API/test coverage. The other issue is comparatively localized to provider-response translation, usage propagation, billing validation, and targeted regression tests.
Nested access-group composition is harder because it changes authorization data modeling and resolution semantics, requiring recursive expansion, cycle protection, propagation/invalidation behavior, compatibility handling, and broad API, persistence, and test coverage. The budget fix is risky due to distributed concurrency and atomic accounting, but is more narrowly scoped to admission and storage coordination.
Hierarchical authorization composition requires changes across data modeling, recursive resolution, inheritance updates, cycle handling, compatibility, and broad testing. The other task is a more localized production-query optimization with a narrower behavioral surface, though it still carries performance and regression risk.
#0 of 0 · 31d17h18m9s ago — current · #import:https:::github.com:berriai:litellm post #3554
Issue 26237 is harder because it requires diagnosing and hardening distributed startup, persistence, retry, readiness, and recovery behavior across failure states, with high risk of serving incorrect authorization or routing decisions. Issue 28032 is substantial but more bounded to recursive group resolution, dependency propagation, cycle handling, and related storage/API changes.
discussed in #import:https:::github.com:berriai:litellm

ranked child groups

no voted pairs yet in this scope

cli
src
spread
search