llm 0.37.2 Fixes Two Paths That Sent OpenAI Keys to Other Providers
Simon Willison’s llm 0.37.2 fixes two security flaws that could send an OpenAI API key to a different provider. The November 11 release addresses specific custom endpoint configurations reported by Daniel de Araujo. The tension is straightforward: choosing another model provider should not silently transfer credentials belonging to OpenAI.
LLM, a command-line application for accessing language models, supports services that accept OpenAI-style requests. That compatibility lets developers change providers while keeping familiar workflows. But request compatibility and permission to receive a credential are separate decisions. These bugs allowed the former to undermine the latter.
The immediate pressure falls on developers and teams using custom endpoints, the server addresses receiving their model requests. Their question is narrower than whether LLM is generally safe: did an affected configuration send an unintended key? Answering requires separating the patched software behavior from any historical exposure.
What llm 0.37.2 Actually Changed
The release fixes credential selection in particular custom endpoint paths, rather than announcing a compromise affecting every user.
Willison’s security release credits de Araujo with identifying both problems. One involved a missing provider-specific key. The other appeared when a model configured for one request interface switched to another. Both could direct an OpenAI credential toward a server chosen for another purpose.
The configuration context matters. LLM uses extra-openai-models.yaml, a settings file describing additional models, to connect with OpenAI-compatible services. Those services accept requests resembling OpenAI’s interface. Their compatibility does not make them OpenAI, and it does not authorize them to receive an OpenAI account credential.
Willison also identifies llm openai endpoint add, introduced in version 0.37, as a newer way to manage these endpoints. That convenience feature explains the current product context. It does not establish when either vulnerability began, and readers should avoid treating the latest endpoint command as the origin of every affected path.
The release record identifies the patched version. The linked advisories provide the more useful boundaries for exposure assessment. A release number answers which update contains the repair. Configuration details answer whether a particular workflow encountered the vulnerable behavior.
That distinction prevents two misleading readings. The first treats every request from an older installation as a leaked credential. The second assumes that an ordinary-looking model response establishes correct authentication. Neither conclusion follows from the disclosures. Credential routing requires its own evidence, separate from the quality or success of generated text.
The patch also changes the interpretation of a configuration mistake. A missing provider key should create a visible authentication problem. It should not quietly recruit an available credential associated with another service. The important improvement is preserving the intended relationship between a destination and the key permitted to accompany it.
For developers evaluating the release, this is more consequential than a routine compatibility adjustment. The affected behavior crossed a credential boundary without requiring users to deliberately share that credential. The repair therefore deserves attention even when the original model task seemed harmless, such as generating a brief response from a test endpoint.
Two Credential Paths Failed in Different Ways
The advisories describe separate failure conditions, so their affected versions and authentication behavior should remain distinct.
The missing-key advisory covers versions from 0.6 through releases before 0.37.2. A custom model specified api_base, its destination address, and api_key_name, its credential alias. When the named credential was absent, resolution could fall back to OPENAI_API_KEY, an environment variable holding a key.
That failure turned an incomplete configuration into an unintended credential transfer. The advisory also identifies broader precedence behavior in versions 0.6 through 0.7.1, corrected in 0.8. The current repair addresses the remaining missing-key case. An alias looking correct in a configuration file did not establish that its corresponding secret existed.
The request-delegation advisory covers versions from 0.32a2 through releases before 0.37.2. It concerns a custom api_base model with responses: true, selecting the Responses request interface. Running it with -o chat_completions 1 switched to Chat Completions, another request interface, and could restore OpenAI credential defaults.
In that documented path, the credential could come from the environment or LLM’s stored OpenAI key. A configured and stored provider-specific key avoided the delegation leak described there. Both advisories classify their issues as Moderate and identify 0.37.2 as patched. Those ratings do not establish how many installations encountered either condition.
The technical distinction is useful because the mistakes challenge different assumptions. The missing-key case asks what happens when configuration names a secret that cannot be found. The delegation case asks whether authentication rules survive when execution moves into another internal component. A correct answer to one question does not settle the other.
Consider a hypothetical developer moving a workflow to another computer. The model configuration arrives, but the provider credential does not. A working OpenAI credential remains available in the environment. The security expectation is that the missing provider secret blocks or limits the request, rather than changing which account credential leaves the machine.
Now consider a separate hypothetical workflow that changes request interfaces to accommodate a server. The destination remains the same, and the user expects the credential policy to remain stable. An internal switch should not silently reinterpret a missing key as permission to use a different provider’s credential.
These examples explain why a successful response makes a poor security test. Generated output primarily tells the user that some request completed. It does not reveal every authentication decision made along the way. A harmless prompt can therefore accompany a credential-routing problem without producing an obviously suspicious answer.
Provider Flexibility Creates a Separate Security Obligation
OpenAI compatibility describes how requests work; it does not define which credentials a server should receive.
The broader conflict is between convenient provider switching and explicit credential boundaries. Developers benefit when an application can address multiple model services through familiar request formats. The security burden appears when that convenience carries inherited defaults across destinations. An available secret becomes dangerous when availability substitutes for authorization.
LLM’s custom model configuration documents the product’s support for additional model endpoints. That flexibility is the useful feature behind this incident. Removing provider choice would avoid the particular routing problem by shrinking the product, but it would also discard the workflow users selected it to support.
Ollama offers a relevant comparison because its OpenAI compatibility documentation also describes connecting OpenAI clients to another model service. Its local examples supply a placeholder key that the local server ignores. Its direct cloud example instead selects an Ollama credential. Similar request syntax can therefore accompany different authentication expectations.
That comparison does not establish an equivalent vulnerability in Ollama. It illustrates why provider compatibility needs separate credential decisions. A client can reuse a request format while explicitly selecting a destination and its intended secret. The security question concerns the relationship among those choices, rather than which product offers the most models.
For a developer, changing a server address often feels like a transport adjustment. For a credential, it changes the recipient. Those perspectives must meet somewhere in the application’s behavior. Otherwise, a convenience setting can alter the trust relationship while looking like an ordinary model-selection preference.
This is also why the intended recipient matters independently of the prompt. A user might willingly send a public paragraph to an experimental service. That choice does not imply permission to send an account credential there. Content sensitivity and credential sensitivity require separate assessments, even when they travel within the same request.
The same reasoning applies when the destination belongs to the user’s organization. Internal ownership can make a server an appropriate place for model traffic without making every available secret appropriate for transmission. Different teams, retention practices, and operational responsibilities still create boundaries worth preserving.
For enterprise buyers, the useful evaluation question becomes concrete: does changing a provider preserve explicit control over authentication? A demonstration that swaps model names and produces good answers cannot resolve that question. Buyers need evidence about destination-specific credential behavior, including what happens when expected configuration is incomplete.
The architectural lesson is therefore narrower and more actionable than distrust of compatibility layers. Provider flexibility remains useful. It needs authentication rules that travel with the intended destination and survive changes in request handling. Convenience becomes safer when a missing decision stays missing instead of acquiring a permissive default.
Developers Must Separate Updating From Exposure Review
Installing the repair addresses future behavior; understanding earlier requests requires a separate review of the affected workflow.
For users assessing llm 0.37.2, the first distinction is between software state and historical events. A patched installation can stop reproducing a disclosed flaw. That result does not establish what an older installation transmitted. Conversely, an older version alone does not establish that a vulnerable configuration ever ran.
A proportionate review starts with the relevant model configuration and execution context. The useful evidence connects a software version, a destination, a credential source, and the options used. Without that connection, teams risk replacing a specific disclosure with a general assumption that every developer machine experienced the same event.
The work becomes organizational when the same workflow exists in several places. A laptop, an automated job, and a shared development environment can hold different secrets despite using similar configuration files. Treating them as interchangeable obscures the exact condition under review. The deployment context matters as much as the model’s display name.
Credential rotation addresses another question: whether an existing secret should remain usable after suspected exposure. It does not substitute for correcting the routing behavior. A replacement credential placed into an unchanged vulnerable environment could recreate the underlying problem. Remediation decisions should connect the software repair with the evidence about earlier transmission.
If review establishes unintended disclosure, invalidating the affected credential limits its continued usefulness. That action should remain separate from claims about misuse. A team can respond to a disclosed secret without asserting that another party exploited it. Clear language supports decisive action while preserving an accurate incident record.
Teams should also avoid turning an investigation into another disclosure channel. The evidence they need is usually about which credential source a request selected and where it went. Copying complete secrets into tickets or shared notes creates additional handling obligations without necessarily clarifying the original event.
A useful incident record explains the finding, the affected environment, the remediation, and the unresolved questions. Keeping those details in a searchable engineering knowledge base can help colleagues understand why a workflow changed. The record should preserve reasoning and configuration context rather than credential values.
For maintainers of internal tools, the release also offers a review target beyond this package. Any application that combines configurable destinations with default credentials deserves scrutiny at that boundary. That is an engineering inference from the disclosed failure patterns, not evidence that another application shares these vulnerabilities.
The immediate priority remains specific: identify affected LLM workflows, move them to a patched release, and assess credible exposure. Expanding the investigation should follow evidence. A narrowly framed security issue can justify careful action without becoming a claim that every compatible model client requires an emergency rebuild.
The Disclosures Establish a Bug, Not Widespread Exploitation
A reproducible credential-routing flaw establishes a real security failure, but it does not measure the scale of real-world misuse.
The disclosures support concern about unintended transmission under identified conditions. They do not provide a population-wide count of affected users or establish a coordinated exploitation campaign. Those are different kinds of findings. A technical reproduction can demonstrate a failure without revealing how often that failure occurred outside the test.
The skeptical question is therefore about scope. Which installations held the relevant credentials, used the affected configuration, and executed the triggering path? Public disclosure cannot answer that for every user. Individual environments supply evidence that a general release announcement cannot, including whether the destination was external, internal, or local.
Several outcomes remain possible after a credential reaches an unintended recipient. Receipt alone differs from retention, later access, or misuse. Each additional claim needs supporting evidence. Reporting that collapses those stages makes the incident sound more certain while making its practical implications harder to assess.
The opposite error also deserves attention. A lack of publicly documented abuse does not establish that no unintended transmission occurred. Credential-routing flaws can matter before anyone demonstrates financial loss or account activity. The appropriate response depends on the disclosed behavior and the user’s environment, rather than waiting for a dramatic public incident.
The Moderate classifications likewise require context. A severity label summarizes an advisory’s assessment; it does not decide every organization’s response. A narrowly scoped credential in a controlled test environment presents different consequences from a broadly authorized secret in routine automation. The software defect can be the same while the operational stakes differ.
The age of an affected version range also needs careful treatment. It identifies software releases containing the behavior, rather than proving continuous exposure throughout that period. A user who installed an affected release but never used the relevant endpoint path has a different factual situation from someone who repeatedly did.
There is also no reason to treat the provider receiving a key as malicious by default. An unintended recipient can operate legitimately and still receive information it should never have received. The defect concerns the client’s credential decision. Allegations about a recipient’s conduct require separate evidence.
Nor does the disclosure establish a breach of OpenAI’s own service. The described problem sits in a client workflow directing credentials toward a custom destination. Preserving that distinction helps readers identify the responsible software boundary and avoid confusing an application integration flaw with a provider infrastructure incident.
For readers, the strongest interpretation remains bounded: the flaws were real, the affected paths were specific, and the patch matters. The unresolved question is historical exposure in particular environments. That framing supports action without inflating a documented implementation failure into an unsupported account of mass compromise.
What Should Follow the Security Patch
The next useful evidence concerns adoption, credential-boundary testing, and the results of actual exposure reviews.
The first signal is whether affected workflows move onto patched software. Over the coming months, meaningful adoption evidence would include updated automation environments and maintained installation instructions. A developer updating a personal installation is useful progress, but it does not establish that every scheduled job using the same tool also changed.
Evidence that affected environments remain on older versions would weaken the practical reassurance supplied by the release. Evidence of completed updates across identified workflows would strengthen it. The relevant measurement is remediation where the triggering conditions existed, rather than a general download count detached from configuration.
The second signal is how future testing treats authentication boundaries. A regression test, a check designed to catch the return of an earlier bug, should examine credential selection as well as completion output. The engineering question is whether destination-specific rules remain stable when configuration is incomplete or request handling changes.
Stronger evidence would show those boundaries surviving across supported execution paths. A test that checks only whether a prompt receives an answer provides less reassurance. Compatibility can remain intact while authentication changes underneath it, which is exactly why a security-specific expectation deserves an explicit place in maintenance work.
The third signal is any substantiated account of historical exposure. Useful findings would distinguish an unintended transmission from retention or misuse and describe the affected conditions. Such reports would sharpen the practical consequences. Their absence would leave those consequences uncertain, rather than proving that every affected request was harmless.
These signals should also shape how teams communicate internally. A status update can state that affected installations were patched while leaving historical review open. It can report a confirmed credential transfer without claiming exploitation. Separating those findings makes later evidence easier to incorporate and prevents an early assumption from hardening into the incident narrative.
For developers building provider-switching features, the release supplies a durable design question: what happens when the intended key is unavailable? The safest answer should be visible in behavior, documentation, and tests. A silent substitution is difficult for users to recognize because their primary task can continue looking ordinary.
Buyers evaluating AI workflows can ask the same question without inspecting implementation details. Which credentials belong to which destinations? What changes when a request takes another supported route? How does the application communicate incomplete authentication configuration? Specific answers provide more value than a broad promise of compatibility.
Treat llm 0.37.2 as a reason to examine the boundary between provider selection and credential selection. If your workflow used a custom endpoint, compare its configuration and execution options with the advisories. Establish which version ran and which credential sources were available. Move affected environments to patched software, then keep historical exposure review separate from update completion. Where evidence establishes unintended disclosure, address the credential as well as the application. Preserve the findings in documentation colleagues can understand without reproducing secrets. The useful outcome is a clear account of what changed, what happened, and what remains unknown. Can your team explain why each model destination receives only its intended credential?



