b1sl-python 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

b1sl/b1sl/__init__.py

@@ -5,6 +5,7 @@ b1sl.b1sl — SDK for SAP B1 Service Layer (OData).
 import logging
 import warnings
 
+from b1sl.b1sl import entities
 from b1sl.b1sl.async_client import AsyncB1Client
 from b1sl.b1sl.async_rest_adapter import AsyncRestAdapter
 from b1sl.b1sl.base_adapter import HookContext, ObservabilityConfig
@@ -17,6 +18,11 @@ from b1sl.b1sl.resources.async_base import AsyncGenericResource
 from b1sl.b1sl.resources.base import GenericResource, ODataQuery
 from b1sl.b1sl.rest_adapter import RestAdapter
 
+try:
+    from b1sl.b1sl import fields  # type: ignore
+except ImportError:
+    fields = None  # type: ignore
+
 try:
     from pydantic import ArbitraryTypeWarning
 
@@ -27,16 +33,6 @@ except ImportError:
 # Standard library pattern: prevent "No handlers could be found"
 logging.getLogger("b1sl").addHandler(logging.NullHandler())
 
-try:
-    from b1sl.b1sl import entities  # type: ignore
-except ImportError:
-    entities = None  # type: ignore # Before code generation
-
-try:
-    from b1sl.b1sl import fields  # type: ignore
-except ImportError:
-    fields = None  # type: ignore
-
 __all__ = [
     "AsyncB1Client",
     "B1Client",

b1sl/b1sl/adapter_protocol.py

@@ -12,17 +12,17 @@ class RestAdapterProtocol(Protocol):
     """
 
     def get(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def post(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def patch(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def delete(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...

b1sl/b1sl/async_client.py

@@ -8,17 +8,13 @@ from b1sl.b1sl.base_adapter import ObservabilityConfig
 from b1sl.b1sl.config import B1Config
 
 if TYPE_CHECKING:
+    from b1sl.b1sl.batch.client import BatchClient
     from b1sl.b1sl.models._generated.entities.businesspartners import (
         Activity,
         BusinessPartner,
     )
-    from b1sl.b1sl.models._generated.entities.finance import JournalEntry
-    from b1sl.b1sl.models._generated.entities.general import Document, Payment, User
-
-    # Models for typing convenience aliases
+    from b1sl.b1sl.models._generated.entities.general import Document
     from b1sl.b1sl.models._generated.entities.inventory import Item
-    from b1sl.b1sl.models._generated.entities.production import ProductionOrder
-    from b1sl.b1sl.models._generated.entities.sales import ServiceCall
     from b1sl.b1sl.models.base import B1Model
     from b1sl.b1sl.resources.async_base import AsyncGenericResource
     from b1sl.b1sl.resources.udo import AsyncUDOResource
@@ -35,6 +31,12 @@ class AsyncB1Client:
     AI Role: Recommended for modern web apps.
     Use 'async with AsyncB1Client(config) as b1:' to ensure session cleanup.
 
+    Concurrency-Elite Aliases (Elite Citizens):
+        Only entities with ETag support are exposed as direct properties.
+        This ensures state-safety and clear architectural boundaries.
+        Objects without ETag support must be accessed via 'get_resource()'
+        or 'udo()'.
+
     Example:
         async with AsyncB1Client(config) as b1:
             item = await b1.items.get("A0001")
@@ -59,9 +61,10 @@ class AsyncB1Client:
             version (str): API version (defaults to 'v2').
             session_id (str, optional): An existing B1SESSION cookie to reuse.
         """
+        self._logger = logger or logging.getLogger(f"b1sl.{self.__class__.__name__}")
         self._adapter = AsyncRestAdapter(
             config,
-            logger=logger,
+            logger=self._logger,
             version=version,
             observability=observability,
             session_id=session_id,
@@ -72,9 +75,6 @@ class AsyncB1Client:
     def session_id(self) -> str | None:
         """
         Retrieves the current SAP session ID.
-
-        Returns:
-            str: B1SESSION cookie value or None.
         """
         return self._adapter.session_id
 
@@ -96,10 +96,33 @@ class AsyncB1Client:
 
         Note:
             Use ``with`` (sync CM), **not** ``async with``, even in async code.
-            This is correct Python — the CM guards a state variable, not I/O.
         """
         return self._adapter.dry_run(enabled)
 
+    def with_schema(self, name: str):
+        """
+        Context manager to temporarily set the B1S-Schema header
+        **for the current asyncio.Task only** (task-safe via ContextVar).
+        
+        Usage::
+        
+            async with AsyncB1Client(config) as b1:
+                async with b1.with_schema("demo.schema"):
+                    await b1.items.get("A0001")
+        """
+        return self._adapter.with_schema(name)
+
+    def batch(self) -> BatchClient:
+        """
+        Returns a context manager that groups multiple resource operations
+        into a single OData $batch HTTP request.
+
+        Use this for high-concurrency scenarios (bulk GETs) or transactional
+        integrity (atomic ChangeSets). See :class:`BatchClient` for details.
+        """
+        from b1sl.b1sl.batch.client import BatchClient
+        return BatchClient(self)
+
     async def connect(self) -> None:
         """
         Initializes the underlying HTTP client and logs in.
@@ -117,7 +140,6 @@ class AsyncB1Client:
     async def __aenter__(self) -> AsyncB1Client:
         """
         Entry point for the async context manager.
-        Logins and prepares the session.
         """
         await self.connect()
         return self
@@ -125,7 +147,6 @@ class AsyncB1Client:
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """
         Exit point for the async context manager.
-        Ensures logout and connection pool cleanup.
         """
         await self.aclose()
 
@@ -149,145 +170,194 @@ class AsyncB1Client:
         return DynamicResource(self._adapter)
 
     # --------------------------------------------------------------------------
-    # Thin Aliases for common endpoints (Developer Experience)
+    # Concurrency-Elite Aliases (First-Class Citizens with ETag support)
     # --------------------------------------------------------------------------
 
+    # --- Master Data ---
+
     @property
     def items(self) -> "AsyncGenericResource[Item]":
-        """Convenience alias for get_resource(Item, 'Items')."""
-        from b1sl.b1sl.models._generated.entities.inventory import Item
-
+        """Access the 'Items' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities import Item
         return self.get_resource(Item, "Items")
 
     @property
     def business_partners(self) -> "AsyncGenericResource[BusinessPartner]":
-        """Convenience alias for get_resource(BusinessPartner, 'BusinessPartners')."""
-        from b1sl.b1sl.models._generated.entities.businesspartners import (
-            BusinessPartner,
-        )
-
+        """Access the 'BusinessPartners' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities import BusinessPartner
         return self.get_resource(BusinessPartner, "BusinessPartners")
 
     @property
-    def invoices(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'Invoices')."""
-        from b1sl.b1sl.models._generated.entities.general import Document
+    def activities(self) -> "AsyncGenericResource[Activity]":
+        """Access the 'Activities' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities import Activity
+        return self.get_resource(Activity, "Activities")
 
-        return self.get_resource(Document, "Invoices")
+    # --- Sales Documents ---
 
     @property
     def quotations(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'Quotations')."""
+        """Access the 'Quotations' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
-
         return self.get_resource(Document, "Quotations")
 
     @property
     def orders(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'Orders')."""
+        """Access the 'Orders' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
-
         return self.get_resource(Document, "Orders")
 
     @property
     def delivery_notes(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'DeliveryNotes')."""
+        """Access the 'DeliveryNotes' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
-
         return self.get_resource(Document, "DeliveryNotes")
 
     @property
-    def purchase_orders(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'PurchaseOrders')."""
+    def invoices(self) -> "AsyncGenericResource[Document]":
+        """Access the 'Invoices' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
-
-        return self.get_resource(Document, "PurchaseOrders")
+        return self.get_resource(Document, "Invoices")
 
     @property
-    def purchase_delivery_notes(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'PurchaseDeliveryNotes')."""
+    def returns(self) -> "AsyncGenericResource[Document]":
+        """Access the 'Returns' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "Returns")
 
-        return self.get_resource(Document, "PurchaseDeliveryNotes")
+    @property
+    def return_request(self) -> "AsyncGenericResource[Document]":
+        """Access the 'ReturnRequest' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "ReturnRequest")
 
     @property
-    def purchase_invoices(self) -> "AsyncGenericResource[Document]":
-        """Convenience alias for get_resource(Document, 'PurchaseInvoices')."""
+    def credit_notes(self) -> "AsyncGenericResource[Document]":
+        """Access the 'CreditNotes' entity (supports ETags)."""
         from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "CreditNotes")
 
-        return self.get_resource(Document, "PurchaseInvoices")
+    @property
+    def down_payments(self) -> "AsyncGenericResource[Document]":
+        """Access the 'DownPayments' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "DownPayments")
 
     @property
