feat(deployments): unify payload passthrough from api to adapter

[HzaRashid]

Formalizes how provider-specific payloads flow through the deployment API first and then into the deployment adapter, establishing an API-to-adapter contract relationship, and provides a generalizable pattern for other adapter domains.

The deployment adapter exposes provider escape hatches on a shared set of fields across the full API → adapter path (for example provider_spec, provider_config, provider_data, and provider_result). This PR keeps those field names structurally aligned across layers while allowing each layer to define its own schema for the same field. In practice, API-side provider schemas in Langflow can include Langflow-referential entities (such as project/flow references or other Langflow-managed context) that must be validated and resolved first; mapper resolution then transforms that API payload into a Langflow-agnostic payload before it reaches adapter-side schemas. Before this PR, these escape hatches were largely untyped dict[str, Any] payloads.

What’s included

• Grounded deployment payload flow:

  • adapter-side escape hatches are represented as named slots
  • Langflow maps API payloads into those slots via provider mappers
  • both layers share slot names but can use different models per slot

• Added shared payload contract primitives in lfx:

  • PayloadSlot, AdapterPayloadValidationError, ProviderPayloadSchemas, AdapterPayload
  • clear ownership docs in lfx.services.adapters.payload

• Added deployment payload taxonomy in lfx:

  • new deployment/payloads.py with canonical slot names and centralized TypeVars
  • operation-specific outbound result slots (instead of one shared deployment_result):
    • deployment_create_result
    • deployment_operation_result
    • deployment_list_result
    • config_list_result
    • snapshot_list_result
    • plus existing execution/item/status slots

• Genericized deployment schema usage to align with slot-specific typing:

  • provider mixins now carry explicit generic payload types
  • result/list models now use dedicated outbound TypeVars
  • centralized TypeVar definitions in deployment/payloads.py (single source of truth)

• Added adapter base contract hook:

  • BaseDeploymentService.payload_schemas: ClassVar[DeploymentPayloadSchemas | None]

• Added Langflow mapper base scaffolding:

  • DeploymentApiPayloads (Langflow-owned API slot registry)
  • BaseDeploymentMapper passthrough-first behavior with per-slot resolve_*/shape_* methods
  • DeploymentMapperRegistry (+ type guard on registration)

• Added package exports for new payload contract types in:

  • lfx.services.adapters.__init__
  • lfx.services.adapters.deployment.__init__

• Added/updated docs:

  • ownership boundaries in lfx payload modules
  • generalized payload ownership section in PLUGGABLE_SERVICES.md (with deployments as example)

Why

• Makes deployment adapter escape hatches explicit and typeable end-to-end.
• Keeps adapter contracts Langflow-agnostic while letting Langflow own API-specific validation and reshaping.
• Avoids over-coupling outbound payload shapes by splitting result slots per operation from the start.
• Sets up future provider-specific OpenAPI enrichment through Langflow-owned DeploymentApiPayloads.

Test plan

• make format_backend
• make lint
• uv run pytest src/backend/tests/unit/api/v1/test_deployment_mapper_base.py
• uv run pytest src/backend/tests/unit/api/v1/test_deployment_mapper_base.py src/backend/tests/unit/api/v1/test_deployment_schemas.py
• cd src/lfx && uv sync && uv run pytest tests/unit/services/deployment/test_payload_formalization.py

Notes

• No concrete provider mapper implementation is included yet; this PR establishes the shared contract foundation and enforcement scaffolding.

Summary by CodeRabbit

• New Features

  • Added deployment payload mapping and validation framework with per-provider mapper support.
  • Enhanced deployment API schemas with stronger type safety for provider-specific payloads.

• Documentation

  • Added section on payload contract ownership between API and adapter layers.
  • Expanded error handling behavior documentation.

• Tests

  • Added comprehensive tests for deployment mapper and payload schema functionality.

[coderabbitai]

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: f3c892f7-b918-4fab-b242-b263e4a75743

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

Walkthrough

