sofias-sdk-lite 0.1.5__tar.gz → 0.2.0__tar.gz

sofias_sdk_lite-0.2.0/LICENSE

@@ -0,0 +1,69 @@
+Sofias SDK Lite License
+
+Copyright (c) 2026 Sofias Tech, S.L. All rights reserved.
+
+This licence applies to the software distributed as "sofias-sdk-lite" (the
+"SDK"), including its source code, documentation and examples. By installing
+or using the SDK you accept it. If you do not accept it, do not use the SDK.
+
+1. Permitted use
+
+   Sofias Tech, S.L. ("Sofias") grants you a free, non-exclusive,
+   non-transferable and revocable licence to download, install and use the SDK
+   solely to develop, test and run agents intended to run on the Sofias
+   platform, including its developer portal and marketplace.
+
+2. Source availability
+
+   The source code is made available so that you can read it and understand
+   how the SDK works. Access to the source code does not grant any right
+   beyond those set out in section 1.
+
+3. Restrictions
+
+   Except as expressly permitted in section 1, you may not:
+
+   a) use the SDK, or any part or derivative of it, to build, run or offer
+      agents, applications or services for any platform other than Sofias;
+   b) copy, modify, adapt, translate or create derivative works of the SDK,
+      other than the local copies needed for the permitted use;
+   c) distribute, publish, sublicense, sell, rent or otherwise make the SDK or
+      any derivative of it available to third parties;
+   d) remove or alter this notice or any other notice of ownership.
+
+4. Your agents
+
+   The agents you build with the SDK are yours. This licence does not give
+   Sofias any right over them. Any right Sofias needs to host, run or offer
+   your agents is governed by the terms you accept when you publish on the
+   Sofias platform.
+
+5. Termination
+
+   This licence ends automatically if you breach any of its terms. Sofias may
+   also revoke it by written notice. On termination you must stop using the SDK
+   and delete every copy in your possession.
+
+6. No warranty
+
+   THE SDK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING WITHOUT LIMITATION THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+7. Limitation of liability
+
+   TO THE MAXIMUM EXTENT PERMITTED BY LAW, SOFIAS SHALL NOT BE LIABLE FOR ANY
+   DAMAGE ARISING FROM THE USE OF, OR THE INABILITY TO USE, THE SDK.
+
+8. Changes
+
+   Sofias may publish new versions of this licence. Each release of the SDK is
+   governed by the licence included with it.
+
+9. Governing law and jurisdiction
+
+   This licence is governed by Spanish law. Any dispute shall be submitted to
+   the courts of Donostia - San Sebastian (Gipuzkoa), Spain, unless mandatory
+   law provides otherwise.
+
+Contact: support@sofias.ai

sofias_sdk_lite-0.1.5/README.md → sofias_sdk_lite-0.2.0/PKG-INFO

@@ -1,7 +1,45 @@
+Metadata-Version: 2.4
+Name: sofias-sdk-lite
+Version: 0.2.0
+Summary: Build agents on the Sofias agent graph and run them over RabbitMQ.
+Keywords: agents,ai,llm,rabbitmq,sofias
+Author: Sofias Tech, S.L.
+Author-email: Sofias Tech, S.L. <support@sofias.ai>
+License-Expression: LicenseRef-Sofias-SDK-Lite
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Dist: pydantic>=2.0
+Requires-Dist: aio-pika>=9.0.0
+Requires-Dist: rstream>=1.0.0
+Requires-Dist: nh3>=0.3.6
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mkdocs>=1.6,<2 ; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.5 ; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25 ; extra == 'docs'
+Requires-Dist: opentelemetry-api>=1.20.0 ; extra == 'otel'
+Requires-Python: >=3.11
+Project-URL: Homepage, https://sofias.ai/
+Project-URL: Documentation, https://docs.sofias.ai/
+Project-URL: Repository, https://github.com/Sofias-ai/sofias-sdk-lite
+Project-URL: Changelog, https://github.com/Sofias-ai/sofias-sdk-lite/blob/main/CHANGELOG.md
+Provides-Extra: docs
+Provides-Extra: otel
+Description-Content-Type: text/markdown
+
 # sofias-sdk-lite
 
 Build multi-node agents on a declarative graph and run them against RabbitMQ.
 