-    def incoming_payments(self) -> "AsyncGenericResource[Payment]":
-        """Convenience alias for get_resource(Payment, 'IncomingPayments')."""
-        from b1sl.b1sl.models._generated.entities.general import Payment
+    def goods_return_request(self) -> "AsyncGenericResource[Document]":
+        """Access the 'GoodsReturnRequest' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "GoodsReturnRequest")
 
-        return self.get_resource(Payment, "IncomingPayments")
+    # --- Purchasing Documents ---
 
     @property
-    def vendor_payments(self) -> "AsyncGenericResource[Payment]":
-        """Convenience alias for get_resource(Payment, 'VendorPayments')."""
-        from b1sl.b1sl.models._generated.entities.general import Payment
+    def purchase_requests(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseRequests' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseRequests")
 
-        return self.get_resource(Payment, "VendorPayments")
+    @property
+    def purchase_quotations(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseQuotations' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseQuotations")
 
     @property
-    def users(self) -> "AsyncGenericResource[User]":
-        """Convenience alias for get_resource(User, 'Users')."""
-        from b1sl.b1sl.models._generated.entities.general import User
+    def purchase_orders(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseOrders' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseOrders")
 
-        return self.get_resource(User, "Users")
+    @property
+    def purchase_delivery_notes(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseDeliveryNotes' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseDeliveryNotes")
 
-    # --- Producción & Operaciones ---
+    @property
+    def purchase_invoices(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseInvoices' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseInvoices")
 
     @property
-    def production_orders(self) -> "AsyncGenericResource[ProductionOrder]":
-        """Convenience alias for get_resource(ProductionOrder, 'ProductionOrders')."""
-        from b1sl.b1sl.models._generated.entities.production import ProductionOrder
+    def purchase_returns(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseReturns' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseReturns")
 
-        return self.get_resource(ProductionOrder, "ProductionOrders")
+    @property
+    def purchase_credit_notes(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseCreditNotes' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseCreditNotes")
+
+    @property
+    def purchase_down_payments(self) -> "AsyncGenericResource[Document]":
+        """Access the 'PurchaseDownPayments' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "PurchaseDownPayments")
 
