unique-search-proxy-core 2026.38.0.dev2__tar.gz → 2026.38.0.dev4__tar.gz

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-search-proxy-core
-Version: 2026.38.0.dev2
+Version: 2026.38.0.dev4
 Summary: Shared Pydantic types for the Unique Search Proxy API
 Author: ThePhilAz
 Author-email: ThePhilAz <rami.azouz@philico.com>
@@ -8,7 +8,7 @@ Requires-Dist: httpx>=0.28.0,<0.29
 Requires-Dist: pydantic>=2.12.5,<3.0.0
 Requires-Dist: pydantic-settings>=2.10.1,<3
 Requires-Dist: pyhumps>=3.8.0,<4
-Requires-Dist: unique-toolkit[monitoring]>=2026.38.0.dev5,<2026.38.0rc0
+Requires-Dist: unique-toolkit[monitoring]>=2026.38.0.dev18,<2026.38.0rc0
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 
@@ -224,8 +224,8 @@ from unique_search_proxy_core import (
 ## 7. Features summary
 
 - Discriminated provider configs (`engine`, `crawler` Literal discriminators)
-- **Search & agent:** `ExposableParam` policy; config-owned `request_model` / `exposed_params_model` / `merge` (`provider_query_params` is search-only)
-- **Agent:** `BingAgentConfig.request_model()` (injects `query`; excludes `output_schema`); Bing carries `market` / `setLang` / `freshness`, which are baked into the hashed agent name (`market` and `setLang` are `Literal`s over Bing's documented codes, like `BraveCountry`). All three are tagged `ui:widget: hidden`: they are not cleared for release, so the admin form does not render them
+- **Search & agent:** config-owned `request_model` / `exposed_params_model` / `merge` (`provider_query_params` is search-only); standard engines put optional provider knobs behind the `ExposableParam` policy
+- **Agent:** `BingAgentConfig.request_model()` (injects `query`; excludes `output_schema`); Bing's `market` / `freshness` are fixed admin values, never exposed to the LLM, and are baked into the hashed agent name (both are `Literal`s over Bing's documented values, like `BraveCountry`). A blank `market` falls back to the `BING_AGENT_DEFAULT_MARKET` environment variable
 - **Crawl:** `BasicConfig.request_model()` (injects `urls`); no exposable params / no merge
 - CamelCase JSON aliases on all models
 - Zero server dependencies (import-linter enforced in the client package)

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/README.md

@@ -210,8 +210,8 @@ from unique_search_proxy_core import (
 ## 7. Features summary
 
 - Discriminated provider configs (`engine`, `crawler` Literal discriminators)
-- **Search & agent:** `ExposableParam` policy; config-owned `request_model` / `exposed_params_model` / `merge` (`provider_query_params` is search-only)
-- **Agent:** `BingAgentConfig.request_model()` (injects `query`; excludes `output_schema`); Bing carries `market` / `setLang` / `freshness`, which are baked into the hashed agent name (`market` and `setLang` are `Literal`s over Bing's documented codes, like `BraveCountry`). All three are tagged `ui:widget: hidden`: they are not cleared for release, so the admin form does not render them
+- **Search & agent:** config-owned `request_model` / `exposed_params_model` / `merge` (`provider_query_params` is search-only); standard engines put optional provider knobs behind the `ExposableParam` policy
+- **Agent:** `BingAgentConfig.request_model()` (injects `query`; excludes `output_schema`); Bing's `market` / `freshness` are fixed admin values, never exposed to the LLM, and are baked into the hashed agent name (both are `Literal`s over Bing's documented values, like `BraveCountry`). A blank `market` falls back to the `BING_AGENT_DEFAULT_MARKET` environment variable
 - **Crawl:** `BasicConfig.request_model()` (injects `urls`); no exposable params / no merge
 - CamelCase JSON aliases on all models
 - Zero server dependencies (import-linter enforced in the client package)

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique-search-proxy-core"
-version = "2026.38.0.dev2"
+version = "2026.38.0.dev4"
 description = "Shared Pydantic types for the Unique Search Proxy API"
 authors = [{ name = "ThePhilAz", email = "rami.azouz@philico.com" }]
 readme = "README.md"
@@ -10,7 +10,7 @@ dependencies = [
     "pydantic>=2.12.5,<3.0.0",
     "pydantic-settings>=2.10.1,<3",
     "pyhumps>=3.8.0,<4",
-    "unique-toolkit[monitoring]>=2026.38.0.dev5,<2026.38.0rc0",
+    "unique-toolkit[monitoring]>=2026.38.0.dev18,<2026.38.0rc0",
 
 ]
 

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/unique_search_proxy_core/agent_engines/bing/enums.py

@@ -42,59 +42,5 @@ BingMarket: TypeAlias = Literal[
     "es-US",
 ]
 
-#: Languages Bing localizes its interface strings into (``setLang``).
-BingSetLang: TypeAlias = Literal[
-    "ar",
-    "eu",
-    "bn",
-    "bg",
-    "ca",
-    "zh-hans",
-    "zh-hant",
-    "hr",
-    "cs",
-    "da",
-    "nl",
-    "en",
-    "en-gb",
-    "et",
-    "fi",
-    "fr",
-    "gl",
-    "de",
-    "gu",
-    "he",
-    "hi",
-    "hu",
-    "is",
-    "it",
-    "jp",
-    "kn",
-    "ko",
-    "lv",
-    "lt",
-    "ms",
-    "ml",
-    "mr",
-    "nb",
-    "pl",
-    "pt-br",
-    "pt-pt",
-    "pa",
-    "ro",
-    "ru",
-    "sr",
-    "sk",
-    "sl",
-    "es",
-    "sv",
-    "ta",
-    "te",
-    "th",
-    "tr",
-    "uk",
-    "vi",
-]
-
 #: Named recency windows accepted by the Bing ``freshness`` knob.
 BingFreshnessPreset: TypeAlias = Literal["Day", "Week", "Month"]

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/unique_search_proxy_core/agent_engines/bing/grounding.py

@@ -24,7 +24,6 @@ class BingGroundingConfiguration:
 
     fetch_size: int
     market: str | None = None
-    set_lang: str | None = None
     freshness: str | None = None
 
     def hash_payload(self) -> str:

unique_search_proxy_core-2026.38.0.dev4/unique_search_proxy_core/agent_engines/bing/schema.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from typing import Annotated, Any, ClassVar, Literal, Mapping, get_args
+
+from pydantic import Field, GetJsonSchemaHandler, field_validator
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema
+from unique_toolkit._common.pydantic.rjsf_tags import RJSFMetaTag
+
+from unique_search_proxy_core.agent_engines.base import (
+    AgentEngineType,
+    BaseAgentEngineConfig,
+)
+from unique_search_proxy_core.agent_engines.bing.enums import (
+    BingFreshnessPreset,
+    BingMarket,
+)
+
+#: Admin-facing labels for the recency presets, whose wire values are terse.
+_FRESHNESS_PRESET_TITLES: Mapping[str, str] = {
+    "Day": "Past 24 hours",
+    "Week": "Past 7 days",
+    "Month": "Past 30 days",
+}
+
+
+def _single_dropdown(
+    property_schema: JsonSchemaValue,
+    *,
+    values: tuple[Any, ...],
+    blank_title: str,
+    titles: Mapping[Any, str] | None = None,
+) -> JsonSchemaValue:
+    """Render an optional literal as one dropdown instead of a union selector.
+
+    ``Literal[...] | None`` reaches RJSF as an ``anyOf``, drawn as a branch
+    picker wrapping a second control; a single ``oneOf`` of constants collapses
+    that into one select whose first entry is the blank value. ``titles``
+    relabels options whose wire values are not admin-facing copy.
+    """
+    schema = dict(property_schema)
+    schema.pop("anyOf", None)
+    schema["type"] = ["string", "null"]
+    schema["oneOf"] = [
+        {"const": None, "title": blank_title},
+        *(
+            {"const": value, "title": (titles or {}).get(value, value)}
+            for value in values
+        ),
+    ]
+    return schema
+
+
+class BingAgentConfig(BaseAgentEngineConfig[Literal[AgentEngineType.BING]]):
+    """Deployment + request defaults for Bing grounding via Azure AI Projects.
+
+    The grounding knobs are fixed values chosen by an admin: whatever is set
+    here applies to every search in the space and is never offered to the LLM
+    to steer per call.
+    """
+
+    _request_model_name: ClassVar[str] = "BingAgentSearchRequest"
+    _exposed_params_model_name: ClassVar[str] = "BingAgentExposedParams"
+
+    engine: Annotated[
+        Literal[AgentEngineType.BING], RJSFMetaTag.SpecialWidget.hidden()
+    ] = Field(
+        default=AgentEngineType.BING,
+        title="Agent engine",
+        description="Provider discriminator; must be `bing` for this config.",
+    )
+    fetch_size: int = Field(
+        default=5,
+        ge=1,
+        le=50,
+        description="Maximum number of Bing grounding results per query",
+    )
+    market: BingMarket | None = Field(
+        default=None,
+        title="Preferred region and language",
+        description=(
+            "Region and language Bing should favour, as `<language>-<country>`. "
+            "Examples: `de-CH`, `fr-CH`, `fr-FR`. This biases the results rather "
+            "than restricting them — sources from other regions can still "
+            "appear. If left blank, the deployment default set in the "
+            "environment variable `BING_AGENT_DEFAULT_MARKET` applies. If left "
+            "blank and the environment variable is not set, Bing may favour the "
+            "region where the underlying Microsoft Foundry resource is deployed."
+        ),
+    )
+    freshness: BingFreshnessPreset | None = Field(
+        default=None,
+        title="Only results published recently",
+        description=(
+            "Only includes results Bing discovered within the chosen timeframe, "
+            "counted back from each search. This is a hard filter and it applies "
+            "to every search in the space."
+        ),
+    )
+
+    # Spaces saved on 2026.36 hold an ExposableParam `{expose, value}` object
+    # under `market` and `freshness`, where these fields now expect a scalar.
+    # node-chat data migration `20260908120000_drop_bing_grounding_exposable_params`
+    # deletes those keys; the validator below reads the same shape as unset for
+    # any row the migration has not reached, because an invalid tool config
+    # silently disables the whole tool instead of reporting the problem.
+    @field_validator("market", "freshness", mode="before")
+    @classmethod
+    def _coerce_unset(cls, value: Any) -> Any:
+        """Read a cleared control, or a retired `{expose, value}` object, as unset."""
+        if isinstance(value, Mapping):
+            return None
+        if isinstance(value, str) and not value.strip():
+            return None
+        return value
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls,
+        core_schema: CoreSchema,
+        handler: GetJsonSchemaHandler,
+    ) -> JsonSchemaValue:
+        """Keep the optional grounding knobs to one control each in the admin form."""
+        schema = handler(core_schema)
+        properties = schema.get("properties")
+        if not isinstance(properties, dict):
+            return schema
+
+        market = properties.get("market")
+        if isinstance(market, dict):
+            properties["market"] = _single_dropdown(
+                market,
+                values=get_args(BingMarket),
+                blank_title="Not set",
+            )
+
+        freshness = properties.get("freshness")
+        if isinstance(freshness, dict):
+            properties["freshness"] = _single_dropdown(
+                freshness,
+                values=get_args(BingFreshnessPreset),
+                blank_title="Not set",
+                titles=_FRESHNESS_PRESET_TITLES,
+            )
+
+        return schema
+
+
+BingAgentSearchRequest = BingAgentConfig.request_model()
+
+
+__all__ = [
+    "BingAgentConfig",
+    "BingAgentSearchRequest",
+    "BingFreshnessPreset",
+    "BingMarket",
+]

unique_search_proxy_core-2026.38.0.dev4/unique_search_proxy_core/agent_engines/bing/settings.py

@@ -0,0 +1,61 @@
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from unique_search_proxy_core.agent_engines.bing.enums import BingMarket
+
+_ENV_PREFIX = "BING_AGENT_"
+
+
+class _BingAgentEnvSettings(BaseSettings):
+    default_market: BingMarket | None = Field(
+        default=None,
+        description=(
+            "Bing market applied to grounded searches whose space leaves "
+            "Market blank. Unset means no market is sent at all."
+        ),
+    )
+
+    @field_validator("default_market", mode="before")
+    @classmethod
+    def _blank_is_unset(cls, value: Any) -> Any:
+        """Treat an empty variable as unset instead of failing to boot.
+
+        Helm renders an unconfigured optional value as ``""``, which
+        ``BingMarket`` would reject. A non-blank typo still fails at startup.
+        """
+        if isinstance(value, str) and not value.strip():
+            return None
+        return value
+
+
+def _get_settings() -> _BingAgentEnvSettings:
+    if "pytest" in sys.modules:
+        env_file = Path(os.getcwd()) / "tests/test.env"
+    else:
+        env_file = Path(os.getcwd()) / ".env"
+
+    class _Settings(_BingAgentEnvSettings):
+        model_config = SettingsConfigDict(
+            env_file=env_file,
+            env_prefix=_ENV_PREFIX,
+            extra="ignore",
+        )
+
+    return _Settings()
+
+
+bing_agent_env_settings = _get_settings()
+
+
+def resolve_market(value: str | None = None) -> str | None:
+    """Return the market to send to Bing, or ``None`` to send none at all.
+
+    The space's fixed market wins, falling back to ``BING_AGENT_DEFAULT_MARKET``.
+    With neither set, ``mkt`` is left off the grounding tool entirely.
+    """
+    return value or bing_agent_env_settings.default_market

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/unique_search_proxy_core/context.py

@@ -2,14 +2,17 @@
 
 from __future__ import annotations
 
+import json
+import logging
 from collections.abc import Mapping
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 COMPANY_ID_HEADER = "x-unique-company-id"
 USER_ID_HEADER = "x-unique-user-id"
 CHAT_ID_HEADER = "x-unique-chat-id"
+USER_METADATA_HEADER = "x-unique-user-metadata"
 
 _CONTEXT_HEADER_FIELDS: tuple[tuple[str, str], ...] = (
     ("company_id", COMPANY_ID_HEADER),
@@ -17,6 +20,8 @@ _CONTEXT_HEADER_FIELDS: tuple[tuple[str, str], ...] = (
     ("chat_id", CHAT_ID_HEADER),
 )
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class RequestContext(BaseModel):
     """Caller identity for search-proxy requests."""
@@ -26,14 +31,23 @@ class RequestContext(BaseModel):
     company_id: str
     user_id: str
     chat_id: str
+    user_metadata: dict[str, Any] = Field(default_factory=dict)
 
     def to_headers(self) -> dict[str, str]:
         """Serialize context to the canonical HTTP header names."""
-        return {
+        headers = {
             COMPANY_ID_HEADER: self.company_id,
             USER_ID_HEADER: self.user_id,
             CHAT_ID_HEADER: self.chat_id,
         }
+        if self.user_metadata:
+            # ``ensure_ascii`` keeps the value latin-1 encodable, which HTTP
+            # headers require.
+            headers[USER_METADATA_HEADER] = json.dumps(
+                self.user_metadata,
+                ensure_ascii=True,
+            )
+        return headers
 
     @classmethod
     def missing_headers(cls, headers: Mapping[str, Any]) -> list[str]:
@@ -62,7 +76,37 @@ class RequestContext(BaseModel):
                 values[field_name] = getattr(fallback, field_name)
             else:
                 values[field_name] = str(raw)
-        return cls(**values)
+        return cls(
+            **values,
+            user_metadata=_parse_user_metadata(
+                normalized.get(USER_METADATA_HEADER),
+                fallback=fallback.user_metadata,
+            ),
+        )
+
+
+def _parse_user_metadata(
+    raw: Any,
+    *,
+    fallback: dict[str, Any],
+) -> dict[str, Any]:
+    """Decode the JSON user-metadata header; absent → fallback, malformed → {}."""
+    if raw is None or (isinstance(raw, str) and not raw.strip()):
+        return fallback
+    try:
+        decoded = json.loads(raw)
+    except (TypeError, ValueError) as exc:
+        # Log the error class only — never the header body (may contain PII).
+        _LOGGER.warning(
+            "Ignoring malformed %s header (%s)",
+            USER_METADATA_HEADER,
+            type(exc).__name__,
+        )
+        return {}
+    if not isinstance(decoded, dict):
+        _LOGGER.warning("Ignoring non-object %s header", USER_METADATA_HEADER)
+        return {}
+    return decoded
 
 
 LOCAL_REQUEST_CONTEXT = RequestContext(
@@ -78,4 +122,5 @@ __all__ = [
     "LOCAL_REQUEST_CONTEXT",
     "RequestContext",
     "USER_ID_HEADER",
+    "USER_METADATA_HEADER",
 ]

{unique_search_proxy_core-2026.38.0.dev2 → unique_search_proxy_core-2026.38.0.dev4}/unique_search_proxy_core/param_policy/__init__.py

@@ -2,18 +2,14 @@
 
 Public surface: :class:`ExposableParam` (the admin-side ``{expose, value}``
 deployment value), :class:`ExposedParams` (the base class of LLM-facing
-parameter models), :func:`enforced_by_infra` (RJSF tag to lock env-enforced
-knobs), and the shared leading-field names. Everything else callers need lives
-as methods on the config base classes (``BaseSearchEngineConfig.request_model()``
-/ ``exposed_params_model()`` / ``merge()`` / ``provider_query_params()``).
+parameter models), and the shared leading-field names. Everything else callers
+need lives as methods on the config base classes
+(``BaseSearchEngineConfig.request_model()`` / ``exposed_params_model()`` /
+``merge()`` / ``provider_query_params()``).
 """
 
 from unique_search_proxy_core.param_policy.exposable_param import ExposableParam
 from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
-from unique_search_proxy_core.param_policy.ui_tags import (
-    dynamic_enforced_by_infra,
-    enforced_by_infra,
-)
 
 #: Required leading field of every search / agent-search request.
 QUERY_FIELD = "query"
@@ -25,6 +21,4 @@ __all__ = [
     "URLS_FIELD",
     "ExposableParam",
     "ExposedParams",
-    "enforced_by_infra",
-    "dynamic_enforced_by_infra",
 ]

unique_search_proxy_core-2026.38.0.dev2/unique_search_proxy_core/agent_engines/bing/schema.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-from typing import Annotated, Any, ClassVar, Literal, TypeAlias
-
-from pydantic import Field, GetCoreSchemaHandler, field_validator
-from pydantic_core import CoreSchema, core_schema
-from unique_toolkit._common.pydantic.rjsf_tags import RJSFMetaTag
-
-from unique_search_proxy_core.agent_engines.base import (
-    AgentEngineType,
-    BaseAgentEngineConfig,
-)
-from unique_search_proxy_core.agent_engines.bing.enums import (
-    BingFreshnessPreset,
-    BingMarket,
-    BingSetLang,
-)
-from unique_search_proxy_core.agent_engines.bing.settings import (
-    bing_agent_env_settings,
-)
-from unique_search_proxy_core.param_policy.exposable_param import ExposableParam
-from unique_search_proxy_core.param_policy.ui_tags import dynamic_enforced_by_infra
-from unique_search_proxy_core.schema import DeactivatedNone
-
-_BING_DOCS_BASE_URL = (
-    "https://learn.microsoft.com/en-us/previous-versions/bing/search-apis/"
-    "bing-web-search/reference"
-)
-_BING_QUERY_PARAMS_DOCS_URL = f"{_BING_DOCS_BASE_URL}/query-parameters"
-_BING_MARKET_CODES_DOCS_URL = f"{_BING_DOCS_BASE_URL}/market-codes"
-
-
-_FRESHNESS_DATE_PATTERN = r"^\d{4}-\d{2}-\d{2}(?:\.\.\d{4}-\d{2}-\d{2})?$"
-
-
-class BingFreshnessDate(str):
-    """A single ``YYYY-MM-DD`` day or an inclusive ``YYYY-MM-DD..YYYY-MM-DD`` span.
-
-    The constraint lives in the type instead of ``Field(pattern=...)`` because
-    request-model derivation strips ``Annotated`` metadata off union branches,
-    which would leave exactly the surface the LLM writes to unchecked. Freshness
-    is baked into the hashed agent name, so free text here would mint a Foundry
-    agent version per distinct string while Bing ignored the value itself.
-    """
-
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls,
-        source: type[Any],
-        handler: GetCoreSchemaHandler,
-    ) -> CoreSchema:
-        return core_schema.str_schema(pattern=_FRESHNESS_DATE_PATTERN)
-
-
-MarketOrNone: TypeAlias = Annotated[BingMarket, Field(title="Market")] | DeactivatedNone
-SetLangOrNone: TypeAlias = (
-    Annotated[BingSetLang, Field(title="Language")] | DeactivatedNone
-)
-FreshnessOrNone: TypeAlias = (
-    Annotated[BingFreshnessPreset, Field(title="Preset")]
-    | Annotated[BingFreshnessDate, Field(title="Day or range")]
-    | DeactivatedNone
-)
-
-ExposableMarket = ExposableParam[MarketOrNone]
-ExposableSetLang = ExposableParam[SetLangOrNone]
-ExposableFreshness = ExposableParam[FreshnessOrNone]
-
-
-def _default_market() -> ExposableMarket:
-    return ExposableMarket(
-        expose=False,
-        value=bing_agent_env_settings.market.default,
-    )
-
-
-def _market_is_enforced() -> bool:
-    return bing_agent_env_settings.market.enforce
-
-
-EnforcedExposableMarket = Annotated[
-    ExposableMarket,
-    dynamic_enforced_by_infra(
-        _market_is_enforced,
-        help=(
-            "Market is pinned for this deployment by "
-            '`BING_AGENT_MARKET={"default": "<mkt>", "enforce": true}`.'
-        ),
-    ),
-]
-
-# The grounding knobs are not cleared for release yet, so they are kept out of
-# the admin form instead of being removed: the fields, the values stored configs
-# already carry and the runtime path stay intact, but with no widget to render,
-# no admin can pin a value or expose a knob to the LLM. Drop the tag to release.
-_hidden_until_released = RJSFMetaTag.SpecialWidget.hidden()
-
-HiddenExposableMarket = Annotated[EnforcedExposableMarket, _hidden_until_released]
-HiddenExposableSetLang = Annotated[ExposableSetLang, _hidden_until_released]
-HiddenExposableFreshness = Annotated[ExposableFreshness, _hidden_until_released]
-
-
-class BingAgentConfig(BaseAgentEngineConfig[Literal[AgentEngineType.BING]]):
-    """Deployment + request defaults for Bing grounding via Azure AI Projects."""
-
-    _request_model_name: ClassVar[str] = "BingAgentSearchRequest"
-    _exposed_params_model_name: ClassVar[str] = "BingAgentExposedParams"
-
-    engine: Annotated[
-        Literal[AgentEngineType.BING], RJSFMetaTag.SpecialWidget.hidden()
-    ] = Field(
-        default=AgentEngineType.BING,
-        title="Agent engine",
-        description="Provider discriminator; must be `bing` for this config.",
-    )
-    fetch_size: int = Field(
-        default=5,
-        ge=1,
-        le=50,
-        description="Maximum number of Bing grounding results per query",
-    )
-    market: HiddenExposableMarket = Field(
-        default=_default_market(),
-        title="Market",
-        description=(
-            "Country/region **and** language the results come from (Bing `mkt`), "
-            "as `<language>-<country>`: `de-CH` returns German-language Swiss "
-            "results, `fr-CH` French-language Swiss ones, `en-GB` UK English. "
-            "Set it when the question is about a specific country or expects an "
-            "answer in that country's language. Left unset, Bing guesses the "
-            "market from the caller and may answer from another country. "
-            f"[Market codes]({_BING_MARKET_CODES_DOCS_URL})"
-        ),
-    )
-    set_lang: HiddenExposableSetLang = Field(
-        default=ExposableSetLang(expose=False, value=None),
-        title="Interface language",
-        description=(
-            "Language of Bing's own interface strings in the response (Bing "
-            "`setLang`), e.g. `de`, `fr`, `pt-br`. It changes neither which "
-            "results come back nor the language they are written in — use the "
-            "market for that. Bing falls back to English for codes it does not "
-            "support. "
-            f"[Supported languages]({_BING_MARKET_CODES_DOCS_URL}#bing-supported-language-codes)"
-        ),
-    )
-    freshness: HiddenExposableFreshness = Field(
-        default=ExposableFreshness(expose=False, value=None),
-        title="Freshness",
-        description=(
-            "Keep only pages Bing discovered recently (Bing `freshness`): `Day` "
-            "(last 24 hours), `Week` (last 7 days), `Month` (last 30 days), a "
-            "single `YYYY-MM-DD` day, or an inclusive "
-            "`YYYY-MM-DD..YYYY-MM-DD` range. Use it for news and fast-moving "
-            "topics; leave it unset for background or reference questions, where "
-            "it would hide older pages that are still correct. "
-            f"[Accepted values]({_BING_QUERY_PARAMS_DOCS_URL}#freshness)"
-        ),
-    )
-
-    @field_validator("market", mode="before")
-    @classmethod
-    def validate_market(cls, v: ExposableMarket) -> ExposableMarket:
-        if bing_agent_env_settings.market.enforce:
-            return ExposableMarket(
-                expose=False, value=bing_agent_env_settings.market.default
-            )
-        return v
-
-
-BingAgentSearchRequest = BingAgentConfig.request_model()
-
-
-__all__ = [
-    "BingAgentConfig",
-    "BingAgentSearchRequest",
-    "BingFreshnessDate",
-    "BingFreshnessPreset",
-    "BingMarket",
-    "BingSetLang",
-    "ExposableFreshness",
-    "ExposableMarket",
-    "ExposableSetLang",
-]

unique_search_proxy_core-2026.38.0.dev2/unique_search_proxy_core/agent_engines/bing/settings.py

@@ -1,47 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from unique_search_proxy_core.agent_engines.bing.enums import BingMarket
-
-_ENV_PREFIX = "BING_AGENT_"
-
-
-class MarketSettings(BaseSettings):
-    default: BingMarket | None = Field(
-        default=None,
-        description="Default Bing market for grounded searches",
-    )
-    enforce: bool = Field(
-        default=False,
-        description="Enforce the default market for grounded searches",
-    )
-
-
-class _BingAgentEnvSettings(BaseSettings):
-    market: MarketSettings = Field(
-        default=MarketSettings(),
-        description="Bing market settings",
-    )
-
-
-def _get_settings() -> _BingAgentEnvSettings:
-    if "pytest" in sys.modules:
-        env_file = Path(os.getcwd()) / "tests/test.env"
-    else:
-        env_file = Path(os.getcwd()) / ".env"
-
-    class _Settings(_BingAgentEnvSettings):
-        model_config = SettingsConfigDict(
-            env_file=env_file,
-            env_prefix=_ENV_PREFIX,
-            extra="ignore",
-        )
-
-    return _Settings()
-
-
-bing_agent_env_settings = _get_settings()

unique_search_proxy_core-2026.38.0.dev2/unique_search_proxy_core/param_policy/ui_tags.py

@@ -1,41 +0,0 @@
-"""RJSF tags for deployment knobs the environment has taken out of admin hands."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-
-from unique_toolkit._common.pydantic.rjsf_tags import DynamicRJSFTag, RJSFMetaTag
-
-_ENFORCED_HELP = "This parameter has been enforced by the infra team."
-
-
-def enforced_by_infra(enforced: bool, *, help: str | None = None) -> RJSFMetaTag:
-    """Grey out a whole config field (including every child of an ``ExposableParam``).
-
-    Apply to the *field* annotation, not the ``ExposableParam`` type argument:
-    ``Annotated[ExposableMarket, DynamicRJSFTag(enforced_by_infra_factory)]``.
-    Tags inside ``ExposableParam[Annotated[T, ...]]`` are dropped, because
-    ``ui_schema_for_model`` resolves annotations with ``get_type_hints``, which
-    does not substitute TypeVars on Pydantic generics.
-
-    Prefer wrapping the factory in :class:`DynamicRJSFTag` so env-driven locks
-    are re-evaluated whenever the admin UI schema is generated.
-    """
-    attrs: dict[str, Any] = {"ui:disabled": enforced}
-    if enforced:
-        attrs["ui:help"] = help or _ENFORCED_HELP
-    return RJSFMetaTag(attrs)
-
-
-def dynamic_enforced_by_infra(
-    factory: Callable[[], bool],
-    *,
-    help: str | None = None,
-) -> DynamicRJSFTag:
-    """Like :func:`enforced_by_infra`, but re-reads ``factory()`` at uiSchema time."""
-
-    def _tag() -> RJSFMetaTag:
-        return enforced_by_infra(factory(), help=help)
-
-    return DynamicRJSFTag(_tag)