+**Documentation:** [docs.sofias.ai](https://docs.sofias.ai/) · **Developer portal:** [developers.sofias.ai](https://developers.sofias.ai/) · **Source:** [github.com/Sofias-ai/sofias-sdk-lite](https://github.com/Sofias-ai/sofias-sdk-lite)
+
 `sofias-sdk-lite` gives you:
 
 - **An agent graph** — LLM nodes, function nodes, delegation nodes (agent-to-agent),
@@ -13,8 +51,8 @@ Build multi-node agents on a declarative graph and run them against RabbitMQ.
 - **A runner** — `AgentRunner` consumes tasks from a queue, resolves per-request
   settings, executes your agent, and streams the response back — with graceful
   shutdown, retries, and circuit breakers built in.
-- **An LLM that is already wired** — LLM nodes talk to the Sofias Bifrost
-  gateway (or any OpenAI-compatible endpoint) using the model, URL and key
+- **An LLM that is already wired** — LLM nodes talk to the Sofias gateway
+  (or any OpenAI-compatible endpoint) using the model, URL and key
   from the agent's settings or the `SOFIAS_LLM_*` environment. `create_llm()`
   builds the client when you need it explicitly; `LLMCallable` stays a protocol
   for anything the bundled clients do not cover.
@@ -97,12 +135,11 @@ resolved at `build()`:
 
 1. Under `AgentRunner`, from the per-task settings the platform sends
    (`model_name`, `router_url`, `router_api_key` on `BaseAgentSettings`).
-2. Otherwise from the environment: `SOFIAS_LLM_MODEL`, `SOFIAS_LLM_BASE_URL`
-   (default `http://bifrost:8080/v1`), `SOFIAS_LLM_API_KEY`,
-   `SOFIAS_LLM_PROVIDER` (default `bifrost`). The `BIFROST_MODEL` /
-   `BIFROST_BASE_URL` / `BIFROST_API_KEY` variables the Sofias Developer
-   Portal injects into agent containers are accepted as fallbacks, so a
-   portal-deployed agent needs no LLM configuration at all.
+2. Otherwise from the environment: `SOFIAS_LLM_MODEL`, `SOFIAS_LLM_BASE_URL`,
+   `SOFIAS_LLM_API_KEY` and `SOFIAS_LLM_PROVIDER` (default `sofias`). The
+   Sofias platform injects them into every agent it runs, so an agent
+   deployed through the developer portal needs no LLM configuration at all.
+   There is no default URL: to run locally against a real gateway, set it.
 3. Or explicitly: `.with_llm(create_llm(model="default", api_key=...))`.
 
 ```python
@@ -173,11 +210,21 @@ if __name__ == "__main__":
 ## Scope (v1)
 
 Core agent graph, RabbitMQ messaging, the runner, and LLM clients for the
-Bifrost gateway / any OpenAI-compatible endpoint ship today. Memory and MCP
+Sofias gateway / any OpenAI-compatible endpoint ship today. Memory and MCP
 tool discovery are intentionally out of scope for v1 — the SDK ships the
 relevant protocols (`MemoryProvider`, `ToolProvider`) so you can plug in
 your own, and these become optional extras in a later release.
 
+## Source and contributions
+
+The public repository holds read-only release snapshots: each release of
+`sofias-sdk-lite` appears there as a single commit. Development happens
+elsewhere, so pull requests cannot be merged and we do not accept
+contributions at the moment. For questions or to report a problem, write to
+support@sofias.ai.
+
 ## License
 
-Apache-2.0. See [LICENSE](LICENSE).
+Source-available under the [Sofias SDK Lite License](https://github.com/Sofias-ai/sofias-sdk-lite/blob/main/LICENSE):
+you may use `sofias-sdk-lite` to develop, test and run agents for the Sofias
+platform. The agents you build with it are yours.

sofias_sdk_lite-0.1.5/PKG-INFO → sofias_sdk_lite-0.2.0/README.md

@@ -1,25 +1,9 @@
-Metadata-Version: 2.4
-Name: sofias-sdk-lite
-Version: 0.1.5
-Summary: Build agents on the Sofias agent graph and run them over RabbitMQ.
-License-Expression: Apache-2.0
-Requires-Dist: pydantic>=2.0
-Requires-Dist: aio-pika>=9.0.0
-Requires-Dist: rstream>=1.0.0
-Requires-Dist: nh3>=0.3.6
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: mkdocs-material>=9.5 ; extra == 'docs'
-Requires-Dist: mkdocstrings[python]>=0.25 ; extra == 'docs'
-Requires-Dist: opentelemetry-api>=1.20.0 ; extra == 'otel'
-Requires-Python: >=3.11
-Provides-Extra: docs
-Provides-Extra: otel
-Description-Content-Type: text/markdown
-
 # sofias-sdk-lite
 
 Build multi-node agents on a declarative graph and run them against RabbitMQ.
 
+**Documentation:** [docs.sofias.ai](https://docs.sofias.ai/) · **Developer portal:** [developers.sofias.ai](https://developers.sofias.ai/) · **Source:** [github.com/Sofias-ai/sofias-sdk-lite](https://github.com/Sofias-ai/sofias-sdk-lite)
+
 `sofias-sdk-lite` gives you:
 
 - **An agent graph** — LLM nodes, function nodes, delegation nodes (agent-to-agent),
@@ -31,8 +15,8 @@ Build multi-node agents on a declarative graph and run them against RabbitMQ.
 - **A runner** — `AgentRunner` consumes tasks from a queue, resolves per-request
   settings, executes your agent, and streams the response back — with graceful
   shutdown, retries, and circuit breakers built in.
-- **An LLM that is already wired** — LLM nodes talk to the Sofias Bifrost
-  gateway (or any OpenAI-compatible endpoint) using the model, URL and key
+- **An LLM that is already wired** — LLM nodes talk to the Sofias gateway
+  (or any OpenAI-compatible endpoint) using the model, URL and key
   from the agent's settings or the `SOFIAS_LLM_*` environment. `create_llm()`
   builds the client when you need it explicitly; `LLMCallable` stays a protocol
   for anything the bundled clients do not cover.
@@ -115,12 +99,11 @@ resolved at `build()`:
 
 1. Under `AgentRunner`, from the per-task settings the platform sends
    (`model_name`, `router_url`, `router_api_key` on `BaseAgentSettings`).
-2. Otherwise from the environment: `SOFIAS_LLM_MODEL`, `SOFIAS_LLM_BASE_URL`
-   (default `http://bifrost:8080/v1`), `SOFIAS_LLM_API_KEY`,
-   `SOFIAS_LLM_PROVIDER` (default `bifrost`). The `BIFROST_MODEL` /
-   `BIFROST_BASE_URL` / `BIFROST_API_KEY` variables the Sofias Developer
-   Portal injects into agent containers are accepted as fallbacks, so a
-   portal-deployed agent needs no LLM configuration at all.
+2. Otherwise from the environment: `SOFIAS_LLM_MODEL`, `SOFIAS_LLM_BASE_URL`,
+   `SOFIAS_LLM_API_KEY` and `SOFIAS_LLM_PROVIDER` (default `sofias`). The
+   Sofias platform injects them into every agent it runs, so an agent
+   deployed through the developer portal needs no LLM configuration at all.
+   There is no default URL: to run locally against a real gateway, set it.
 3. Or explicitly: `.with_llm(create_llm(model="default", api_key=...))`.
 
 ```python
@@ -191,11 +174,21 @@ if __name__ == "__main__":
 ## Scope (v1)
 
 Core agent graph, RabbitMQ messaging, the runner, and LLM clients for the
-Bifrost gateway / any OpenAI-compatible endpoint ship today. Memory and MCP
+Sofias gateway / any OpenAI-compatible endpoint ship today. Memory and MCP
 tool discovery are intentionally out of scope for v1 — the SDK ships the
 relevant protocols (`MemoryProvider`, `ToolProvider`) so you can plug in
 your own, and these become optional extras in a later release.
 
+## Source and contributions
+
+The public repository holds read-only release snapshots: each release of
+`sofias-sdk-lite` appears there as a single commit. Development happens
+elsewhere, so pull requests cannot be merged and we do not accept
+contributions at the moment. For questions or to report a problem, write to
+support@sofias.ai.
+
 ## License
 
-Apache-2.0. See [LICENSE](LICENSE).
+Source-available under the [Sofias SDK Lite License](https://github.com/Sofias-ai/sofias-sdk-lite/blob/main/LICENSE):
+you may use `sofias-sdk-lite` to develop, test and run agents for the Sofias
+platform. The agents you build with it are yours.

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/pyproject.toml

@@ -1,10 +1,29 @@
 [project]
 name = "sofias-sdk-lite"
-version = "0.1.5"
+version = "0.2.0"
 description = "Build agents on the Sofias agent graph and run them over RabbitMQ."
 readme = "README.md"
 requires-python = ">=3.11"
-license = "Apache-2.0"
+license = "LicenseRef-Sofias-SDK-Lite"
+license-files = ["LICENSE"]
+keywords = [
+    "agents",
+    "ai",
+    "llm",
+    "rabbitmq",
+    "sofias",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
 dependencies = [
     "pydantic>=2.0",
     "aio-pika>=9.0.0",
@@ -13,9 +32,20 @@ dependencies = [
     "httpx>=0.27.0",
 ]
 
+[[project.authors]]
+name = "Sofias Tech, S.L."
+email = "support@sofias.ai"
+
+[project.urls]
+Homepage = "https://sofias.ai/"
+Documentation = "https://docs.sofias.ai/"
+Repository = "https://github.com/Sofias-ai/sofias-sdk-lite"
+Changelog = "https://github.com/Sofias-ai/sofias-sdk-lite/blob/main/CHANGELOG.md"
+
 [project.optional-dependencies]
 otel = ["opentelemetry-api>=1.20.0"]
 docs = [
+    "mkdocs>=1.6,<2",
     "mkdocs-material>=9.5",
     "mkdocstrings[python]>=0.25",
 ]

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/pyproject.toml.orig

@@ -1,10 +1,24 @@
 [project]
 name = "sofias-sdk-lite"
-version = "0.1.5"
+version = "0.2.0"
 description = "Build agents on the Sofias agent graph and run them over RabbitMQ."
 readme = "README.md"
 requires-python = ">=3.11"
-license = "Apache-2.0"
+license = "LicenseRef-Sofias-SDK-Lite"
+license-files = ["LICENSE"]
+authors = [{ name = "Sofias Tech, S.L.", email = "support@sofias.ai" }]
+keywords = ["agents", "ai", "llm", "rabbitmq", "sofias"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
 dependencies = [
     "pydantic>=2.0",
     "aio-pika>=9.0.0",
@@ -13,11 +27,19 @@ dependencies = [
     "httpx>=0.27.0",
 ]
 
+[project.urls]
+Homepage = "https://sofias.ai/"
+Documentation = "https://docs.sofias.ai/"
+Repository = "https://github.com/Sofias-ai/sofias-sdk-lite"
+Changelog = "https://github.com/Sofias-ai/sofias-sdk-lite/blob/main/CHANGELOG.md"
+
 [project.optional-dependencies]
 otel = [
     "opentelemetry-api>=1.20.0",
 ]
 docs = [
+    # MkDocs 2.0 drops the plugin system this site relies on.
+    "mkdocs>=1.6,<2",
     "mkdocs-material>=9.5",
     "mkdocstrings[python]>=0.25",
 ]

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/__init__.py

@@ -91,7 +91,7 @@ from sofias_sdk_lite.errors import (
     ToolExecutionError,
 )
 from sofias_sdk_lite.llm import (
-    BifrostLLM,
+    GatewayLLM,
     LLMCallable,
     LLMGatewayConfig,
     LLMResponse,
@@ -230,7 +230,7 @@ __all__ = [
     "StreamableLLMCallable",
     "LLMResponse",
     # LLM clients + factory
-    "BifrostLLM",
+    "GatewayLLM",
     "OpenAICompatibleLLM",
     "LLMGatewayConfig",
     "create_llm",

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/config/agent_settings.py

@@ -68,13 +68,13 @@ class BaseAgentSettings(AgentSettings):
     """Model identifier or gateway alias. Empty means "no LLM configured here"."""
 
     router_url: str = ""
-    """OpenAI-compatible gateway root. Empty falls back to the in-cluster Bifrost URL."""
+    """OpenAI-compatible gateway root, injected by the platform. Required to build an LLM."""
 
     router_api_key: SecretStr = SecretStr("")
     """Gateway bearer token. Empty sends unauthenticated requests."""
 
     router_provider: str = ""
-    """Adapter flavour: ``"bifrost"`` (default when empty) or an OpenAI-compatible label."""
+    """Adapter flavour: ``"sofias"`` (default when empty) or an OpenAI-compatible label."""
 
     @property
     def has_llm_gateway(self) -> bool:

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/llm/__init__.py

@@ -5,19 +5,19 @@ Two layers:
 - **Protocol** (`LLMCallable`, `StreamableLLMCallable`, `LLMResponse`,
   `TokenUsage`, `ToolSpec`, ...): the contract `LLMNode` drives. Wrap any
   client in it if you need something the bundled adapters do not cover.
-- **Batteries** (`create_llm`, `BifrostLLM`, `OpenAICompatibleLLM`,
-  `LLMGatewayConfig`): a ready-made client for the Sofias Bifrost gateway (or
+- **Batteries** (`create_llm`, `GatewayLLM`, `OpenAICompatibleLLM`,
+  `LLMGatewayConfig`): a ready-made client for the Sofias gateway (or
   any OpenAI-compatible endpoint) resolved from settings or the environment,
   so agent code never constructs an LLM client by hand.
 """
 
 from __future__ import annotations
 
-from sofias_sdk_lite.llm.bifrost import (
-    DEFAULT_BIFROST_BASE_URL,
-    DEFAULT_BIFROST_MAX_TOKENS,
-    BifrostLLM,
-    normalize_bifrost_base_url,
+from sofias_sdk_lite.llm.gateway import (
+    DEFAULT_GATEWAY_MAX_TOKENS,
+    PROVIDER_GATEWAY,
+    GatewayLLM,
+    normalize_gateway_base_url,
 )
 from sofias_sdk_lite.llm.factory import (
     ENV_LLM_API_KEY,
@@ -52,11 +52,11 @@ __all__ = [
     "ToolCall",
     "ToolSpec",
     # Clients
-    "BifrostLLM",
+    "GatewayLLM",
     "OpenAICompatibleLLM",
-    "DEFAULT_BIFROST_BASE_URL",
-    "DEFAULT_BIFROST_MAX_TOKENS",
-    "normalize_bifrost_base_url",
+    "DEFAULT_GATEWAY_MAX_TOKENS",
+    "PROVIDER_GATEWAY",
+    "normalize_gateway_base_url",
     # Factory
     "LLMGatewayConfig",
     "create_llm",

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/llm/factory.py

@@ -6,10 +6,9 @@ Resolution order for `create_llm`:
 2. The agent's runtime settings (`BaseAgentSettings.model_name`,
    ``router_url``, ``router_api_key``), which the platform injects per task.
 3. Environment variables: ``SOFIAS_LLM_MODEL``, ``SOFIAS_LLM_BASE_URL``,
-   ``SOFIAS_LLM_API_KEY``, ``SOFIAS_LLM_PROVIDER``; then ``BIFROST_MODEL`` /
-   ``BIFROST_BASE_URL`` / ``BIFROST_API_KEY`` (what the Sofias Developer Portal
-   injects into every agent container); then the platform's canonical
-   ``MODEL_NAME`` / ``ROUTER_URL`` / ``ROUTER_API_KEY``.
+   ``SOFIAS_LLM_API_KEY``, ``SOFIAS_LLM_PROVIDER`` (what the Sofias platform
+   injects into every agent container); then ``MODEL_NAME`` / ``ROUTER_URL`` /
+   ``ROUTER_API_KEY``, the same keys the agent settings use.
 
 `AgentBuilder.build()` calls `resolve_default_llm` when no `with_llm()` was
 given, and `AgentRunner` scopes the per-task settings-derived client with
@@ -27,7 +26,7 @@ from typing import Any, Final
 from pydantic import BaseModel, ConfigDict, SecretStr
 
 from sofias_sdk_lite.errors.exceptions import LLMConfigurationError
-from sofias_sdk_lite.llm.bifrost import DEFAULT_BIFROST_BASE_URL, BifrostLLM
+from sofias_sdk_lite.llm.gateway import PROVIDER_GATEWAY, GatewayLLM
 from sofias_sdk_lite.llm.openai_compatible import OpenAICompatibleLLM
 from sofias_sdk_lite.llm.protocol import LLMCallable, StreamableLLMCallable
 from sofias_sdk_lite.observability._log import get_logger
@@ -53,16 +52,12 @@ ENV_LLM_BASE_URL: Final[str] = "SOFIAS_LLM_BASE_URL"
 ENV_LLM_API_KEY: Final[str] = "SOFIAS_LLM_API_KEY"
 ENV_LLM_PROVIDER: Final[str] = "SOFIAS_LLM_PROVIDER"
 
-# Fallback names, tried in order after the SOFIAS_LLM_* variables:
-# - BIFROST_*: injected by the Sofias Developer Portal into sandbox and
-#   production agent containers (AgentRuntime::ModelSelection#model_env).
-# - MODEL_NAME / ROUTER_URL / ROUTER_API_KEY: the platform's canonical
-#   settings keys, so a container that already exports them needs no renaming.
-_ENV_FALLBACK_MODEL: Final[tuple[str, ...]] = ("BIFROST_MODEL", "MODEL_NAME")
-_ENV_FALLBACK_BASE_URL: Final[tuple[str, ...]] = ("BIFROST_BASE_URL", "ROUTER_URL")
-_ENV_FALLBACK_API_KEY: Final[tuple[str, ...]] = ("BIFROST_API_KEY", "ROUTER_API_KEY")
+# Fallback names, tried after the SOFIAS_LLM_* variables: the same keys the
+# agent settings use, so a container that already exports them needs no renaming.
+_ENV_FALLBACK_MODEL: Final[tuple[str, ...]] = ("MODEL_NAME",)
+_ENV_FALLBACK_BASE_URL: Final[tuple[str, ...]] = ("ROUTER_URL",)
+_ENV_FALLBACK_API_KEY: Final[tuple[str, ...]] = ("ROUTER_API_KEY",)
 
-PROVIDER_BIFROST: Final[str] = "bifrost"
 _OPENAI_COMPATIBLE_PROVIDERS: Final[frozenset[str]] = frozenset(
     {"openai", "openai-compatible", "generic", "litellm", "openrouter", "vllm"}
 )
@@ -71,8 +66,9 @@ _OPENAI_COMPATIBLE_PROVIDERS: Final[frozenset[str]] = frozenset(
 class LLMGatewayConfig(BaseModel):
     """Everything needed to build an LLM client.
 
-    ``model`` is the only required field. ``base_url`` defaults to the
-    in-cluster Bifrost endpoint and ``provider`` to ``"bifrost"``.
+    ``model`` names the model; ``base_url`` must be set before `create_llm`
+    can build a client (the platform injects it). ``provider`` defaults to
+    ``"sofias"``, the Sofias gateway.
     """
 
     model_config = ConfigDict(frozen=True)
@@ -80,14 +76,14 @@ class LLMGatewayConfig(BaseModel):
     model: str
     """Model identifier or gateway alias (e.g. ``"default"``)."""
 
-    base_url: str = DEFAULT_BIFROST_BASE_URL
-    """OpenAI-compatible API root."""
+    base_url: str = ""
+    """OpenAI-compatible API root. Injected by the platform; required to build a client."""
 
     api_key: SecretStr = SecretStr("")
     """Bearer token. Empty sends no ``Authorization`` header."""
 
-    provider: str = PROVIDER_BIFROST
-    """``"bifrost"`` or any OpenAI-compatible label (``"openai"``, ``"litellm"``, ...)."""
+    provider: str = PROVIDER_GATEWAY
+    """``"sofias"`` or any OpenAI-compatible label (``"openai"``, ``"litellm"``, ...)."""
 
     temperature: float | None = None
     """Sampling temperature; ``None`` keeps the adapter default."""
@@ -102,7 +98,7 @@ class LLMGatewayConfig(BaseModel):
     """Retries on transient failures."""
 
     reasoning_effort: str | None = None
-    """Bifrost only: overrides the per-model-family default."""
+    """Sofias gateway only: overrides the per-model-family default."""
 
     def with_overrides(self, **overrides: Any) -> LLMGatewayConfig:
         """Return a copy with the non-``None`` overrides applied."""
@@ -123,16 +119,16 @@ def _first_env(env: Mapping[str, str], primary: str, fallbacks: tuple[str, ...])
 def gateway_config_from_env(environ: Mapping[str, str] | None = None) -> LLMGatewayConfig | None:
     """Read gateway configuration from the environment; ``None`` if no model is set.
 
-    ``SOFIAS_LLM_*`` wins, then the portal's ``BIFROST_*``, then
-    ``MODEL_NAME`` / ``ROUTER_URL`` / ``ROUTER_API_KEY``.
+    ``SOFIAS_LLM_*`` wins, then ``MODEL_NAME`` / ``ROUTER_URL`` /
+    ``ROUTER_API_KEY``.
     """
     env = os.environ if environ is None else environ
     model = _first_env(env, ENV_LLM_MODEL, _ENV_FALLBACK_MODEL)
     if not model:
         return None
-    base_url = _first_env(env, ENV_LLM_BASE_URL, _ENV_FALLBACK_BASE_URL) or DEFAULT_BIFROST_BASE_URL
+    base_url = _first_env(env, ENV_LLM_BASE_URL, _ENV_FALLBACK_BASE_URL)
     api_key = _first_env(env, ENV_LLM_API_KEY, _ENV_FALLBACK_API_KEY)
-    provider = env.get(ENV_LLM_PROVIDER) or PROVIDER_BIFROST
+    provider = env.get(ENV_LLM_PROVIDER) or PROVIDER_GATEWAY
     return LLMGatewayConfig(
         model=model, base_url=base_url, api_key=SecretStr(api_key), provider=provider
     )
@@ -149,10 +145,10 @@ def gateway_config_from_settings(settings: Any) -> LLMGatewayConfig | None:
     model = getattr(settings, "model_name", "") or ""
     if not model:
         return None
-    base_url = getattr(settings, "router_url", "") or DEFAULT_BIFROST_BASE_URL
+    base_url = getattr(settings, "router_url", "") or ""
     raw_key = getattr(settings, "router_api_key", "")
     api_key = raw_key.get_secret_value() if isinstance(raw_key, SecretStr) else str(raw_key or "")
-    provider = getattr(settings, "router_provider", "") or PROVIDER_BIFROST
+    provider = getattr(settings, "router_provider", "") or PROVIDER_GATEWAY
     return LLMGatewayConfig(
         model=model, base_url=base_url, api_key=SecretStr(api_key), provider=provider
     )
@@ -204,14 +200,23 @@ def create_llm(
         source: An `LLMGatewayConfig`, an agent settings object exposing
             ``model_name`` / ``router_url`` / ``router_api_key``, or ``None``
             to fall back to keyword arguments and then the environment.
-        model, base_url, api_key, provider, temperature, max_tokens, timeout,
-            max_retries, reasoning_effort: Override the resolved configuration.
+        model: Overrides the resolved model identifier or gateway alias.
+        base_url: Overrides the resolved gateway URL.
+        api_key: Overrides the resolved bearer token.
+        provider: Overrides the adapter flavour (``"sofias"`` or an
+            OpenAI-compatible label).
+        temperature: Overrides the sampling temperature.
+        max_tokens: Overrides the output budget.
+        timeout: Overrides the per-request timeout in seconds.
+        max_retries: Overrides the number of retries on transient failures.
+        reasoning_effort: Overrides the per-model-family default (Sofias
+            gateway only).
         **adapter_kwargs: Forwarded to the adapter constructor (e.g.
             ``transport=`` for tests, ``default_headers=``).
 
     Raises:
-        LLMConfigurationError: If no model can be resolved or the provider
-            is unknown.
+        LLMConfigurationError: If no model or gateway URL can be resolved, or
+            the provider is unknown.
     """
     config = _resolve_config(
         source,
@@ -246,12 +251,20 @@ def create_llm(
     if config.temperature is not None:
         common["temperature"] = config.temperature
 
+    if not config.base_url.strip():
+        raise LLMConfigurationError(
+            f"No LLM gateway URL configured for model '{config.model}'. On the Sofias "
+            f"platform {ENV_LLM_BASE_URL} is injected automatically; to run locally, "
+            "export it or install a fake LLM with default_llm(...).",
+            missing=["base_url"],
+        )
+
     provider_name = config.provider.lower()
-    if provider_name == PROVIDER_BIFROST:
-        return BifrostLLM(reasoning_effort=config.reasoning_effort, **common)
+    if provider_name == PROVIDER_GATEWAY:
+        return GatewayLLM(reasoning_effort=config.reasoning_effort, **common)
     if provider_name in _OPENAI_COMPATIBLE_PROVIDERS:
         return OpenAICompatibleLLM(provider=provider_name, **common)
-    supported = ", ".join(sorted({PROVIDER_BIFROST, *_OPENAI_COMPATIBLE_PROVIDERS}))
+    supported = ", ".join(sorted({PROVIDER_GATEWAY, *_OPENAI_COMPATIBLE_PROVIDERS}))
     raise LLMConfigurationError(
         f"Unknown LLM provider '{config.provider}'. Supported: {supported}",
         missing=["provider"],

sofias_sdk_lite-0.1.5/src/sofias_sdk_lite/llm/bifrost.py → sofias_sdk_lite-0.2.0/src/sofias_sdk_lite/llm/gateway.py

@@ -1,13 +1,17 @@
-"""Bifrost gateway client.
+"""Sofias gateway client.
 
-Bifrost is the OpenAI-compatible LLM gateway used by the Sofias platform. This
-adapter is `OpenAICompatibleLLM` with the gateway's defaults baked in:
+The Sofias platform gives every agent access to its models through an
+OpenAI-compatible gateway. This adapter is `OpenAICompatibleLLM` with the
+gateway's defaults baked in:
 
-- base URL ``http://bifrost:8080/v1`` (the in-cluster service name);
 - a per-model-family ``reasoning_effort`` so thinking channels are switched
   off (or minimised) unless the caller asks otherwise;
 - a generous ``max_tokens`` budget, because structured output is paid out
   of that budget and a truncated JSON document does not parse.
+
+There is no default address: when the agent runs on the platform the gateway
+URL is injected for it (``SOFIAS_LLM_BASE_URL``), and to run locally against a
+real gateway you set it yourself.
 """
 
 from __future__ import annotations
@@ -17,19 +21,20 @@ from urllib.parse import urlsplit
 
 import httpx
 
+from sofias_sdk_lite.errors.exceptions import LLMConfigurationError
 from sofias_sdk_lite.llm.openai_compatible import OpenAICompatibleLLM
 
 __all__ = [
-    "BifrostLLM",
-    "DEFAULT_BIFROST_BASE_URL",
-    "DEFAULT_BIFROST_MAX_TOKENS",
-    "normalize_bifrost_base_url",
+    "DEFAULT_GATEWAY_MAX_TOKENS",
+    "GatewayLLM",
+    "PROVIDER_GATEWAY",
+    "normalize_gateway_base_url",
 ]
 
-DEFAULT_BIFROST_BASE_URL: Final[str] = "http://bifrost:8080/v1"
-"""In-cluster Bifrost endpoint used when no base URL is configured."""
+PROVIDER_GATEWAY: Final[str] = "sofias"
+"""Provider label that selects this adapter in `create_llm`."""
 
-DEFAULT_BIFROST_MAX_TOKENS: Final[int] = 16_384
+DEFAULT_GATEWAY_MAX_TOKENS: Final[int] = 16_384
 """Output budget sent when neither the constructor nor the caller sets one.
 
 A single budget on purpose: splitting it by reasoning mode produced a family
@@ -39,9 +44,9 @@ billed, so a generous cap costs nothing on short completions.
 
 # Per-family default ``reasoning_effort`` when the caller passes none.
 # ``"none"`` turns the thinking channel off, ``"low"`` keeps it minimal.
-# - gpt-oss reasons by default and some providers reject "none" -> "low".
-# - deepseek: the primary provider rejects "none" with HTTP 400 -> "low".
-# - qwen: thinking is inconsistent across providers -> "none" explicitly.
+# - gpt-oss reasons by default and "none" is not accepted everywhere -> "low".
+# - deepseek: "none" is not accepted everywhere -> "low".
+# - qwen: thinking behaves inconsistently unless disabled -> "none" explicitly.
 # - glm: "none" makes the model emit its monologue inside content -> "low".
 _REASONING_EFFORT_BY_FAMILY: Final[dict[str, str]] = {
     "gpt-oss": "low",
@@ -51,43 +56,55 @@ _REASONING_EFFORT_BY_FAMILY: Final[dict[str, str]] = {
 }
 
 # Fallback for models outside the table, including the ``"default"`` gateway
-# alias most agents send: ``"low"`` is accepted by every upstream provider.
+# alias most agents send: ``"low"`` is accepted by every model family.
 _REASONING_EFFORT_FALLBACK: Final[str] = "low"
 
 
-def normalize_bifrost_base_url(base_url: str) -> str:
-    """Return the OpenAI-compatible API root for a Bifrost host.
+def normalize_gateway_base_url(base_url: str) -> str:
+    """Return the OpenAI-compatible API root for a gateway host.
+
+    The gateway can be configured either as a bare host
+    (``https://gateway.example``) or as the API root
+    (``https://gateway.example/v1``). The OpenAI surface lives under ``/v1``,
+    so a URL with no path gets it appended; any URL that already has a path is
+    trusted as-is.
 
-    Deployments configure the gateway either as a bare host
-    (``https://bifrost.example``) or as the API root
-    (``https://bifrost.example/v1``). Bifrost serves the OpenAI surface under
-    ``/v1``, so a URL with no path gets it appended; any URL that already has
-    a path is trusted as-is. Empty input falls back to the in-cluster default.
+    Raises:
+        LLMConfigurationError: If ``base_url`` is empty.
     """
-    url = (base_url or DEFAULT_BIFROST_BASE_URL).rstrip("/")
+    url = (base_url or "").strip().rstrip("/")
+    if not url:
+        raise LLMConfigurationError(
+            "No LLM gateway URL configured. On the Sofias platform "
+            "SOFIAS_LLM_BASE_URL is injected automatically; to run locally, "
+            "export it or install a fake LLM with default_llm(...).",
+            missing=["base_url"],
+        )
     if urlsplit(url).path in ("", "/"):
         return f"{url}/v1"
     return url
 
 
-class BifrostLLM(OpenAICompatibleLLM):
-    """`StreamableLLMCallable` for the Bifrost gateway.
+class GatewayLLM(OpenAICompatibleLLM):
+    """`StreamableLLMCallable` for the Sofias gateway.
 
     Args:
-        api_key: Bifrost API key (empty string sends no ``Authorization``).
+        api_key: Gateway API key (empty string sends no ``Authorization``).
         model: Model identifier or gateway alias (e.g. ``"default"``).
-        base_url: Gateway host or API root; defaults to the in-cluster
-            service URL. A bare host gets ``/v1`` appended (see
-            `normalize_bifrost_base_url`).
+        base_url: Gateway host or API root. Required; a bare host gets
+            ``/v1`` appended (see `normalize_gateway_base_url`).
         temperature: Sampling temperature.
         max_retries: Retries on transient failures.
         timeout: Per-request timeout in seconds.
         reasoning_effort: ``None`` applies the per-family default; a non-empty
             string is sent as-is on every request; ``""`` disables injection
-            so the provider default applies.
-        max_tokens: Output budget; ``None`` applies `DEFAULT_BIFROST_MAX_TOKENS`.
+            so the model default applies.
+        max_tokens: Output budget; ``None`` applies `DEFAULT_GATEWAY_MAX_TOKENS`.
         default_headers: Extra headers sent on every request.
         transport: Optional ``httpx`` transport (for tests).
+
+    Raises:
+        LLMConfigurationError: If ``base_url`` is empty.
     """
 
     def __init__(
@@ -95,7 +112,7 @@ class BifrostLLM(OpenAICompatibleLLM):
         *,
         api_key: str,
         model: str,
-        base_url: str = DEFAULT_BIFROST_BASE_URL,
+        base_url: str,
         temperature: float = 0.1,
         max_retries: int = 3,
         timeout: float = 120.0,
@@ -106,9 +123,9 @@ class BifrostLLM(OpenAICompatibleLLM):
     ) -> None:
         super().__init__(
             api_key=api_key,
-            base_url=normalize_bifrost_base_url(base_url),
+            base_url=normalize_gateway_base_url(base_url),
             model=model,
-            provider="bifrost",
+            provider=PROVIDER_GATEWAY,
             temperature=temperature,
             max_retries=max_retries,
             timeout=timeout,
@@ -126,10 +143,10 @@ class BifrostLLM(OpenAICompatibleLLM):
         return _REASONING_EFFORT_FALLBACK
 
     def _augment_request_kwargs(self, kwargs: dict[str, Any]) -> None:
-        """Inject Bifrost defaults; values already present in the request win."""
+        """Inject gateway defaults; values already present in the request win."""
         if self._reasoning_effort is None:
             model = kwargs.get("model") or self._model
             kwargs.setdefault("reasoning_effort", self._default_reasoning_effort(str(model)))
         elif self._reasoning_effort:
             kwargs.setdefault("reasoning_effort", self._reasoning_effort)
-        kwargs.setdefault("max_tokens", DEFAULT_BIFROST_MAX_TOKENS)
+        kwargs.setdefault("max_tokens", DEFAULT_GATEWAY_MAX_TOKENS)

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/llm/openai_compatible.py

@@ -1,7 +1,7 @@
 """OpenAI-compatible chat-completions client implementing `StreamableLLMCallable`.
 
 Any gateway or provider that speaks the OpenAI ``/chat/completions`` wire
-format (Bifrost, LiteLLM, OpenRouter, vLLM, OpenAI itself, ...) works with
+format (the Sofias gateway, LiteLLM, OpenRouter, vLLM, OpenAI itself, ...) works with
 this adapter. It is built on ``httpx`` only, so the SDK stays free of any
 vendor SDK.
 
@@ -71,7 +71,7 @@ class OpenAICompatibleLLM:
             ``MockTransport`` here).
     """
 
-    GATEWAY_PROVIDERS: ClassVar[frozenset[str]] = frozenset({"bifrost", "litellm", "openrouter"})
+    GATEWAY_PROVIDERS: ClassVar[frozenset[str]] = frozenset({"sofias", "litellm", "openrouter"})
 
     def __init__(
         self,

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/llm/protocol.py

@@ -1,7 +1,7 @@
 """The `LLMCallable` protocol and its request/response types.
 
 This module defines the contract `LLMNode` drives. The SDK ships two
-implementations (`sofias_sdk_lite.llm.BifrostLLM` for the Sofias gateway and
+implementations (`sofias_sdk_lite.llm.GatewayLLM` for the Sofias gateway and
 `sofias_sdk_lite.llm.OpenAICompatibleLLM` for any OpenAI-style endpoint) and a
 factory (`sofias_sdk_lite.llm.create_llm`) that picks one from settings or the
 environment. Implement the protocol yourself only when you need a client those

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/observability/__init__.py

@@ -1,6 +1,6 @@
 """Observability protocols for sofias_sdk_lite: tracing and events.
 
-Protocol-only — no concrete OTLP/SigNoz exporter or message broker client
+Protocol-only — no concrete OTLP exporter or message broker client
 ships here. Bring your own tracing backend (OpenTelemetry, Jaeger,
 Datadog, ...) and event broker (RabbitMQ, Kafka, ...) by implementing the
 protocols below.

{sofias_sdk_lite-0.1.5 → sofias_sdk_lite-0.2.0}/src/sofias_sdk_lite/observability/tracing.py

@@ -6,7 +6,7 @@ protocols the SDK expects from an external tracing system, the
 node, tool, and LLM operations), and no-op / logging-only implementations
 for when a real tracing backend isn't configured.
 
-Protocol-only: no concrete OpenTelemetry/OTLP/SigNoz exporter is vendored.
+Protocol-only: no concrete OpenTelemetry/OTLP exporter is vendored.
 Bring your own backend by implementing ``TracingProvider``.
 """