kobil-aitrust 1.2.0__tar.gz

kobil_aitrust-1.2.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

kobil_aitrust-1.2.0/LICENSE

@@ -0,0 +1,128 @@
+KOBIL Agent Trust SDK License
+Version 1.0
+
+Copyright (c) 2026 KOBIL GmbH. All rights reserved.
+The Software is developed by the KOBIL AI Team.
+
+In short: you may install and use the Software free of charge, also in
+commercial products, and ship it inside your own application. You may not
+change it, copy it into other software, or pass it on or sell it on its
+own. The numbered terms below are the license; this summary is not.
+
+1. Definitions
+
+   "The Software" is the code and documentation in this package.
+
+   "You" is the person or organization that accepts these terms.
+
+   "Your company" is the organization you work for, and the organizations
+   that control it, that it controls, or that are under common control
+   with it.
+
+   "Your application" is software or a service that you build and that
+   does more than give access to the Software. Your application is not a
+   work based on the Software just because it uses the Software.
+
+2. Acceptance
+
+   By installing, copying or using the Software you accept these terms.
+   If you do not accept them, do not use the Software.
+
+3. What you may do
+
+   KOBIL grants you and your company a non-exclusive, worldwide,
+   non-transferable license, free of charge, to:
+
+   a. install and use the Software, unchanged, to build, test and run your
+      applications, including commercial ones that you charge for;
+   b. make the copies of the Software that this needs, for example on
+      developer machines, on build servers and in your application's
+      environments;
+   c. ship the Software, unchanged, as part of your application, for
+      example inside its container image, package or bundle.
+
+   Your company's employees and contractors may do the same on your
+   company's behalf.
+
+   Building your application with tools such as bundlers, minifiers,
+   transpilers or compilers is not a change to the Software. Using AI
+   coding tools to write applications that use the Software is allowed.
+
+4. Shipping the Software inside your application
+
+   When you ship the Software as part of your application:
+
+   a. the Software must be needed for your application to work, and must
+      not be offered as a library, SDK or tool of its own;
+   b. the people who receive your application get no right to use the
+      Software apart from your application;
+   c. keep this license and the copyright notice with the Software, or in
+      your application's third-party notices.
+
+5. What you may not do
+
+   You may not:
+
+   a. change, adapt or translate the Software, or make works based on it;
+   b. copy the Software's code, or substantial parts of it, into other
+      software, whether by hand or with automated or AI tools, or use the
+      Software to train AI models;
+   c. publish, share, sublicense, sell, rent or lease the Software on its
+      own, or as part of another SDK, library, framework or developer
+      tool;
+   d. remove or change this license or any copyright notice in the
+      Software;
+   e. use the Software to break the law, or to suggest that KOBIL endorses
+      your application.
+
+   These limits apply to the Software itself. You may sell and
+   commercially distribute your application.
+
+6. KOBIL services
+
+   The Software can connect to KOBIL services. Using those services is
+   governed by their own terms, not by this license. This license does not
+   give you access to any KOBIL service.
+
+7. Ownership
+
+   KOBIL keeps all rights in the Software that this license does not
+   expressly grant. This license gives you no right to KOBIL's names,
+   logos or trademarks, except to say truthfully that your application
+   uses the Software.
+
+8. Other software
+
+   The Software uses third-party open-source packages. Each of them is
+   covered by its own license, not by this one.
+
+9. New versions
+
+   KOBIL may release new versions of the Software under a new version of
+   this license. Each copy of the Software is covered by the license that
+   came with it.
+
+10. Violations
+
+   If you break these terms, KOBIL may tell you so in writing. The first
+   time this happens, your license continues if, within 30 days of that
+   notice, you fully comply again and take practical steps to correct past
+   violations. Otherwise, and after any later violation, your license
+   ends. You must then stop using and shipping the Software.
+
+11. No warranty
+
+   As far as the law allows, the Software comes "as is", without any
+   warranty or condition, express or implied, including fitness for a
+   particular purpose and non-infringement.
+
+12. Limitation of liability
+
+   As far as the law allows, KOBIL is not liable for any damages that come
+   from these terms or from using, or not being able to use, the Software,
+   under any kind of legal claim.
+
+13. Other permissions
+
+   For any use these terms do not allow, ask KOBIL for written permission
+   at www.kobil.com.

