Another PyPI package got compromised — here's why I stopped relying on multi-provider AI SDKs

The Telnyx Python SDK was compromised on PyPI today.

This is the second major AI/telecom SDK supply chain attack in two weeks. LiteLLM was hit before that.

If you haven't noticed the pattern yet, you should.

What happened with Telnyx

The Telnyx package on PyPI was backdoored. If you ran pip install telnyx in the last 24 hours, you may have pulled malicious code onto your machine.

Telnyx themselves confirmed it and are working on remediation.

This follows the LiteLLM supply chain attack from two weeks ago, where malicious code was injected into the LiteLLM package — an SDK used by thousands of AI applications.

The pattern is clear

Here's what these attacks have in common:

1. Complex dependency graphs — both LiteLLM and Telnyx SDKs pull in dozens of sub-packages
2. High-value targets — packages that touch AI APIs or communications are goldmines for attackers
3. Trusted by CI/CD pipelines — pip install in automated build systems means instant, silent deployment
4. Difficult to audit — multi-provider abstraction layers have massive codebases

The bigger the dependency surface, the bigger the attack surface.

Why I switched to a single HTTP call

After the LiteLLM attack, I rebuilt my AI integration around a single API endpoint with zero external SDK dependencies:

curl -X POST https://simplylouie.com/api/chat \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "What is the capital of France?"}'

That's it. One HTTPS call. No SDK. No pip package. No dependency tree to audit.

# Python version — no external packages needed
import urllib.request
import json

data = json.dumps({"message": "Hello"}).encode()
req = urllib.request.Request(
    "https://simplylouie.com/api/chat",
    data=data,
    headers={
        "Authorization": "Bearer YOUR_KEY",
        "Content-Type": "application/json"
    }
)

with urllib.request.urlopen(req) as response:
    result = json.loads(response.read())
    print(result["reply"])

Standard library only. Nothing to compromise via PyPI.

The real cost of complexity

Developers often reach for SDKs because they seem easier. But:

• LiteLLM: 50,000+ lines of code, 40+ AI providers, massive attack surface
• Telnyx SDK: complex Python package with transitive dependencies
• My approach: one HTTPS POST to one endpoint

Simplicity isn't just aesthetically pleasing — it's a security property.

What I'd recommend

Audit your requirements.txt right now. If you have LiteLLM, Telnyx, or any AI/telecom SDK:

# Check for suspicious packages
pip list | grep -E '(litellm|telnyx|anthropic|openai)'

# Review what version you're actually running
pip show litellm

Consider whether you actually need the full SDK. If you're only calling one AI provider, a direct HTTP call is both simpler and more secure.

Pin your dependencies. Use exact version pinning in production:

# requirements.txt
requests==2.31.0  # not requests>=2.0

Monitor for compromise notices. Subscribe to PyPI security advisories.

The $2/month alternative

I built SimplyLouie as a single-endpoint Claude API proxy specifically because I wanted to:

1. Avoid complex multi-provider SDK dependency hell
2. Offer a stable, auditable API surface
3. Keep costs predictable ($2/month flat, no per-token surprises)

One endpoint. One provider (Claude). One line in your config.

And critically — zero PyPI packages for users to install.

The LiteLLM attack cost some teams days of incident response. The Telnyx attack is happening right now.

Every attack like this is an argument for simplicity.

---

SimplyLouie is a $2/month Claude API proxy. No SDK required — just a curl command. Try it free for 7 days.