Is litellm safe?

value = eval(source)

exec(compiled, exec_globals)  # noqa: S102

exec(compiled, exec_globals)  # noqa: S102

"out of URLs and access logs. Example api_key='d534…[redacted, 64 chars]'"

"Example api_key='d534…[redacted, 64 chars]'"

subprocess.check_call([sys.executable, "-m", "pip", "install", "supabase"])

subprocess.check_call([sys.executable, "-m", "pip", "install", "sentry_sdk"])

subprocess.check_call([sys.executable, "-m", "pip", "install", "slack_bolt"])

return subprocess.run(command, env=dict(env), check=False).returncode

return subprocess.Popen(
            [
                sys.executable,
                "-m",
                "litellm.proxy.proxy_cli",
                "--config",
                str(config_path),
                "--port", …

result: Final = subprocess.run(("codex", "--version"), capture_output=True, text=True, timeout=5, check=False)

output: Final = subprocess.run(
            (binary, "--version"), capture_output=True, text=True, check=False, timeout=10
        ).stdout

process: Final = subprocess.Popen(self.argv)

result: Final = subprocess.run(resolve_prisma_argv(("prisma", "generate")), capture_output=True, text=True)

process: Final = subprocess.Popen(
        (
            sys.executable,
            "-m",
            "litellm.proxy.prometheus_metrics_server",
            "--host",
            host,
            "--port",
            str(port), …

subprocess.Popen(command, stdout=devnull, stderr=devnull)

subprocess.Popen(command, stdout=devnull, stderr=devnull)

"0.0.0.0",

_IPV4_LOCAL_ADDRESS: Final = "0.0.0.0"

- if litellm.force_ipv4 is True, it will return AsyncHTTPTransport with local_address="0.0.0.0"

"local_addr": ("0.0.0.0", 0) if litellm.force_ipv4 else None,

- If force_ipv4 is True, it will create an AsyncHTTPTransport with local_address set to "0.0.0.0"

``python -m litellm.proxy.prometheus_metrics_server --host 0.0.0.0 --port 4001``.

_WILDCARD_TO_LOOPBACK: Final = MappingProxyType({"0.0.0.0": "127.0.0.1", "::": "::1"})

parser.add_argument("--host", default="0.0.0.0")

@click.option("--host", default="0.0.0.0", help="Host for the server to listen on.", envvar="HOST")

with open(path, encoding="utf-8") as lines:

files("litellm").joinpath("anthropic_beta_headers_config.json").read_text(encoding="utf-8")

with open("user_cost.json", "r") as json_file:

with open(config_path) as f:

content: Final = file_path.read_text(encoding="utf-8")

content: Final = file_path.read_text(encoding="utf-8")

with open(json_path, "r") as f:

with open(file_path, "rb") as f:

with open(str(content), "rb") as f:

with open(str(file_content_obj), "rb") as f:

return open(file_path, "rb")

with open(str(file), "rb") as f:

raw: Final = Path(get_cli_token_file_path()).read_text()

content: Final = json.loads(files("litellm").joinpath("blog_posts.json").read_text(encoding="utf-8"))

return files("litellm").joinpath("model_prices_and_context_window_backup.json").read_bytes()

with open(file_content, "rb") as f:

return HuggingFaceTokenizer.from_str(Path(path).read_text(encoding="utf-8"))

with open(web_identity_token_file, "r") as f:

with open(str(file_content), "rb") as f:

with open(str(file_content), "rb") as f:

with open(image, "rb") as f:

with open(self.auth_file, "r") as f:

with open(config_path) as f:

return Path(image).read_bytes()

with open(self.access_token_file, "r") as f:

with open("user_cost.json", "w") as json_file:

Path(path).write_text(self.to_str(pretty), encoding="utf-8")

with open(self.auth_file, "w") as f:

with open(self.access_token_file, "w") as f:

with open(self.api_key_file, "w") as f:

with open(local_path, "wb") as f:

os.unlink(local_requirements_path)

os.unlink(tmp_path)

os.unlink(tmp_path)

with open(cert_path, "w") as f:

with open(key_path, "w") as f:

os.unlink(tmp_file)

snapshot_file.write_text(json.dumps(result.fragments, indent=2, sort_keys=True) + "\n")

with open(log_path, "w") as log_file:

with open(resolved_path, "w") as f:

with open(filename, "w") as f:

path.write_text(report, encoding="utf-8")

path.write_text(SLASH_COMMAND_BODY, encoding="utf-8")

os.unlink(tmp_name)

with open(local_file_path, "w") as f:

with open(local_file_path, "w") as f:

with open(os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "w", encoding="utf-8") as handle:

shutil.copyfile(plan.ca_source, ca_path)

register_exit_hook(_only_in_this_process(lambda: shutil.rmtree(runtime_dir, ignore_errors=True)))

with open(path, "w", encoding="utf-8") as handle:

(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,312130,e=>{"use strict";var t=e.i(843476),l=e.i(271645),a=e.i(519455),o=e.i(515288),s=e.i(793479),r=e.i(110204),n=e.i(571303),i= …

`;t.document.write(a),t.document.close(),t.onload=()=>{t.print()}})(e),children:[(0,t.jsx)(G.FileText,{}),"Export as PDF"]}),(0,t.jsxs)(U.DropdownMenuItem,{onClick:()=>(e=>{let t=e.entries.filter(e=>null!==e.result),s=[["LLM Multi-Model Cos …

}'`}),(0,t.jsx)("p",{className:"mb-2 mt-3 text-xs text-muted-foreground",children:"Look for these headers in the response:"}),(0,t.jsxs)("div",{className:"space-y-1.5",children:[(0,t.jsxs)("div",{className:"flex items-start gap-3",children: …

}`,em=({visible:e,initialJson:r,onSave:n,onClose:a})=>{let[l,o]=(0,s.useState)(r||ed),[i,c]=(0,s.useState)(null),d=()=>{c(null),a()};return(0,t.jsx)(q.Dialog,{open:e,onOpenChange:e=>!e&&d(),children:(0,t.jsxs)(q.DialogContent,{className:"ma …

(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,180127,e=>{"use strict";let t=(0,e.i(475254).default)("arrow-left",[["path",{d:"m12 19-7-7 7-7",key:"1l729n"}],["path",{d:"M19 1 …

import httpx

import httpx

import httpx

self.response = response or httpx.Response(
            status_code=self.status_code,
            request=httpx.Request(method="POST", url="https://litellm.ai"),
        )

request=httpx.Request(method="POST", url="https://litellm.ai"),

import httpx

import httpx

response: Final = httpx.get(url, timeout=timeout)

import httpx

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="delete_assistant", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="delete_assistant", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

response=httpx.Response(
                status_code=400,
                content="Unsupported provider",
                request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),
            ),

request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"),

id_token: Final = auth_data.get("id_token")

derived: Final = self._extract_account_id(_optional_str(id_token or access_token))

"grant_type=authorization_code"

id_token: Final = _optional_str(data.get("id_token"))

if not access_token or not refresh_token or not id_token:

"id_token": id_token,

"grant_type": "refresh_token",

id_token: Final = _optional_str(data.get("id_token"))

if not access_token or not id_token:

"id_token": id_token,

id_token: Final = tokens.get("id_token")

account_id: Final = self._extract_account_id(id_token or access_token)

"id_token": id_token,

XAI_OAUTH_DISCOVERY_URL: Final = f"{XAI_OAUTH_ISSUER}/.well-known/openid-configuration"

id_token: ReadOnly[str | None]

id_token: NotRequired[ReadOnly[str | None]]

authorization_endpoint: NotRequired[ReadOnly[str]]

authorization_endpoint=discovery["authorization_endpoint"],

"grant_type": "authorization_code",

authorization_endpoint: Final = data.get("authorization_endpoint")

if not authorization_endpoint or not token_endpoint:

"authorization_endpoint": self._validate_xai_endpoint(authorization_endpoint),

authorization_endpoint: str,

return f"{authorization_endpoint}?{urlencode(params)}"

"id_token": token_payload.get("id_token"),

DefaultAzureCredential,

ManagedIdentityCredential,

return ManagedIdentityCredential(client_id=_client_id)

return DefaultAzureCredential()

from azure.identity import DefaultAzureCredential

DefaultAzureCredential as AsyncDefaultAzureCredential,

credential=DefaultAzureCredential(),

"""Call STS AssumeRole and return temporary credentials."""

sts_response: Final = sts_client.assume_role(

6. From DefaultAzureCredential

# Try to get token provider from service principal or DefaultAzureCredential

"Using Azure AD token provider based on Service Principal with Secret workflow or DefaultAzureCredential for Azure Auth"

# try to get DefaultAzureCredential provider

Try to get DefaultAzureCredential provider

Token provider callable if DefaultAzureCredential is enabled and available, None otherwise

verbose_logger.debug("Attempting to use DefaultAzureCredential for Azure Auth")

azure_credential=AzureCredentialType.DefaultAzureCredential,

verbose_logger.debug("Successfully obtained Azure AD token provider using DefaultAzureCredential")

verbose_logger.debug("DefaultAzureCredential failed: %s", e)

DefaultAzureCredential source) and the token is minted automatically

f"AZURE_CLIENT_SECRET / AZURE_TENANT_ID or any DefaultAzureCredential source) "

federated token, username/password, or `DefaultAzureCredential` / managed identity.

# ``_get_default_ttl_for_boto3_credentials`` (~59 minutes); AssumeRole STS credentials expire with

``_auth_with_env_vars`` (including when skipping AssumeRole because the runtime identity

non-refreshable ``Credentials`` cached ~59 min, inside the 3600s STS session), and AssumeRole

"tools": {

server.add_request_handler("tools/list", PaginatedRequestParams, handle_list_tools)

server.add_request_handler("tools/call", CallToolRequestParams, mcp_server_tool_call)