kobil_aitrust-1.2.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.5
+Name: kobil-aitrust
+Version: 1.2.0
+Summary: KOBIL AI Trust Platform — unified meta-package wrapping SDK and Audit into a simple developer-facing API
+License-Expression: LicenseRef-KOBIL-Agent-Trust-SDK-1.0
+License-File: LICENSE
+Keywords: agent,ai,audit,ciba,fga,kobil,mfa,oauth,security,trust
+Requires-Python: >=3.10
+Requires-Dist: kobil-agent-sdk<4,>=3.0
+Requires-Dist: mcp>=2.0.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20; extra == 'all'
+Requires-Dist: kobil-agent-audit<4,>=3.0; extra == 'all'
+Requires-Dist: openai>=1.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20; extra == 'anthropic'
+Provides-Extra: audit
+Requires-Dist: kobil-agent-audit<4,>=3.0; extra == 'audit'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# kobil-aitrust (Python)
+
+Python mirror of the `@uveysservetoglu/kobil-aitrust` TypeScript meta-package — wraps the SDK
+and Audit packages into a single developer-facing API via `AITrust()`.
+
+Behavioral 1:1 port of the TypeScript package in `../src`. The TypeScript
+source is the reference specification.
+
+## Dependency note
+
+`AITrust()` constructs a `KobilAI` from `kobil_agent_sdk` (the agent-sdk port).
+That dependency is resolved lazily through `kobil_aitrust.trust._make_kobil_ai`
+so the package imports without agent-sdk installed and so tests can inject a
+fake — mirroring the TS `vi.mock('@uveysservetoglu/kobil-agent-sdk')`. Audit is resolved
+the same way via `_import_audit_cls`.
+
+## Install (dev)
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Test
+
+```bash
+pytest
+```
+
+## Usage
+
+```python
+import asyncio
+from kobil_aitrust import AITrust, AITrustConfig
+
+ai = AITrust(AITrustConfig(platform_url="https://trust.kobil.com", client_id="my-agent"))
+
+@ai.tool  # or: secured = ai.tool(fn, ToolOptions(name="get_weather", scopes=["weather:read"]))
+async def get_weather(city, ctx):
+    return "sunny"
+```

kobil_aitrust-1.2.0/README.md

@@ -0,0 +1,41 @@
+# kobil-aitrust (Python)
+
+Python mirror of the `@uveysservetoglu/kobil-aitrust` TypeScript meta-package — wraps the SDK
+and Audit packages into a single developer-facing API via `AITrust()`.
+
+Behavioral 1:1 port of the TypeScript package in `../src`. The TypeScript
+source is the reference specification.
+
+## Dependency note
+
+`AITrust()` constructs a `KobilAI` from `kobil_agent_sdk` (the agent-sdk port).
+That dependency is resolved lazily through `kobil_aitrust.trust._make_kobil_ai`
+so the package imports without agent-sdk installed and so tests can inject a
+fake — mirroring the TS `vi.mock('@uveysservetoglu/kobil-agent-sdk')`. Audit is resolved
+the same way via `_import_audit_cls`.
+
+## Install (dev)
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Test
+
+```bash
+pytest
+```
+
+## Usage
+
+```python
+import asyncio
+from kobil_aitrust import AITrust, AITrustConfig
+
+ai = AITrust(AITrustConfig(platform_url="https://trust.kobil.com", client_id="my-agent"))
+
+@ai.tool  # or: secured = ai.tool(fn, ToolOptions(name="get_weather", scopes=["weather:read"]))
+async def get_weather(city, ctx):
+    return "sunny"
+```

kobil_aitrust-1.2.0/kobil_aitrust/__init__.py