Introduces a deployment payload mapping and validation framework spanning the LFX adapter layer and Langflow API. Adds payload slot primitives for validation, deployment mapper registries with provider-specific overrides, and generic-typed schemas enabling provider-specific payload handling across adapter and API boundaries.

Changes

Cohort / File(s)	Summary
Secrets baseline update .secrets.baseline	Updated timestamp and adjusted line numbers for secret keyword entries in test files.
Payload primitives and core infrastructure src/lfx/src/lfx/services/adapters/payload.py, src/lfx/src/lfx/services/adapters/__init__.py	New AdapterPayloadValidationError exception, PayloadSlot[T] generic validator wrapping Pydantic models, and ProviderPayloadSchemas registry base. Exports these primitives from adapters module.
Deployment payload taxonomy src/lfx/src/lfx/services/adapters/deployment/payloads.py, src/lfx/src/lfx/services/adapters/deployment/__init__.py, src/lfx/src/lfx/services/adapters/deployment/base.py	Introduces TypeVars for deployment payload shapes (DeploymentSpec, Config, Update, ExecutionInput, etc.), frozen DeploymentPayloadFields/DeploymentPayloadSchemas dataclasses defining canonical slot registry, and adds payload_schemas ClassVar to BaseDeploymentService.
Deployment API mapper layer src/backend/base/langflow/api/v1/mappers/__init__.py, src/backend/base/langflow/api/v1/mappers/deployments/__init__.py, src/backend/base/langflow/api/v1/mappers/deployments/base.py	New mapper infrastructure: BaseDeploymentMapper with resolve_* inbound and shape_* outbound methods performing optional payload validation via slots, DeploymentApiPayloads frozen dataclass, and DeploymentMapperRegistry for per-provider mapper overrides with default fallback.
Deployment schema generics refactoring src/lfx/src/lfx/services/adapters/deployment/schema.py	Replaces loose ProviderPayload typing with strongly-typed Generic classes parametrized by TypeVars (T_DeploymentSpec, T_DeploymentConfig, T_ProviderResult, etc.). Updates ProviderDataModel, ProviderResultModel, ProviderSpecModel, BaseDeploymentData, and all list/result types to carry provider-specific payloads via generics.
Tests for payload system src/backend/tests/unit/api/v1/test_deployment_mapper_base.py, src/backend/tests/unit/api/v1/test_deployment_schemas.py, src/lfx/tests/unit/services/deployment/test_payload_formalization.py	Validates BaseDeploymentMapper passthrough/validation behavior, DeploymentMapperRegistry registration and defaults, slot parse/dump round-trips, generic parametrization across schema types, and error handling via AdapterPayloadValidationError.
Documentation src/lfx/PLUGGABLE_SERVICES.md	Added "Payload Contract Ownership" section detailing adapter vs. API layer payload ownership, shared LFX slot primitives, and deployment-specific examples. Expanded error handling documentation with entry point, TOML, and configuration behavior.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

🚥 Pre-merge checks | ✅ 5 | ❌ 2

❌ Failed checks (2 warnings)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 11.54% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.
Test Quality And Coverage	⚠️ Warning	Test quality has significant gaps: inadequate coverage (2 new methods despite major schema changes), smoke tests lack behavior validation, low assertion density (73 across 28 tests), security vulnerability unfixed in AdapterPayloadValidationError message leaking secrets to logs, and insufficient AsyncSession testing.	Fix security vulnerability by removing {error} from AdapterPayloadValidationError message. Expand test_deployment_schemas.py with comprehensive error case tests. Replace smoke tests with behavior-validation tests. Add integration tests with real AsyncSession mocks and edge case testing for malformed payloads.

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The PR title accurately summarizes the main change: unifying payload passthrough from the API layer to the adapter layer for deployments, which is the primary focus of this comprehensive PR.
Test Coverage For New Implementations	✅ Passed	The PR includes comprehensive test coverage with three test files (189+221+27=437 new lines) corresponding to major implementations (payload.py, payloads.py, base.py mappers). Test-to-code ratio of ~1.65:1 demonstrates substantial test coverage following proper Python naming conventions.
Test File Naming And Structure	✅ Passed	All test files follow pytest naming conventions, are located in appropriate directories, have descriptive test names, include proper markers and parametrization, and provide comprehensive coverage of positive, negative, and edge case scenarios.
Excessive Mock Usage Warning	✅ Passed	Three new test files demonstrate excellent test design with zero use of mock objects, instantiating real objects and performing direct assertions.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch deployment-schema-unify