-    # --- Contabilidad & Finanzas ---
+    # --- Inventory & Specialized ---
 
     @property
-    def journal_entries(self) -> "AsyncGenericResource[JournalEntry]":
-        """Convenience alias for get_resource(JournalEntry, 'JournalEntries')."""
-        from b1sl.b1sl.models._generated.entities.finance import JournalEntry
+    def inventory_gen_entries(self) -> "AsyncGenericResource[Document]":
+        """Access the 'InventoryGenEntries' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "InventoryGenEntries")
 
-        return self.get_resource(JournalEntry, "JournalEntries")
+    @property
+    def inventory_gen_exits(self) -> "AsyncGenericResource[Document]":
+        """Access the 'InventoryGenExits' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "InventoryGenExits")
 
-    # --- Servicio Post-Venta ---
+    @property
+    def drafts(self) -> "AsyncGenericResource[Document]":
+        """Access the 'Drafts' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "Drafts")
 
     @property
-    def service_calls(self) -> "AsyncGenericResource[ServiceCall]":
-        """Convenience alias for get_resource(ServiceCall, 'ServiceCalls')."""
-        from b1sl.b1sl.models._generated.entities.sales import ServiceCall
+    def additional_expenses(self) -> "AsyncGenericResource[B1Model]":
+        """Access the 'AdditionalExpenses' entity (supports ETags)."""
+        from b1sl.b1sl.models.base import B1Model
+        return self.get_resource(B1Model, "AdditionalExpenses")
 
-        return self.get_resource(ServiceCall, "ServiceCalls")
+    # --- Correction marketing documents ---
 
-    # --- CRM & Seguimiento ---
+    @property
+    def correction_invoice(self) -> "AsyncGenericResource[Document]":
+        """Access the 'CorrectionInvoice' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "CorrectionInvoice")
 
     @property