@@ -0,0 +1,88 @@
+"""kobil-aitrust — unified meta-package for the KOBIL AI Trust Platform (Python).
+
+Python mirror of ``@uveysservetoglu/kobil-aitrust``. Wraps the SDK and Audit packages
+into a simple developer-facing API via the :func:`AITrust` factory.
+"""
+
+from __future__ import annotations
+
+from .config import AITrustConfig
+from .define_tool import (
+    SecuredTool,
+    ToolDefinition,
+    ToolExecute,
+    ToolInput,
+    define_tool,
+    register_tools,
+    to_anthropic_tools,
+    to_openai_tools,
+)
+from .errors import (
+    AITrustError,
+    ApprovalDenied,
+    ApprovalTimeout,
+    ConfigurationError,
+    NotAuthenticated,
+    NotAuthorized,
+    UntrustedAgent,
+    get_error_code,
+    is_aitrust_error,
+)
+from .integrations import (
+    secure_anthropic_client,
+    secure_langchain_model,
+    secure_openai_client,
+    secure_vercel_ai,
+)
+from .trust import (
+    AITrust,
+    AITrustInstance,
+    ApprovalOptions,
+    ToolContext,
+    ToolOptions,
+    detect_client_framework,
+    detect_framework,
+)
+
+# The release pipeline stamps the version into pyproject.toml only, so read it back from the installed metadata.
+from importlib.metadata import PackageNotFoundError as _PackageNotFoundError, version as _version
+
+try:
+    __version__ = _version("kobil-aitrust")
+except _PackageNotFoundError:  # running from a source checkout that is not installed
+    __version__ = "0.0.0"
+
+__all__ = [
+    "AITrust",
+    "AITrustInstance",
+    "AITrustConfig",
+    "ToolOptions",
+    "ToolContext",
+    "ApprovalOptions",
+    "detect_framework",
+    "detect_client_framework",
+    # define-tool
+    "ToolDefinition",
+    "SecuredTool",
+    "ToolExecute",
+    "ToolInput",
+    "define_tool",
+    "register_tools",
+    "to_anthropic_tools",
+    "to_openai_tools",
+    # errors
+    "AITrustError",
+    "NotAuthenticated",
+    "NotAuthorized",
+    "ApprovalDenied",
+    "ApprovalTimeout",
+    "UntrustedAgent",
+    "ConfigurationError",
+    "is_aitrust_error",
+    "get_error_code",
+    # integrations
+    "secure_langchain_model",
+    "secure_openai_client",
+    "secure_anthropic_client",
+    "secure_vercel_ai",
+]

kobil_aitrust-1.2.0/kobil_aitrust/_mcp_bridge.py

