feat(core, anthropic, openai): aclose() lifecycle + latched fallbacks

[Bagatur (baskaryan)]

Summary

Adds an explicit resource-lifecycle contract to chat models, an opt-in FallbackLatch circuit-breaker for with_fallbacks(...), and close()/aclose() propagation through RunnableWithFallbacks.

langchain-core

• BaseChatModel.close() / aclose() — default no-ops that subclasses override. aclose() dispatches to close() so async teardown works for sync-only subclasses. Adds __enter__/__exit__/__aenter__/__aexit__ for context-manager use.
• RunnableWithFallbacks.close() / aclose() — walk runnable + fallbacks, calling each one's lifecycle method; per-runnable failures are suppressed so one bad close doesn't block the rest.
• FallbackLatch + with_fallbacks(..., latch=...) — opt-in circuit breaker. Once the primary raises a handled exception the latch trips and subsequent calls (on this wrapper, or any wrapper sharing the latch) skip the primary. The latch propagates through __getattr__ rebinds (bind_tools, bind, …) so tool-bound and bare wrappers share one circuit. latch.reset() re-enables the primary. Default (no latch) behavior is unchanged.

langchain-anthropic / langchain-openai

close()/aclose() release the underlying httpx client only when the model privately owns it.

This is the important subtlety: both integrations back their SDK clients with a process-wide shared httpx pool via @lru_cache (_get_default_*httpx_client). Every model with the same base_url/timeout/proxy reuses one pool, by design. An earlier revision of this PR closed that shared pool on teardown, which broke every other live model in the process:

RuntimeError: Cannot send a request, as the client has been closed.
-> anthropic.APIConnectionError: Connection error.

So ownership is now tracked explicitly:

• anthropic: ChatAnthropic always wraps the shared cached pool (no http_client field), so close()/aclose() are no-ops for the pool, guarded by an identity check against the lru-cache getter (defensive against any future private-client path).
• openai: a client is owned iff the model built it privately — the unhashable-httpx.Timeout fresh-client path or an openai_proxy transport — and the user didn't supply their own http_client/http_async_client. Shared-cache and user-supplied clients are never closed.

This makes aclose() safe to call after every use without disturbing sibling models or pools the caller owns. It is most useful for the privately-owned and user-injected-and-managed cases, and as a uniform, provider-agnostic teardown hook for frameworks (LangGraph runtimes, agent orchestrators) that previously had to reach into private SDK attributes.

Release Note

none

Test Plan

• core: lifecycle + context-manager tests for BaseChatModel; latch trip/reset/shared/propagation + close/aclose propagation tests for RunnableWithFallbacks.
• anthropic: regression test — two models share the lru-cached pool, close one, assert the other's pool stays open; plus owned-path + uninstantiated-noop tests.
• openai: shared-pool regression test (sync + async), owned-via-proxy / owned-via-unhashable-timeout flag tests, user-injected-not-closed test, owned-client-closed test.
• Full suites pass: core runnables + language_models, libs/partners/anthropic (106), libs/partners/openai chat_models/test_base (201). Lint + mypy clean.

🤖 Generated with Claude Code

[codspeed-hq]

Merging this PR will not alter performance

✅ 13 untouched benchmarks
⏩ 2 skipped benchmarks¹

---

_{Comparing feat/chat-model-aclose (e0ace82) with master (1338871)²}

Footnotes

1. 2 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

2. No successful run was found on master (4493b2c) during the generation of this report, so 1338871 was used instead as the comparison base. There might be some changes unrelated to this pull request in this report. ↩