-    def activities(self) -> "AsyncGenericResource[Activity]":
-        """Convenience alias for get_resource(Activity, 'Activities')."""
-        from b1sl.b1sl.models._generated.entities.businesspartners import Activity
+    def correction_invoice_reversal(self) -> "AsyncGenericResource[Document]":
+        """Access the 'CorrectionInvoiceReversal' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "CorrectionInvoiceReversal")
 
-        return self.get_resource(Activity, "Activities")
+    @property
+    def correction_purchase_invoice(self) -> "AsyncGenericResource[Document]":
+        """Access the 'CorrectionPurchaseInvoice' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "CorrectionPurchaseInvoice")
+
+    @property
+    def correction_purchase_invoice_reversal(self) -> "AsyncGenericResource[Document]":
+        """Access the 'CorrectionPurchaseInvoiceReversal' entity (supports ETags)."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+        return self.get_resource(Document, "CorrectionPurchaseInvoiceReversal")
 
     def udo(self, table_name: str) -> "AsyncUDOResource":
         """
         Asynchronously access a User Defined Object (UDO) or User Table.
 
         AI Role: Dynamic accessor for entities not pre-defined in the client.
-
-        Args:
-            table_name (str): The UDO name in SAP B1.
-
-        Returns:
-            AsyncUDOResource: A resource object bound to the UDO.
         """
         from b1sl.b1sl.resources.udo import AsyncUDOResource
-
         return AsyncUDOResource(adapter=self._adapter, table_name=table_name)
 
 

b1sl/b1sl/async_rest_adapter.py

@@ -215,6 +215,7 @@ class AsyncRestAdapter(BaseRestAdapter):
         endpoint: str,
         ep_params=None,
         data=None,
+        headers: dict | None = None,
         _is_login: bool = False,
         _retry_once=True,
     ) -> Result:
@@ -240,7 +241,9 @@ class AsyncRestAdapter(BaseRestAdapter):
 
         try:
             # ── ETag: inject If-None-Match (GET) or If-Match (PATCH/DELETE/POST) ──
-            headers = self._build_headers(http_method, endpoint_path)
+            req_headers = self._build_headers(http_method, endpoint_path)
+            if headers:
+                req_headers.update(headers)
 
             if self._dry_run_active and http_method in {"POST", "PATCH", "DELETE"} and not _is_login:
                 self._logger.info(f"[{req_id}] [DRY RUN] Intercepting {http_method} {full_url}")
@@ -250,7 +253,7 @@ class AsyncRestAdapter(BaseRestAdapter):
             else:
                 response = await self._client.request(
                     method=http_method, url=full_url, params=ep_params, json=data,
-                    headers=headers,
+                    headers=req_headers,
                 )
 
             if response.status_code == 401 and _retry_once and not _is_login:
@@ -259,7 +262,7 @@ class AsyncRestAdapter(BaseRestAdapter):
                 # Recursive call will handle its own finally block,
                 # but we need to return here to avoid double-logging/hooking.
                 return await self._do(
-                    http_method, endpoint, ep_params, data, _is_login, _retry_once=False
+                    http_method, endpoint, ep_params, data, headers, _is_login, _retry_once=False
                 )
 
             response.raise_for_status()
@@ -275,7 +278,10 @@ class AsyncRestAdapter(BaseRestAdapter):
             self._raise_if_concurrency_error(
                 e.response.status_code, sap_code, sap_msg, endpoint_path, body
             )
-            raise B1Exception(f"SAP Error {sap_code}: {sap_msg}") from e
+            
+            # Use specialized exception based on status code if available
+            exc_cls = _HTTP_STATUS_TO_EXC.get(e.response.status_code, B1Exception)
+            raise exc_cls(f"SAP Error {sap_code}: {sap_msg}", details=body) from e
         except Exception as e:
             exc_captured = e
             raise B1Exception(f"Request failed: {e}") from e
@@ -290,6 +296,10 @@ class AsyncRestAdapter(BaseRestAdapter):
                 duration_ms = (time.perf_counter() - start_time) * 1000
                 status_code = response.status_code if response is not None else None
 
+                # Prepare context extras
+                context_extras = dict(self._obs.context_extras)
+                context_extras["is_dry_run"] = self._dry_run_active and http_method in {"POST", "PATCH", "DELETE"} and not _is_login
+
                 ctx = HookContext(
                     req_id=req_id,
                     http_method=http_method,
@@ -300,7 +310,9 @@ class AsyncRestAdapter(BaseRestAdapter):
                     user=self._username,
                     status_code=status_code,
                     duration_ms=duration_ms,
-                    extra=dict(self._obs.context_extras),
+                    payload=log_data if http_method in {"POST", "PATCH"} else None,
+                    if_match=req_headers.get("If-Match"),
+                    extra=context_extras,
                     exc=exc_captured,
                 )
 
@@ -338,18 +350,33 @@ class AsyncRestAdapter(BaseRestAdapter):
                 f"HTTP Error {response.status_code if response else 'Unknown'}"
             )
 
-    async def get(self, endpoint, ep_params=None, data=None):
+    async def get(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous GET request."""
-        return await self._do("GET", endpoint, ep_params, data)
+        return await self._do("GET", endpoint, ep_params, data, headers=headers)
 
