Keep openhands/* as public LLM model; translate to litellm_proxy only at transport time

[enyst]

Problem

openhands/* is intended to be the user-facing/provider-facing model namespace, but the SDK currently rewrites it into the LiteLLM transport namespace during LLM validation:

https://github.com/OpenHands/software-agent-sdk/blob/main/openhands-sdk/openhands/sdk/llm/llm.py#L499-L520

if model_val.startswith("openhands/"):
    model_name = model_val.removeprefix("openhands/")
    d["model"] = f"litellm_proxy/{model_name}"
    d["base_url"] = d.get("base_url") or "https://llm-proxy.app.all-hands.dev/"

Because this happens in a Pydantic @model_validator(mode="before"), it is not only a LiteLLM request-time transformation. It mutates the public LLM.model field before agent-server routes and persistence see the object.

Observed downstream effect in agent-canvas (see OpenHands/agent-canvas#1146 and OpenHands/agent-canvas#1148):

1. GUI submits an OpenHands provider model as model: "openhands/<model>".
2. Agent server validates the request as LLM, which rewrites it to model: "litellm_proxy/<model>" and stamps the OpenHands proxy base_url.
3. The rewritten shape is persisted and returned over the API.
4. A later UI Basic-mode save path can treat litellm_proxy/* as a non-OpenHands provider and drop base_url.
5. The profile becomes model: "litellm_proxy/<model>", base_url: null; LiteLLM then falls back toward the wrong provider/default OpenAI route and reports a misleading auth error.

The immediate agent-canvas PR preserves the proxy base_url for current/released agent-server behavior, but the cleaner SDK contract would be: store and expose openhands/*; translate to litellm_proxy/* only at LiteLLM transport boundaries.

Existing history

The rewrite appears to have been introduced by #70 (f16a2da9, originally in openhands/core/config/llm_config.py), then moved into the current LLM pydantic class by #91. Related base-url fixes were made in #338 and #1341.

Desired behavior

• Public/stored/API LLM config remains stable as model: "openhands/<model>" for OpenHands provider models.
• The SDK still sends LiteLLM the transport model it expects: model="litellm_proxy/<model>" and api_base="https://llm-proxy.app.all-hands.dev/" (unless a caller intentionally supplied another base URL and that remains supported).
• Existing users with already persisted litellm_proxy/* + OpenHands proxy base_url profiles/settings are migrated seamlessly back to the public openhands/* shape.
• Third-party LiteLLM proxy profiles must not be converted accidentally.
• Avoid leaving redundant frontend/backend normalization code long-term once the SDK contract is stable.

Proposed SDK implementation

1. Centralize OpenHands-provider helpers/constants

Add a small internal helper module or section in llm.py with explicit constants and conversion helpers, for example:

• OPENHANDS_PROVIDER_PREFIX = "openhands/"
• LITELLM_PROXY_PREFIX = "litellm_proxy/"
• OPENHANDS_LLM_PROXY_BASE_URL = "https://llm-proxy.app.all-hands.dev/"
• accepted normalized OpenHands proxy base URLs, likely both:
  • https://llm-proxy.app.all-hands.dev
  • https://llm-proxy.app.all-hands.dev/v1
• is_openhands_provider_model(model)
• is_openhands_proxy_base_url(base_url)
• is_openhands_litellm_proxy_model(model, base_url)
• openhands_public_model_from_proxy(model, base_url)
• litellm_transport_model_for(model)
• possibly litellm_transport_base_url_for(model, base_url)

The conversion from litellm_proxy/* back to openhands/* should be conservative: only when paired with the known OpenHands proxy URL, and ideally only for models in the verified OpenHands model list. Do not rewrite arbitrary litellm_proxy/* from a customer/third-party proxy.

2. Stop mutating LLM.model during normal validation

Change LLM._coerce_inputs() so openhands/* remains in d["model"].

It should still default base_url for openhands/* when unset/None, preserving the #1341 fix:

if model_val.startswith("openhands/"):
    d["base_url"] = d.get("base_url") or OPENHANDS_LLM_PROXY_BASE_URL

If custom base_url for openhands/* is intentionally supported today (test_base_url_for_openhands_provider_with_custom_url), keep that behavior or make a deliberate breaking-change decision.

3. Translate only for LiteLLM transport calls

Use the transport model when calling LiteLLM, not when storing the public LLM.model:

• _prepare_transport_kwargs() should pass model=<transport model>.
• _transport_call() / _atransport_call() inherit that via _prepare_transport_kwargs().
• Responses API paths should be checked too if they use separate transport construction.

Conceptually:

def _litellm_transport_model(self) -> str:
    if self.model.startswith("openhands/"):
        return f"litellm_proxy/{self.model.removeprefix('openhands/')}"
    return self.model

Then:

return dict(
    model=self._litellm_transport_model(),
    api_key=self._get_litellm_api_key_value(),
    api_base=self.base_url,
    ...
)

4. Audit all code paths that currently rely on the rewritten model

The rewrite currently means self.model is already litellm_proxy/*, so several helper paths may implicitly depend on that. They should use either the public model or transport model intentionally:

• _infer_litellm_provider() / infer_litellm_provider(model=..., api_base=...) probably needs the transport model.
• get_litellm_model_info() currently only calls /v1/model/info for model.startswith("litellm_proxy/"); for public openhands/*, pass the transport model into that lookup so proxy model-info still works.
• _model_name_for_capabilities() / get_features() / supports_vision() should be checked. Some local feature tables understand litellm_proxy/*; they may need either OpenHands-aware normalization or transport-model input for capability lookup.
• telemetry/metrics/cost fields should be reviewed. Prefer reporting the public openhands/* model where user-facing, but ensure price/capability lookup still resolves correctly.
• error messages should ideally reference the public model while preserving enough transport context for debugging.
• fallback strategies / router / model switch tool should be reviewed for any direct string-prefix assumptions.

5. Add seamless migration for persisted settings

There is already settings versioning:

• AGENT_SETTINGS_SCHEMA_VERSION and _AGENT_SETTINGS_MIGRATIONS in openhands-sdk/openhands/sdk/settings/model.py.
• top-level PERSISTED_SETTINGS_SCHEMA_VERSION in openhands-agent-server/openhands/agent_server/persistence/models.py.
• PersistedSettings.from_persisted() / validate_agent_settings() already apply nested settings migrations.

For the active agent settings path, consider bumping AGENT_SETTINGS_SCHEMA_VERSION and adding an agent-settings migration that canonicalizes:

{
  "llm": {
    "model": "litellm_proxy/<known-openhands-model>",
    "base_url": "https://llm-proxy.app.all-hands.dev/"
  }
}

to:

{
  "llm": {
    "model": "openhands/<known-openhands-model>",
    "base_url": "https://llm-proxy.app.all-hands.dev/"
  }
}

This seems like an appropriate use of agent settings versioning for the active settings file because it is changing the canonical persisted shape of a nested agent_settings.llm field.

If we choose not to bump agent settings, then the equivalent normalization must still happen in a clearly documented load path; however piggybacking on the existing versioned migration mechanism is probably cleaner and easier to test.

Do not silently infer OpenHands from litellm_proxy/* + base_url: null unless we intentionally accept that heuristic. That stranded shape is the broken downstream state, but without the proxy URL it is ambiguous with third-party LiteLLM proxy usage. A conservative migration should only repair unambiguous profiles/settings; ambiguous ones can raise/validate/show a setup error.

6. Add seamless migration for LLM profiles

Profiles have their own versioning concept too:

• LLM_PROFILE_SCHEMA_VERSION in openhands-sdk/openhands/sdk/llm/llm.py.
• LLM.from_persisted() / LLM.to_persisted().
• LLMProfileStore.save() writes llm.to_persisted().
• LLMProfileStore.load() goes through LLM.load_from_json().

Consider bumping LLM_PROFILE_SCHEMA_VERSION and adding profile migrations inside LLM.from_persisted() so saved profile JSON is canonicalized from old litellm_proxy/* + OpenHands proxy base_url to openhands/* + OpenHands proxy base_url.

Important: LLMProfileStore.list_summaries() currently reads raw JSON directly and does not instantiate LLM; it returns data.get("model") / data.get("base_url"). It should either:

• apply the same lightweight profile migration/normalization before building the summary, or
• share a helper with LLM.from_persisted() that can canonicalize raw profile dicts without exposing/decrypting secrets.

Otherwise the UI profile list can still show litellm_proxy/* even though loading the profile would normalize it.

7. Compatibility / rollout notes

• Keep accepting old litellm_proxy/* + OpenHands proxy base_url inputs for at least one release so existing clients and files do not break.
• Persist the new public shape on the next save/write after migration.
• Third-party litellm_proxy/* with non-OpenHands base URLs should remain unchanged.
• litellm_proxy/* + base_url: null should probably not be auto-converted unless there is an additional reliable signal. It can remain invalid and surface a clearer validation/setup error.
• Once this ships and agent-canvas pins a compatible agent-server version, downstream workaround code can be reduced to compatibility handling for older servers.

Suggested tests

SDK unit tests

• LLM(model="openhands/foo") keeps llm.model == "openhands/foo" and sets default base_url to the OpenHands proxy.
• LLM(model="openhands/foo", base_url=None) also sets the proxy base URL.
• LLM(model="openhands/foo", base_url="https://custom-proxy.example") preserves the custom base URL if that remains intended.
• Mock litellm.completion / litellm.acompletion and verify transport kwargs use model="litellm_proxy/foo", api_base=<proxy>, while llm.model remains openhands/foo.
• Provider inference and model-info lookup tests for openhands/foo still use the proxy path and do not regress capabilities.
• Negative tests: third-party litellm_proxy/foo + custom base URL remains unchanged.

Profile migration tests

• A v1/legacy profile JSON containing litellm_proxy/<known-openhands-model> + OpenHands proxy base URL loads as openhands/<known-openhands-model>.
• Saving after load writes the new schema version and public openhands/* model.
• LLMProfileStore.list_summaries() reports the normalized public model for migrated profiles.
• litellm_proxy/foo + custom proxy URL remains a LiteLLM proxy profile.
• litellm_proxy/foo + base_url: null is not silently converted (or, if we decide to convert, document and test the heuristic).

Settings migration tests

• Persisted agent_settings.llm with old rewritten OpenHands proxy shape migrates to public openhands/* through validate_agent_settings() / PersistedSettings.from_persisted().
• The migration bumps AGENT_SETTINGS_SCHEMA_VERSION if using the existing settings migration mechanism.
• PATCH /api/settings / GET /api/settings returns the public model shape after migration.
• ACP settings are unaffected.

Agent-server/profile API tests

• POST /api/profiles/{name} with openhands/* returns/saves public openhands/*, not litellm_proxy/*.
• GET /api/profiles/{name} for a legacy file returns public openhands/*.
• GET /api/profiles summaries are normalized.
• Starting a conversation/profile activation with an OpenHands profile still results in LiteLLM receiving litellm_proxy/* transport model.

Acceptance criteria

• No public API response or persisted profile/settings file created by the SDK/agent-server rewrites an OpenHands provider model to litellm_proxy/*.
• LiteLLM requests still use the correct litellm_proxy/* model and OpenHands proxy base URL.
• Existing unambiguous legacy profiles/settings migrate seamlessly.
• Third-party LiteLLM proxy usage is not changed.
• Downstream UIs no longer need to reverse-map the SDK's public LLM.model field for normal OpenHands-provider profiles.

This issue was created by an AI agent (OpenHands) on behalf of the agent-canvas maintainers.

[enyst]

Investigation update after checking the SDK plus the downstream clients (OpenHands/OpenHands, OpenHands/OpenHands-CLI, and OpenHands/agent-canvas): I agree with the direction here, and I think the clean invariant should be even stricter: openhands/* should remain the public/provider model everywhere, and both pieces of LiteLLM compatibility (model="litellm_proxy/*" and the OpenHands proxy api_base) should be derived at the LiteLLM transport boundary.

What I found:

• SDK currently mutates the public model during validation in openhands-sdk/openhands/sdk/llm/llm.py: _coerce_inputs() rewrites openhands/* to litellm_proxy/* and fills base_url. That means every downstream serializer/API sees the transport shape, not the provider shape.
• SDK transport uses self.model directly in both chat completions (_prepare_transport_kwargs) and responses (_build_responses_call_kwargs), so moving this boundary needs to cover both paths.
• SDK capability/provider lookup has implicit dependencies on the rewritten shape:
  • _infer_litellm_provider() passes self.model to LiteLLM provider inference.
  • _init_model_info_and_caps() calls get_litellm_model_info(..., model=self._model_name_for_capabilities()).
  • get_litellm_model_info() only uses /v1/model/info for litellm_proxy/* models today.
    These should intentionally use a transport/capability lookup model when needed, while keeping user-facing metrics/settings on openhands/*.
• Persistence has two affected surfaces:
  • LLM.to_persisted() writes the already-mutated model and base_url; LLM.from_persisted() currently has version handling but no migration.
  • Agent settings already have versioned migrations through AGENT_SETTINGS_SCHEMA_VERSION / _AGENT_SETTINGS_MIGRATIONS, so this is the right place to canonicalize old nested agent_settings.llm payloads.
  • LLMProfileStore.list_summaries() reads raw JSON instead of constructing LLM, so profile summary/list APIs need to share the same lightweight canonicalization or they will keep displaying legacy litellm_proxy/* even after load() migrates.
• agent-canvas has accumulated exactly the workaround layer this issue describes:
  • src/utils/normalize-display-model.ts reverse-maps litellm_proxy/* + OpenHands proxy base_url back to openhands/* for display.
  • src/utils/openhands-llm.ts recognizes the SDK-translated proxy/base-url pair.
  • Basic-mode saves in src/routes/llm-settings.tsx and src/components/features/settings/llm-profiles/llm-settings-local-view.tsx preserve/stamp the OpenHands proxy URL so an already-rewritten profile does not become litellm_proxy/* + base_url:null.
• OpenHands/OpenHands has a similar compatibility layer:
  • openhands/app_server/config.py::resolve_provider_llm_base_url() treats both openhands/* and litellm_proxy/* as OpenHands-provider models so SaaS can swap the SDK default proxy URL for the deployment-specific one.
  • frontend settings code knows OpenHands/litellm_proxy default proxy URLs and clears llm.base_url in Basic mode.
  • app-server tracing metadata checks both openhands/ and litellm_proxy/ because the SDK may have already translated.
• OpenHands/OpenHands-CLI is also affected: settings save manually fills the OpenHands proxy for openhands/*, and the TUI decides Basic vs Advanced mode from bool(llm.base_url). If the SDK persists a proxy base_url for ordinary OpenHands provider choices, the CLI/UI can be pushed into “advanced/custom base URL” semantics even though the user selected a normal provider model.

Proposed refinement to the plan:

1. Add one SDK-owned internal helper module for this mapping (is_openhands_provider_model, is_openhands_proxy_base_url, conservative legacy proxy-to-public canonicalization, transport_model_for_litellm, transport_base_url_for_litellm). Downstream apps should not own copies of these rules long-term.
2. Stop mutating LLM.model in validation. Prefer not to default/persist LLM.base_url for openhands/* either unless the caller explicitly supplied a custom base URL; derive the default OpenHands proxy as api_base only when calling LiteLLM. This matches the “regular provider everywhere except LiteLLM” invariant and avoids Basic-vs-Advanced UI confusion.
3. Use the derived transport kwargs for every LiteLLM boundary: chat completion, async completion, responses, provider inference, and proxy model-info lookup. User-facing metrics/logs/settings should keep openhands/*.
4. Add conservative migrations for legacy persisted payloads:
   • litellm_proxy/<m> + known OpenHands proxy URL -> openhands/<m> and (if we adopt the stricter invariant) drop the default proxy base_url from the canonical persisted shape.
   • Do not rewrite third-party litellm_proxy/* with non-OpenHands base URLs.
   • Do not guess litellm_proxy/* + base_url:null unless we introduce a separate reliable signal; that shape is ambiguous and should surface a clearer setup/validation error.
5. Keep accepting the legacy shape at API boundaries for a release window, but ensure the next save writes the public openhands/* shape. After that lands, agent-canvas, OpenHands frontend/app-server, and CLI can delete most of their reverse-mapping/stamping code and keep only compatibility for older agent-server versions.

Risk: this is a cross-repo refactor because several code paths grew around the old mistake. The safest route is to land the SDK/agent-server canonicalization first with focused migration + transport tests, then remove downstream workarounds in follow-up PRs once clients pin a compatible agent-server/SDK.

This comment was created by an AI agent (OpenHands) on behalf of the user.

[enyst]

@OpenHands Check the related PR 3548, and understand the initial intention here. Let's keep it as simple as we can:

• the SDK PR will stop saving the 'translated' shape of this LLM; verify what its migration does, and what should a user expect if they had saved a profile with a 'translated' openhands/ LLM
• then, verify that we test it well! Checkout the branch if you didn't yet, look at the 'cross' tests on conversation restore, and make sure we have 'cross' tests for this migration (for users who had one) and for its end state too (for new users who just write on disk a profile from openhands/).
• then, clone and open PRs to OpenHands-CLI repo, agent-canvas repo, OpenHands repo, all from OpenHands org; verify if we also need it in benchmarks repo then there too: anywhere where we used a "reverse translation" for this provider - clean up the code from these "reverse translations" and make sure instead that the code recognizes the openhands/ provider by simply recognizing openhands/ prefix.
• then, make me a report here, in a comment to this issue
• then, take each PR you opened, one by one, and /iterate on it.

[openhands-ai]

I'm on it! enyst can track my progress at all-hands.dev

[enyst]

Report on the openhands/* public-model rollout:

SDK PR 3548

• Checked the PR branch and the intended contract is now: keep LLM.model public as openhands/<model> and derive litellm_proxy/<model> only for LiteLLM calls/model-info/cost boundaries.
• Legacy persisted profiles/settings are migrated conservatively only when the old litellm_proxy/<known OpenHands model> shape is paired with the known OpenHands proxy base URL. Third-party litellm_proxy/* profiles are left untouched.
• For users with an already-saved translated profile/settings file, loading through the migration should produce openhands/<model> and the next save writes the public shape. Ambiguous litellm_proxy/* without the OpenHands proxy URL is not inferred as OpenHands.
• I added cross conversation-restore coverage on PR 3548 for both:
  • the end state: a new conversation using openhands/* writes public openhands/* to base_state.json while LiteLLM still receives litellm_proxy/*; and
  • legacy restore: a translated persisted agent snapshot (litellm_proxy/* + OpenHands proxy URL) can restore, then the runtime agent snapshot is rewritten to the public openhands/* shape.
• Local validation run on the SDK branch:
  • uv run pre-commit run --files tests/cross/test_conversation_restore_behavior.py
  • uv run pytest tests/sdk/llm/test_llm.py tests/sdk/llm/test_llm_profile_store.py tests/sdk/llm/test_model_info_proxy_lookup.py tests/sdk/test_settings.py tests/cross/test_check_persisted_settings_compat.py tests/cross/test_conversation_restore_behavior.py -q

Existing upstream refactoring PR
#3548

Downstream cleanup PRs opened

• OpenHands-CLI: settings: keep OpenHands provider models public OpenHands-CLI#770
  • Stops stamping the OpenHands proxy base_url when saving Basic-mode openhands/* settings.
  • Keeps metadata/critic behavior recognizing openhands/ by prefix.
• agent-canvas: settings: trust public OpenHands provider models agent-canvas#1280
  • Removes frontend reverse-mapping helpers for litellm_proxy/* + OpenHands proxy URL.
  • Basic-mode saves no longer re-stamp the proxy base URL; the model selector reads the public model directly.
• OpenHands: refactor(llm): clean up reverse-mapping OpenHands provider models OpenHands#14725
  • Removes app-server/settings reverse conversion from litellm_proxy/* to openhands/*.
  • Narrows OpenHands-provider checks and managed-proxy overrides to the public openhands/ prefix.

Benchmarks audit

• I checked OpenHands/benchmarks for this specific reverse-translation pattern. I found regular LiteLLM proxy config usage for evals (for example litellm_proxy/anthropic/... in config examples and ACP helpers), but not a client workaround that reverse-maps OpenHands-provider models back from litellm_proxy/*. I did not open a benchmarks PR.

Next: I’ll iterate the opened PRs through CI/review.

This issue comment was created by an AI agent (OpenHands) on behalf of the user.

[enyst]

@OpenHands look at these PRs #3514 (comment) and tell me: do we apply the same simplification to the critic LLM? If not, why not? If yes, prove with source links on github. Respond directly here.

[openhands-ai]

I'm on it! enyst can track my progress at all-hands.dev

[enyst]

Short answer: yes for the CLI auto-config path that derives the critic from the user-facing OpenHands LLM, but no extra openhands/* -> litellm_proxy/* rewrite belongs inside the critic client itself.

Why: the SDK critic is not a normal LLM / LiteLLM transport client. APIBasedCritic inherits CriticClient, whose config is a direct vLLM classification endpoint: default server_url = "https://llm-proxy.app.all-hands.dev/vllm", default model_name = "critic", and classify_trace() POSTs directly to {server_url}/classify with json={"model": self.model_name, "input": formatted}. There is no public LLM.model field to keep as openhands/*, and no LiteLLM model namespace to translate at request time for the critic itself:

• Critic config fields/defaults:

  software-agent-sdk/openhands-sdk/openhands/sdk/critic/impl/api/client.py

  Lines 74 to 108 in d078f94

  	DEFAULT_CRITIC_SERVER_URL = "https://llm-proxy.app.all-hands.dev/vllm"
  	DEFAULT_CRITIC_MODEL_NAME = "critic"
  	class CriticClient(BaseModel):
  	"""
  	Core inference client for the Critic classification service.
  	Owns:
  	- Configuration (server URL, API key, model, tokenizer, etc.)
  	- Label space (for predictions only)
  	- Message normalization and chat template formatting
  	- Inference via vLLM /classify endpoint
  	Does NOT handle:
  	- Dataset loading
  	- Ground truth extraction
  	- Evaluation / metrics
  	"""
  	model_config = ConfigDict(arbitrary_types_allowed=True, extra="ignore")
  	# --- connection / model config ---
  	server_url: str = Field(
  	default=DEFAULT_CRITIC_SERVER_URL,
  	description="Base URL of the vLLM classification service",
  	)
  	# validate_secret() normalizes empty, whitespace-only, and redacted inputs
  	# to None. That value may serialize as null during response-model rebuilds,
  	# but it is not part of the public REST schema contract.
  	api_key: str | SecretStr | SkipJsonSchema[None] = Field(
  	..., description="API key for authenticating with the vLLM service"
  	)
  	model_name: str = Field(
  	default=DEFAULT_CRITIC_MODEL_NAME, description="Name of the model to use"

• Direct /classify request using model_name:

  software-agent-sdk/openhands-sdk/openhands/sdk/critic/impl/api/client.py

  Lines 262 to 299 in d078f94

  	def classify_trace(
  	self,
  	messages: Sequence[dict],
  	tools: Sequence[ChatCompletionToolParam] | None = None,
  	) -> ClassificationResponse:
  	"""POST /classify and parse response into ClassificationResponse."""
  	formatted = self.apply_chat_template(messages, tools)
  	def should_retry(exc: BaseException) -> bool:
  	# Retry only on 500 Internal Server Error
  	if isinstance(exc, httpx.HTTPStatusError):
  	return exc.response.status_code == 500
  	return False
  	@retry(
  	retry=retry_if_exception(should_retry),
  	stop=stop_after_attempt(3), # up to 3 tries
  	wait=wait_exponential(
  	multiplier=1, min=1, max=8
  	), # exponential backoff: 1s, 2s, 4s, 8s
  	reraise=True, # re-raise the last exception if all retries fail
  	)
  	def _post_with_retry():
  	api_key_value = self._get_api_key_value()
  	resp = self._client.post(
  	f"{self.server_url}/classify",
  	headers={
  	"Content-Type": "application/json",
  	"Authorization": f"Bearer {api_key_value}",
  	},
  	json={"model": self.model_name, "input": formatted},
  	timeout=self.timeout_seconds,
  	)
  	resp.raise_for_status()
  	return resp
  	resp = _post_with_retry()
  	return ClassificationResponse.model_validate(resp.json())

The PR #3548 simplification is specifically for regular SDK LLM LiteLLM calls: openhands/* stays public, and only litellm_call_kwargs() turns it into litellm_proxy/* + proxy api_base for LiteLLM transport:

• OpenHands-provider transport helper:

  software-agent-sdk/openhands-sdk/openhands/sdk/llm/utils/openhands_provider.py

  Lines 45 to 52 in c3816a4

  	def litellm_call_kwargs(model: str, base_url: str | None) -> dict[str, str | None]:
  	if is_openhands_provider_model(model):
  	model_name = model.removeprefix(OPENHANDS_PROVIDER_PREFIX)
  	return {
  	"model": f"{LITELLM_PROXY_PREFIX}{model_name}",
  	"api_base": base_url or OPENHANDS_LLM_PROXY_BASE_URL,
  	}
  	return {"model": model, "api_base": base_url}

• LLM uses those kwargs for provider inference / transport:

  software-agent-sdk/openhands-sdk/openhands/sdk/llm/llm.py

  Lines 1722 to 1733 in c3816a4

  	def _litellm_call_kwargs(self) -> dict[str, str | None]:
  	return litellm_call_kwargs(self.model, self.base_url)
  	def _infer_litellm_provider(self) -> str | None:
  	if self._litellm_provider is not None:
  	return self._litellm_provider
  	call_kwargs = self._litellm_call_kwargs()
  	provider = infer_litellm_provider(
  	model=call_kwargs["model"] or self.model,
  	api_base=call_kwargs["api_base"],
  	)

  and

  software-agent-sdk/openhands-sdk/openhands/sdk/llm/llm.py

  Lines 1790 to 1808 in c3816a4

  	def _prepare_transport_kwargs(
  	self,
  	*,
  	messages: list[dict[str, Any]],
  	enable_streaming: bool,
  	**kwargs,
  	) -> dict[str, Any]:
  	"""Build the keyword arguments for a litellm (a)completion call."""
  	# When streaming, request usage in the final chunk so that detailed
  	# token breakdowns (prompt_tokens_details with cached_tokens, etc.) are
  	# not silently discarded by litellm's streaming handler.
  	if enable_streaming:
  	kwargs.setdefault("stream_options", {"include_usage": True})
  	return {
  	**self._litellm_call_kwargs(),
  	"api_key": self._get_litellm_api_key_value(),
  	"api_version": self.api_version,
  	"timeout": self.timeout,
  	"drop_params": self.drop_params,

The corresponding critic simplification is in OpenHands-CLI PR #770: get_default_critic() now recognizes the public llm.model.startswith("openhands/"), derives the proxy URL as base_url or DEFAULT_LLM_BASE_URL, and creates APIBasedCritic(..., model_name="critic"). That means critic auto-config no longer relies on the SDK having rewritten/saved the main LLM as litellm_proxy/* or having persisted a proxy base_url:

• CLI critic auto-config using public openhands/: https://github.com/OpenHands/OpenHands-CLI/blob/e96acf324dd65c1ff3df28af99f448c95e39d634/openhands_cli/stores/agent_store.py#L87-L118
• Test proving LLM(model="openhands/...") gets the default critic proxy URL: https://github.com/OpenHands/OpenHands-CLI/blob/e96acf324dd65c1ff3df28af99f448c95e39d634/tests/stores/test_env_llm_overrides.py#L23-L30
• Metadata/extra-body detection also treats openhands/ as the public signal: https://github.com/OpenHands/OpenHands-CLI/blob/e96acf324dd65c1ff3df28af99f448c95e39d634/openhands_cli/utils.py#L81-L107

So: we do apply the same public-openhands/ assumption at the critic derivation boundary, but we intentionally do not add LiteLLM proxy translation inside the critic client because that client is a direct vLLM /classify client, not a LiteLLM-backed LLM.

This issue comment was created by an AI agent (OpenHands) on behalf of the user.