📝 Coding Plan

• Generate coding plan for human review comments

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Tip

You can customize the high-level summary generated by CodeRabbit.

Configure the reviews.high_level_summary_instructions setting to provide custom instructions for generating the high-level summary.

[github-actions]

Frontend Unit Test Coverage Report

Coverage Summary

Lines	Statements	Branches	Functions
	24.17% (8626/35678)	16.93% (4757/28093)	16.91% (1264/7474)

Unit Test Results

Tests	Skipped	Failures	Errors	Time
2779	0 💤	0 ❌	0 🔥	48.544s ⏱️

[codecov]

Codecov Report

❌ Patch coverage is 98.97959% with 2 lines in your changes missing coverage. Please review.
⚠️ Please upload report for BASE (release-1.9.0@37cf0a1). Learn more about missing BASE report.

Files with missing lines	Patch %	Lines
...lfx/src/lfx/services/adapters/deployment/schema.py	95.23%	1 Missing and 1 partial ⚠️

Additional details and impacted files

@@               Coverage Diff                @@
##             release-1.9.0   #12190   +/-   ##
================================================
  Coverage                 ?   38.61%           
================================================
  Files                    ?     1633           
  Lines                    ?    80621           
  Branches                 ?    12155           
================================================
  Hits                     ?    31130           
  Misses                   ?    47739           
  Partials                 ?     1752           

Flag	Coverage Δ
backend	57.44% <100.00%> (?)
frontend	21.59% <ø> (?)
lfx	44.65% <98.56%> (?)

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
...d/base/langflow/api/v1/mappers/deployments/base.py	100.00% <100.00%> (ø)
...c/lfx/src/lfx/services/adapters/deployment/base.py	100.00% <100.00%> (ø)
...x/src/lfx/services/adapters/deployment/payloads.py	100.00% <100.00%> (ø)
...fx/src/lfx/services/adapters/deployment/service.py	100.00% <ø> (ø)
src/lfx/src/lfx/services/adapters/payload.py	100.00% <100.00%> (ø)
src/lfx/src/lfx/services/interfaces.py	100.00% <ø> (ø)
...lfx/src/lfx/services/adapters/deployment/schema.py	94.66% <95.23%> (ø)

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[coderabbitai]

Actionable comments posted: 2

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

src/lfx/src/lfx/services/adapters/deployment/schema.py (2)

187-197: ⚠️ Potential issue | 🟠 Major

These three payload-bearing models are missing Generic inheritance, breaking type specialization.

DeploymentConfig, DeploymentUpdate, and ExecutionCreate use unbound type variables (T_DeploymentConfig, T_DeploymentUpdate, T_ExecutionInput) in field annotations but inherit plain BaseModel instead of Generic. This prevents callers from specializing these models with concrete types and violates the typing pattern established elsewhere in the file (e.g., ProviderResultModel, ProviderDataModel).

Fix

-class DeploymentConfig(BaseModel):
+class DeploymentConfig(BaseModel, Generic[T_DeploymentConfig]):
@@
-class DeploymentUpdate(BaseModel):
+class DeploymentUpdate(BaseModel, Generic[T_DeploymentUpdate]):
@@
-class ExecutionCreate(BaseModel):
+class ExecutionCreate(BaseModel, Generic[T_ExecutionInput]):