-    async def post(self, endpoint, ep_params=None, data=None):
+    async def post(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous POST request."""
-        return await self._do("POST", endpoint, ep_params, data)
+        return await self._do("POST", endpoint, ep_params, data, headers=headers)
 
-    async def patch(self, endpoint, ep_params=None, data=None):
+    async def patch(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous PATCH request."""
-        return await self._do("PATCH", endpoint, ep_params, data)
+        return await self._do("PATCH", endpoint, ep_params, data, headers=headers)
 
-    async def delete(self, endpoint, ep_params=None, data=None):
+    async def delete(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous DELETE request."""
-        return await self._do("DELETE", endpoint, ep_params, data)
+        return await self._do("DELETE", endpoint, ep_params, data, headers=headers)
+
+    async def post_batch(self, body: str, headers: dict) -> httpx.Response:
+        """
+        Special method to send raw multipart content for $batch operations.
+        """
+        await self.ensure_session()
+        if not self._client:
+             raise B1Exception("AsyncRestAdapter not initialized.")
+        
+        url = f"{self.raw_base_url}/$batch"
+        # Combine with session headers if necessary,
+        # although httpx already handles them via cookies.
+        response = await self._client.post(url, content=body, headers=headers)
+        response.raise_for_status()
+        return response

b1sl/b1sl/base_adapter.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from b1sl.b1sl.config import B1Config
 import asyncio
+import json
 import logging
 import uuid
 from collections import OrderedDict
@@ -56,6 +57,8 @@ class HookContext:
     user: str
     status_code: Optional[int]  # None if network exception occurred
     duration_ms: float
+    payload: Optional[Dict[str, Any]] = None  # Redacted request body
+    if_match: Optional[str] = None  # ETag sent in If-Match
     extra: Dict[str, Any] = field(default_factory=dict)
     exc: Optional[Exception] = None
 
@@ -75,6 +78,8 @@ class HookContext:
             "user": self.user,
             "status_code": self.status_code,
             "duration_ms": round(self.duration_ms, 3),
+            "payload": self.payload,
+            "if_match": self.if_match,
             **self.extra,
         }
 
@@ -180,12 +185,20 @@ class BaseRestAdapter:
         self._dry_run_var: ContextVar[bool] = ContextVar(
             f"dry_run_{id(self)}", default=config.dry_run
         )
+        self._b1s_schema_var: ContextVar[str | None] = ContextVar(
+            f"b1s_schema_{id(self)}", default=config.b1s_schema
+        )
 
     @property
     def _dry_run_active(self) -> bool:
         """Returns the current effective dry_run state for this task/thread."""
         return self._dry_run_var.get()
 
+    @property
+    def _schema_active(self) -> str | None:
+        """Returns the current effective schema state for this task/thread."""
+        return self._b1s_schema_var.get()
+
     @contextmanager
     def dry_run(self, enabled: bool = True):
         """
@@ -215,6 +228,28 @@ class BaseRestAdapter:
         finally:
             self._dry_run_var.reset(token)
 
+    @contextmanager
+    def with_schema(self, schema: str | None):
+        """
+        Context manager to temporarily override the B1S-Schema header
+        **for the current asyncio task / thread only**.
+
+        Usage::
+
+            # Use a specific schema for this block
+            with client.with_schema("demo.schema"):
+                await client.items.get("A0001")
+
+        Note:
+            Use ``with``, not ``async with`` — the context manager is
+            synchronous even in async code, which is correct and idiomatic.
+        """
+        token = self._b1s_schema_var.set(schema)
+        try:
+            yield
+        finally:
+            self._b1s_schema_var.reset(token)
+
     @classmethod
     def from_config(
         cls,
@@ -323,6 +358,10 @@ class BaseRestAdapter:
             # POST covers OData Actions (e.g. /BusinessPartners('C20000')/Cancel)
             headers["If-Match"] = cached_etag
 
+        active_schema = self._schema_active
+        if active_schema:
+            headers["B1S-Schema"] = active_schema
+
         if extra_headers:
             headers.update(extra_headers)
         return headers
@@ -390,6 +429,19 @@ class BaseRestAdapter:
 
         clean_endpoint = ctx.endpoint.lstrip("/")
         msg = f"[{ctx.req_id}][{ctx.user}] [{ctx.http_method} /{clean_endpoint}]{status_label} ({ctx.duration_ms:.1f}ms){slow_label}"
+        
+        # In Dry Run or Debug mode, we might want to see the body in the main message
+        meta_info = []
+        if ctx.if_match:
+            meta_info.append(f"ETag: {ctx.if_match}")
+            
+        if ctx.extra.get("is_dry_run") and ctx.payload:
+            payload_str = json.dumps(ctx.payload)
+            meta_info.append(f"Body: {payload_str}")
+            
+        if meta_info:
+            msg += f" | {' | '.join(meta_info)}"
+            
         self._logger.log(level, msg, extra=ctx.to_log_extra())
 
     # ── URL Helpers ──────────────────────────────────────────────────────── #
@@ -419,7 +471,13 @@ class BaseRestAdapter:
             return "unknown", http_fallback
 
         error_node = body.get("error")
-        if not error_node or not isinstance(error_node, dict):
+        if not error_node:
+            return "unknown", http_fallback
+
+        if isinstance(error_node, str):
+            return "unknown", error_node
+
+        if not isinstance(error_node, dict):
             return "unknown", http_fallback
 
         sap_code = str(error_node.get("code", "unknown"))
@@ -435,3 +493,4 @@ class BaseRestAdapter:
             sap_message = http_fallback
 
         return sap_code, sap_message
+