@@ -0,0 +1,219 @@
+"""Loopback MCP bridge (A-E3) — for runtimes that accept only STATIC MCP headers
+(Claude Agent SDK, ADK-TS) and so cannot refresh a Bearer in-code.
+
+A tiny local MCP reverse-proxy: it is an MCP *server* to the runtime (on an ephemeral
+`127.0.0.1` port) and an MCP *client* to the real broker. It holds the
+`BrokerBearerProvider` and injects a fresh Bearer on every forwarded call — invisibly,
+so the runtime's static config never carries (or can leak) the token.
+
+Hardening (plan A-E3):
+* bound to `127.0.0.1` only; requests from a non-loopback client are refused;
+* a 256-bit in-memory secret, checked constant-time, gates the MCP path (so another
+  local process can't drive the bridge);
+* the secret lives only in memory and in the runtime's in-process config — never in
+  argv, logs, or a URL;
+* `dispose()` is idempotent and stops the server with the process.
+
+This module is imported lazily (only when `create_claude_broker_mcp` is called), so
+kobil-aitrust keeps no hard dependency on `mcp`/`uvicorn`.
+"""
+from __future__ import annotations
+
+import hmac
+import json
+import secrets
+import socket
+import threading
+import time
+from typing import Any
+
+BRIDGE_SECRET_HEADER = "x-aitrust-bridge-secret"
+_READY_PATH = "/_bridge_ready"
+_MCP_PATH = "/mcp"
+_LOOPBACK = {"127.0.0.1", "::1"}
+# Connect / write / pool budget for the broker leg — the mcp library's own default.
+_CONNECT_TIMEOUT_S = 30.0
+
+
+class _BrokerForwardClient:
+    """Forwards list/call to the real broker over a fresh connection carrying a fresh
+    Bearer. Mirrors the broker's own per-call upstream client, but INJECTS auth."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        provider: Any,
+        *,
+        tool_timeout_s: float | None = None,
+        end_user: Any = None,
+        approver: Any = None,
+    ) -> None:
+        from .mcp_broker import DEFAULT_TOOL_TIMEOUT_S
+
+        self._endpoint = endpoint
+        self._provider = provider
+        self._tool_timeout_s = tool_timeout_s or DEFAULT_TOOL_TIMEOUT_S
+        # Resolved per call, not here: a callable has to be consulted at the moment of the
+        # call, or a server handling several people pins whoever came first.
+        self._end_user = end_user
+        # Who the agent names to approve a held call (Revision 14); resolved per call too.
+        self._approver = approver
+
+    async def _session(self):
+        import httpx2
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamable_http_client
+
+        token = await self._provider.token()
+        # The read timeout must outlast the broker's approval hold: a CIBA-gated call
+        # is answered only after a human decides (up to max_approval_wait_s = 120 s),
+        # and nothing is sent meanwhile. httpx2's 5 s default cut every held call —
+        # and a slow allow call — before the broker could answer. Passing our own
+        # client also drops the mcp library's 300 s SSE default, so set it here.
+        timeout = httpx2.Timeout(_CONNECT_TIMEOUT_S, read=self._tool_timeout_s)
+        from .mcp_broker import approver_headers, end_user_headers
+
+        hc = httpx2.AsyncClient(
+            headers={"Authorization": f"Bearer {token}", **end_user_headers(self._end_user),
+                     **approver_headers(self._approver)},
+            timeout=timeout,
+        )
+        return hc, streamable_http_client, ClientSession
+
+    async def list_tools(self):
+        hc, factory, ClientSession = await self._session()
+        async with hc:
+            async with factory(self._endpoint, http_client=hc) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    return await session.list_tools()
+
+    async def call_tool(self, name: str, arguments: dict | None):
+        hc, factory, ClientSession = await self._session()
+        async with hc:
+            async with factory(self._endpoint, http_client=hc) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    return await session.call_tool(name, arguments or {})
+
+
+class LoopbackBridge:
+    def __init__(self, *, endpoint: str | None = None, provider: Any = None, backend: Any = None,
+                 tool_timeout_s: float | None = None, end_user: Any = None, approver: Any = None) -> None:
+        if backend is None and (endpoint is None or provider is None):
+            raise ValueError("endpoint/provider or backend is required")
+        self._forward = backend or _BrokerForwardClient(
+            endpoint, provider, tool_timeout_s=tool_timeout_s, end_user=end_user, approver=approver
+        )
+        self._secret = secrets.token_urlsafe(32)  # 256-bit
+        self._port = _free_loopback_port()
+        self._server = None
+        self._thread: threading.Thread | None = None
+        self._disposed = False
+
+    # -- public surface -----------------------------------------------------------
+    @property
+    def url(self) -> str:
+        return f"http://127.0.0.1:{self._port}{_MCP_PATH}"
+
+    @property
+    def secret(self) -> str:
+        return self._secret
+
+    def start(self, *, ready_timeout_s: float = 10.0) -> "LoopbackBridge":
+        import httpx2
+        import uvicorn
+
+        app = self._build_app()
+        config = uvicorn.Config(app, host="127.0.0.1", port=self._port, log_level="warning")
+        self._server = uvicorn.Server(config)
+        self._thread = threading.Thread(target=self._server.run, daemon=True)
+        self._thread.start()
+
+        deadline = time.monotonic() + ready_timeout_s
+        while time.monotonic() < deadline:
+            try:
+                if httpx2.get(f"http://127.0.0.1:{self._port}{_READY_PATH}", timeout=0.3).status_code == 200:
+                    return self
+            except Exception:
+                time.sleep(0.05)
+        self.dispose()
+        raise RuntimeError("loopback bridge did not become ready")
+
+    def dispose(self) -> None:
+        if self._disposed:
+            return
+        self._disposed = True
+        if self._server is not None:
+            self._server.should_exit = True
+        if self._thread is not None:
+            self._thread.join(timeout=5)
+
+    # -- server assembly ----------------------------------------------------------
+    def _build_app(self):
+        import mcp.types as t
+        from mcp.server.mcpserver import MCPServer
+        from starlette.requests import Request
+        from starlette.responses import JSONResponse
+
+        server = MCPServer(name="aitrust-broker-bridge", version="0.0.1")
+
+        @server.custom_route(_READY_PATH, methods=["GET"])
+        async def _ready(_request: Request) -> JSONResponse:
+            return JSONResponse({"status": "ready"})
+
+        async def _list(_ctx, _params):
+            return await self._forward.list_tools()
+
+        async def _call(_ctx, params):
+            try:
+                return await self._forward.call_tool(params.name, params.arguments)
+            except Exception as exc:  # forward failure surfaces as an MCP tool error
+                return t.CallToolResult(
+                    content=[t.TextContent(type="text", text=f"broker bridge error: {exc}")],
+                    is_error=True,
+                )
+
+        ll = server._lowlevel_server
+        ll.add_request_handler("tools/list", t.PaginatedRequestParams, _list)
+        ll.add_request_handler("tools/call", t.CallToolRequestParams, _call)
+
+        app = server.streamable_http_app(streamable_http_path=_MCP_PATH, host="127.0.0.1")
+        return _LoopbackGuard(app, secret=self._secret)
+
+
+class _LoopbackGuard:
+    """Pure-ASGI guard: MCP path requires a loopback client AND the constant-time secret.
+    The readiness route stays open (no secret) for local startup polling."""
+
+    def __init__(self, app, *, secret: str) -> None:
+        self._app = app
+        self._secret = secret
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "http":
+            path = scope.get("path", "")
+            if path == _MCP_PATH or path.startswith(_MCP_PATH + "/"):
+                client = scope.get("client") or ("", 0)
+                if client[0] not in _LOOPBACK:
+                    return await _deny(send, 403, "non_loopback")
+                headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope.get("headers", [])}
+                if not hmac.compare_digest(headers.get(BRIDGE_SECRET_HEADER, ""), self._secret):
+                    return await _deny(send, 401, "bad_bridge_secret")
+        return await self._app(scope, receive, send)
+
+
+async def _deny(send, status: int, reason: str) -> None:
+    body = json.dumps({"error": reason}).encode()
+    await send({"type": "http.response.start", "status": status,
+                "headers": [(b"content-type", b"application/json"), (b"content-length", str(len(body)).encode())]})
+    await send({"type": "http.response.body", "body": body})
+
+
+def _free_loopback_port() -> int:
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+    finally:
+        s.close()

kobil_aitrust-1.2.0/kobil_aitrust/config.py

@@ -0,0 +1,123 @@
+"""Config resolution for kobil-aitrust (mirror of src/config.ts).
+
+Note: ``create_kobil_ai_config`` returns a snake_case dict — the internal API
+contract for the Python KobilAI (agent-sdk). This differs from the TS camelCase
+only by naming convention; the resolution precedence (explicit → AITRUST_* env
+→ KOBIL_* env) is identical.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+
+@dataclass
+class AITrustConfig:
+    platform_url: Optional[str] = None
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    agent_id: Optional[str] = None
+    scopes: Optional[list[str]] = None
+    dpop: Optional[bool] = None
+    management_url: Optional[str] = None
+    audit_url: Optional[str] = None
+    idp_url: Optional[str] = None
+    proxy_url: Optional[str] = None
+    proxy_cert_path: Optional[str] = None
+    proxy_key_path: Optional[str] = None
+    audience: Optional[str] = None
+    api_token: Optional[str] = None
+    realm: Optional[str] = None
+    token_endpoint: Optional[str] = None
+    authorization_endpoint: Optional[str] = None
+    backchannel_auth_endpoint: Optional[str] = None
+    keycloak_token_url: Optional[str] = None
+    timeout_ms: Optional[int] = None
+    isolated: Optional[bool] = None
+    # () -> Optional[str] | Awaitable[Optional[str]]
+    secret_provider: Optional[Callable[[], Any]] = None
+    # (kobil_agent_sdk ApprovalPendingEvent) -> None | Awaitable[None]. Called once when a
+    # native tool call is held for approval, before the SDK starts waiting; observational.
+    # The MCP equivalent is attach_mcp(on_approval_pending=...).
+    on_approval_pending: Optional[Callable[[Any], Any]] = None
+
+
+def resolve_config_value(
+    explicit: Optional[str], aitrust_env: str, kobil_env: str, env: Optional[dict] = None
+) -> Optional[str]:
+    env = env if env is not None else os.environ
+    if explicit is not None:
+        return explicit
+    return env.get(aitrust_env) if env.get(aitrust_env) is not None else env.get(kobil_env)
+
+
+def resolve_local_config(config: Optional[AITrustConfig] = None, env: Optional[dict] = None) -> dict:
+    config = config or AITrustConfig()
+    env = env if env is not None else os.environ
+
+    def rv(explicit, a, k):
+        return resolve_config_value(explicit, a, k, env)
+
+    return {
+        "platform_url": rv(config.platform_url, "AITRUST_PLATFORM_URL", "KOBIL_PLATFORM_URL") or "",
+        "management_url": rv(config.management_url, "AITRUST_MANAGEMENT_URL", "KOBIL_MANAGEMENT_URL"),
+        "audit_url": rv(config.audit_url, "AITRUST_AUDIT_URL", "KOBIL_AUDIT_URL"),
+        "idp_url": rv(config.idp_url, "AITRUST_IDP_URL", "KOBIL_IDP_URL"),
+        "client_id": rv(config.client_id, "AITRUST_CLIENT_ID", "KOBIL_CLIENT_ID") or "",
+        "agent_id": rv(config.agent_id, "AITRUST_AGENT_ID", "KOBIL_AGENT_ID"),
+        "client_secret": rv(config.client_secret, "AITRUST_CLIENT_SECRET", "KOBIL_CLIENT_SECRET"),
+        "api_token": rv(config.api_token, "AITRUST_API_TOKEN", "KOBIL_API_TOKEN"),
+        "audience": rv(config.audience, "AITRUST_AUDIENCE", "KOBIL_AUDIENCE"),
+        "scopes": config.scopes,
+        "dpop": config.dpop,
+        "proxy_url": rv(config.proxy_url, "AITRUST_PROXY_URL", "KOBIL_PROXY_URL"),
+        "proxy_cert_path": rv(config.proxy_cert_path, "AITRUST_PROXY_CERT_PATH", "KOBIL_PROXY_CERT_PATH"),
+        "proxy_key_path": rv(config.proxy_key_path, "AITRUST_PROXY_KEY_PATH", "KOBIL_PROXY_KEY_PATH"),
+        "realm": rv(config.realm, "AITRUST_REALM", "KOBIL_REALM"),
+        "token_endpoint": rv(config.token_endpoint, "AITRUST_TOKEN_ENDPOINT", "KOBIL_TOKEN_ENDPOINT"),
+        "authorization_endpoint": rv(
+            config.authorization_endpoint, "AITRUST_AUTHORIZATION_ENDPOINT", "KOBIL_AUTHORIZATION_ENDPOINT"
+        ),
+        "backchannel_auth_endpoint": rv(
+            config.backchannel_auth_endpoint, "AITRUST_BACKCHANNEL_AUTH_ENDPOINT", "KOBIL_BACKCHANNEL_AUTH_ENDPOINT"
+        ),
+        "keycloak_token_url": rv(config.keycloak_token_url, "AITRUST_KEYCLOAK_TOKEN_URL", "KOBIL_KEYCLOAK_TOKEN_URL"),
+        "timeout_ms": config.timeout_ms,
+        "isolated": config.isolated,
+    }
+
+
+def create_kobil_ai_config(config: Optional[AITrustConfig] = None) -> dict:
+    resolved = resolve_local_config(config)
+    return {
+        "platform_url": resolved["platform_url"],
+        "management_url": resolved["management_url"],
+        "audit_url": resolved["audit_url"],
+        "idp_url": resolved["idp_url"],
+        "client_id": resolved["client_id"],
+        "agent_id": resolved["agent_id"],
+        "client_secret": resolved["client_secret"],
+        "api_token": resolved["api_token"],
+        "audience": resolved["audience"],
+        "scopes": resolved["scopes"],
+        "dpop_enabled": resolved["dpop"],
+        "timeout_ms": resolved["timeout_ms"],
+        "proxy_url": resolved["proxy_url"],
+        "proxy_cert_path": resolved["proxy_cert_path"],
+        "proxy_key_path": resolved["proxy_key_path"],
+        "realm": resolved["realm"],
+        "token_endpoint": resolved["token_endpoint"],
+        "authorization_endpoint": resolved["authorization_endpoint"],
+        "backchannel_auth_endpoint": resolved["backchannel_auth_endpoint"],
+        "keycloak_token_url": resolved["keycloak_token_url"],
+        "isolated": resolved["isolated"],
+        # Carried explicitly: this is a dict literal, so a key left out is silently dropped
+        # and the callback never fires. It is not configuration to resolve from the
+        # environment, so it comes straight from the config object.
+        "on_approval_pending": config.on_approval_pending if config else None,
+    }
+
+
+__all__ = ["AITrustConfig", "resolve_config_value", "resolve_local_config", "create_kobil_ai_config"]