Also applies to: 490-499, 535-543

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/services/adapters/deployment/schema.py` around lines 187 -
197, The three Pydantic models (DeploymentConfig, DeploymentUpdate,
ExecutionCreate) are using unbound type variables (T_DeploymentConfig,
T_DeploymentUpdate, T_ExecutionInput) in field annotations but currently inherit
only BaseModel; update each class signature to inherit Generic with the matching
type variable (e.g., class DeploymentConfig(BaseModel,
Generic[T_DeploymentConfig]) and similarly for DeploymentUpdate and
ExecutionCreate) and ensure Generic is imported from typing so the models can be
specialized with concrete types consistent with the pattern used by
ProviderResultModel/ProviderDataModel.

---

313-324: ⚠️ Potential issue | 🟠 Major

DeploymentCreateResult[_T] leaves provider_result untyped due to multi-inheritance.

The test assertion at lines 187-190 confirms that provider_result resolves to dict instead of the type parameter. When DeploymentCreateResult[_ResultModel] is instantiated, only T_DeploymentCreateResult binds to _ResultModel, while T_DeploymentSpec (from the inherited BaseDeploymentData → ProviderSpecModel[T_DeploymentSpec]) remains unbound and defaults to AdapterPayload, causing the provider_result field to lose its type parameterization.

This breaks the typed outbound contract. Compare with DeploymentOperationResult[_ResultModel], which inherits only from ProviderResultModel[T_DeploymentOperationResult] and correctly types provider_result as _ResultModel.

Resolve by either pinning T_DeploymentSpec to AdapterPayload explicitly in DeploymentCreateResult, or exposing both type parameters separately so callers can parameterize both the spec and result types independently.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/services/adapters/deployment/schema.py` around lines 313 -
324, DeploymentCreateResult currently leaves the spec type unbound so
provider_result becomes untyped; fix by binding the spec type when inheriting
BaseDeploymentData so both type variables are resolved—i.e., change the class
inheritance so DeploymentCreateResult inherits from
BaseDeploymentData[AdapterPayload] and
ProviderResultModel[T_DeploymentCreateResult] (or alternatively expose two
generics on DeploymentCreateResult so callers can supply both T_DeploymentSpec
and T_DeploymentCreateResult), ensuring symbols to update are
DeploymentCreateResult, BaseDeploymentData, ProviderResultModel,
T_DeploymentSpec, T_DeploymentCreateResult, and AdapterPayload.

🧹 Nitpick comments (2)

src/backend/tests/unit/api/v1/test_deployment_schemas.py (1)

199-222: Add strict-wrapper negative tests for unknown top-level fields.

These additions validate passthrough, but they don’t yet assert strict-wrapper rejection behavior for extra inputs on the same request surfaces.

🧪 Suggested test additions

 class TestSharedKernelProviderPayloadCompatibility:
@@
     def test_config_create_accepts_provider_config_dict_through_strict_wrapper(self):
         payload = DeploymentConfigCreate(
@@
         assert payload.raw_payload is not None
         assert payload.raw_payload.provider_config == {"timeout_s": 30, "flags": {"dry_run": True}}
+
+    def test_create_request_rejects_unknown_top_level_spec_fields(self):
+        with pytest.raises(ValidationError, match="Extra inputs"):
+            DeploymentCreateRequest(
+                provider_id=uuid4(),
+                spec={
+                    "name": "deployment",
+                    "description": "",
+                    "type": "agent",
+                    "provider_spec": {"region": "us-east-1"},
+                    "unknown_field": "x",
+                },
+            )
+
+    def test_config_create_rejects_unknown_top_level_raw_payload_fields(self):
+        with pytest.raises(ValidationError, match="Extra inputs"):
+            DeploymentConfigCreate(
+                raw_payload={
+                    "name": "cfg",
+                    "description": "cfg-desc",
+                    "provider_config": {"timeout_s": 30},
+                    "unknown_field": "x",
+                }
+            )

As per coding guidelines: "Test both sync and async code paths, mock external dependencies appropriately, test error handling and edge cases, validate input/output behavior."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/backend/tests/unit/api/v1/test_deployment_schemas.py` around lines 199 -
222, Add negative tests in TestSharedKernelProviderPayloadCompatibility that
assert the strict-wrapper rejects unknown top-level fields: add a test (e.g.,
test_create_request_rejects_unknown_top_level_field) that passes a spec
containing an extra unknown key alongside provider_spec to
DeploymentCreateRequest and asserts a pydantic.ValidationError is raised; and
add another test (e.g., test_config_create_rejects_unknown_top_level_field) that
passes raw_payload with an extra unknown top-level key to DeploymentConfigCreate
and asserts pydantic.ValidationError is raised. Use
pytest.raises(pydantic.ValidationError) to verify the strict-wrapper rejection
for the symbols DeploymentCreateRequest and DeploymentConfigCreate (and their
spec/raw_payload attributes).

src/backend/tests/unit/api/v1/test_deployment_mapper_base.py (1)

47-55: Add one configured outbound-slot case to this file.

All of the shape_* assertions currently run against BaseDeploymentMapper() with no outbound slots configured, so a shaper that ignores api_payloads.*_result / api_payloads.*_data would still pass. Please add at least one typed outbound slot and one invalid-payload assertion to cover the new contract end to end.

Also applies to: 144-162

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/backend/tests/unit/api/v1/test_deployment_mapper_base.py` around lines 47
- 55, The tests only exercise BaseDeploymentMapper with no outbound slots
configured (api_payloads as constructed), so add a case that configures at least
one outbound PayloadSlot (e.g., set api_payloads.deployment_update_outbound =
PayloadSlot(_ApiUpdate) or similar) and instantiate the mapper with that
outbound slot; then add a shape_* assertion that checks the mapper validates
outbound payload types (use the existing shape_* helpers to assert the correct
shaped outbound result) and include an invalid-payload assertion that supplies a
deliberately malformed payload for that outbound slot and asserts the mapper
raises/returns the expected validation error; update both the existing block
around api_payloads and the mirrored block at lines 144-162 to include the new
outbound-slot configuration and invalid-payload assertion so the contract is
covered end-to-end.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/lfx/src/lfx/services/adapters/deployment/payloads.py`:
- Around line 11-28: The TypeVars T_DeploymentSpec...T_ListParamsPayload are
declared with default=AdapterPayload which conflicts with PayloadSlot (expects
T_Model bound=BaseModel) and prevents class-level parameterization; fix by
replacing those TypeVars used in PayloadSlot fields with BaseModel-bound
TypeVars (e.g., change T_DeploymentSpec = TypeVar("T_DeploymentSpec",
bound=BaseModel) etc.) or alternatively create a separate set of TypeVars for
model payloads (e.g., T_DeploymentSpecModel bound=BaseModel) while keeping the
adapter/unbounded TypeVars for schema usage, and then update
DeploymentPayloadFields to inherit Generic[...] with the appropriate TypeVar
names and adjust any schema.py usage to accept the new bound TypeVars.

In `@src/lfx/src/lfx/services/adapters/payload.py`:
- Around line 34-37: The exception currently includes the raw ValidationError
string in the public message which can leak input fragments; change the __init__
of the payload exception (the __init__(*, model_name: str, error:
ValidationError) method that sets self.model_name and self.error) to call
super().__init__ with a sanitized message that does NOT include the error
details (e.g. f"Invalid payload for '{model_name}'") while still assigning
self.error = error so the original ValidationError is retained on the instance
for internal debugging.

---

Outside diff comments:
In `@src/lfx/src/lfx/services/adapters/deployment/schema.py`:
- Around line 187-197: The three Pydantic models (DeploymentConfig,
DeploymentUpdate, ExecutionCreate) are using unbound type variables
(T_DeploymentConfig, T_DeploymentUpdate, T_ExecutionInput) in field annotations
but currently inherit only BaseModel; update each class signature to inherit
Generic with the matching type variable (e.g., class DeploymentConfig(BaseModel,
Generic[T_DeploymentConfig]) and similarly for DeploymentUpdate and
ExecutionCreate) and ensure Generic is imported from typing so the models can be
specialized with concrete types consistent with the pattern used by
ProviderResultModel/ProviderDataModel.
- Around line 313-324: DeploymentCreateResult currently leaves the spec type
unbound so provider_result becomes untyped; fix by binding the spec type when
inheriting BaseDeploymentData so both type variables are resolved—i.e., change
the class inheritance so DeploymentCreateResult inherits from
BaseDeploymentData[AdapterPayload] and
ProviderResultModel[T_DeploymentCreateResult] (or alternatively expose two
generics on DeploymentCreateResult so callers can supply both T_DeploymentSpec
and T_DeploymentCreateResult), ensuring symbols to update are
DeploymentCreateResult, BaseDeploymentData, ProviderResultModel,
T_DeploymentSpec, T_DeploymentCreateResult, and AdapterPayload.

---

Nitpick comments:
In `@src/backend/tests/unit/api/v1/test_deployment_mapper_base.py`:
- Around line 47-55: The tests only exercise BaseDeploymentMapper with no
outbound slots configured (api_payloads as constructed), so add a case that
configures at least one outbound PayloadSlot (e.g., set
api_payloads.deployment_update_outbound = PayloadSlot(_ApiUpdate) or similar)
and instantiate the mapper with that outbound slot; then add a shape_* assertion
that checks the mapper validates outbound payload types (use the existing
shape_* helpers to assert the correct shaped outbound result) and include an
invalid-payload assertion that supplies a deliberately malformed payload for
that outbound slot and asserts the mapper raises/returns the expected validation
error; update both the existing block around api_payloads and the mirrored block
at lines 144-162 to include the new outbound-slot configuration and
invalid-payload assertion so the contract is covered end-to-end.

In `@src/backend/tests/unit/api/v1/test_deployment_schemas.py`:
- Around line 199-222: Add negative tests in
TestSharedKernelProviderPayloadCompatibility that assert the strict-wrapper
rejects unknown top-level fields: add a test (e.g.,
test_create_request_rejects_unknown_top_level_field) that passes a spec
containing an extra unknown key alongside provider_spec to
DeploymentCreateRequest and asserts a pydantic.ValidationError is raised; and
add another test (e.g., test_config_create_rejects_unknown_top_level_field) that
passes raw_payload with an extra unknown top-level key to DeploymentConfigCreate
and asserts pydantic.ValidationError is raised. Use
pytest.raises(pydantic.ValidationError) to verify the strict-wrapper rejection
for the symbols DeploymentCreateRequest and DeploymentConfigCreate (and their
spec/raw_payload attributes).

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: e07471ac-7567-4485-905f-56d00e8f9087

📥 Commits

Reviewing files that changed from the base of the PR and between 1dafc75 and f9cbb0e.

📒 Files selected for processing (14)

• .secrets.baseline
• src/backend/base/langflow/api/v1/mappers/__init__.py
• src/backend/base/langflow/api/v1/mappers/deployments/__init__.py
• src/backend/base/langflow/api/v1/mappers/deployments/base.py
• src/backend/tests/unit/api/v1/test_deployment_mapper_base.py
• src/backend/tests/unit/api/v1/test_deployment_schemas.py
• src/lfx/PLUGGABLE_SERVICES.md
• src/lfx/src/lfx/services/adapters/__init__.py
• src/lfx/src/lfx/services/adapters/deployment/__init__.py
• src/lfx/src/lfx/services/adapters/deployment/base.py
• src/lfx/src/lfx/services/adapters/deployment/payloads.py
• src/lfx/src/lfx/services/adapters/deployment/schema.py
• src/lfx/src/lfx/services/adapters/payload.py
• src/lfx/tests/unit/services/deployment/test_payload_formalization.py