Python
Provider auth redesign: joined segments, method panels, Vertex methods
Rohit C Prasadf281b29ff18f
diff --git a/coworker/providers/registry.py b/coworker/providers/registry.pyindex 9064eb93..49df1995 100644--- a/coworker/providers/registry.py+++ b/coworker/providers/registry.py@@ -44,7 +44,10 @@ class ProviderField:# endpoint, so the user only has to paste a key. Distinct from `placeholder` (grey hint).default: str = ""# Non-empty → the field renders as a segmented choice control instead of a text input;- # each option is {"value", "label"}. The chosen value is stored like any field value.+ # each option is {"value", "label"} plus optional UI extras: "tag" (a tiny badge like+ # "Easiest"), "desc" (one-liner atop the method's panel), and "command" (a copyable+ # terminal command shown in the panel, e.g. the gcloud ADC login). The chosen value is+ # stored like any other field value.choices: tuple = ()# {"other_field_key": "value"} → the field only renders while that other field holds# that value. Drives auth-method switching (Bedrock) without a per-provider form.@@ -158,7 +161,6 @@ def _build_bedrock(profile: dict[str, Any], secrets: Any) -> ProviderClient:def _build_vertex(profile: dict[str, Any], secrets: Any) -> ProviderClient:- # Blank service_account_json → Application Default Credentials, resolved at call time.p = profile or {}def get(key: str) -> Optional[str]:@@ -167,7 +169,9 @@ def _build_vertex(profile: dict[str, Any], secrets: Any) -> ProviderClient:return VertexProvider(project=get("project"),location=get("location"),+ auth_method=get("auth_method"),service_account_json=get("service_account_json"),+ api_key=get("vertex_api_key"),)@@ -318,9 +322,22 @@ DESCRIPTORS: list[ProviderDescriptor] = [required=False, # the default stands in; builder tolerates absencedefault="api_key",choices=(- {"value": "api_key", "label": "Bedrock API key"},- {"value": "profile", "label": "AWS profile"},- {"value": "iam", "label": "IAM keys"},+ {+ "value": "api_key",+ "label": "Bedrock API key",+ "tag": "Easiest",+ "desc": "A single key generated on the Bedrock console — no AWS CLI or IAM setup needed.",+ },+ {+ "value": "profile",+ "label": "AWS profile",+ "desc": "Uses a named profile from ~/.aws — works with `aws configure` and `aws sso login`.",+ },+ {+ "value": "iam",+ "label": "IAM keys",+ "desc": "An IAM access key pair. For temporary STS credentials, include the session token.",+ },),),ProviderField(@@ -330,7 +347,6 @@ DESCRIPTORS: list[ProviderDescriptor] = [required=False,placeholder="ABSK…",show_when={"auth_method": "api_key"},- help="Generate one on the Bedrock console — no AWS CLI or IAM setup needed.",),ProviderField("aws_profile",@@ -339,9 +355,7 @@ DESCRIPTORS: list[ProviderDescriptor] = [required=False,placeholder="default",show_when={"auth_method": "profile"},- help="A named profile from ~/.aws — works with `aws configure` and "- "`aws sso login` (IAM Identity Center). Leave blank to use your "- "default AWS credentials (env vars or ~/.aws).",+ help="Leave blank to use your default AWS credentials (env vars or ~/.aws).",),ProviderField("aws_access_key_id",@@ -390,14 +404,50 @@ DESCRIPTORS: list[ProviderDescriptor] = [help="The region your Vertex AI models are enabled in ""(Claude models: us-east5 or europe-west1).",),+ ProviderField(+ "auth_method",+ "Connect with",+ secret=False,+ required=False, # the default stands in; builder tolerates absence+ default="adc",+ choices=(+ {+ "value": "adc",+ "label": "Google Cloud login",+ "tag": "Recommended",+ "desc": "Uses your machine's Google Cloud identity (Application "+ "Default Credentials). Nothing to paste — sign in once in a terminal:",+ "command": "gcloud auth application-default login",+ },+ {+ "value": "service_account",+ "label": "Service account",+ "desc": "A service-account key — the usual path on shared or headless machines.",+ },+ {+ "value": "api_key",+ "label": "API key",+ "desc": "A long-lived key from the Google Cloud console's API Keys page. "+ "Reaches Gemini models only — Claude and open-weight need Google "+ "Cloud login or a service account.",+ },+ ),+ ),ProviderField("service_account_json",- "Service-account JSON (optional)",+ "Service-account JSON",secret=True,required=False,- help="Paste the JSON key or a path to it. Leave blank to use "- "Application Default Credentials "- "(`gcloud auth application-default login`).",+ show_when={"auth_method": "service_account"},+ help="Paste the JSON key, or a path to the file.",+ ),+ ProviderField(+ "vertex_api_key",+ "Vertex API key",+ secret=True,+ required=False,+ placeholder="AQ.…",+ show_when={"auth_method": "api_key"},),],build=_build_vertex,@@ -646,16 +696,44 @@ def _verify_bedrock(fields: dict[str, Any], timeout: float) -> dict[str, Any]:def _verify_vertex(fields: dict[str, Any], timeout: float) -> dict[str, Any]:- """Resolve credentials (service account or ADC), mint a bearer, and list Google's- publisher models in the given project/location — one cheap read-only call."""+ """One cheap read-only call (list Google's publisher models) through the SELECTED+ auth method: ADC / service-account bearer, or the express API key header."""import httpxfrom .vertex_provider import load_credentialsproject = (fields.get("project") or "").strip()location = (fields.get("location") or "").strip()+ method = (fields.get("auth_method") or "").strip() or (+ "service_account" if (fields.get("service_account_json") or "").strip() else "adc"+ )+ if method == "api_key":+ key = (fields.get("vertex_api_key") or "").strip()+ if not key:+ return {"ok": False, "error": "Enter a Vertex API key to test."}+ try:+ # Express mode is global — no region host, no project in the path.+ resp = httpx.get(+ "https://aiplatform.googleapis.com/v1/publishers/google/models",+ headers={"x-goog-api-key": key},+ timeout=timeout,+ )+ except Exception as exc:+ return {+ "ok": False,+ "error": f"Couldn't reach Vertex AI ({exc.__class__.__name__}).",+ }+ if resp.status_code < 300:+ return {"ok": True}+ if resp.status_code in (401, 403):+ return {"ok": False, "error": "Google rejected the API key."}+ return {"ok": False, "error": f"Vertex AI returned HTTP {resp.status_code}."}+ if method == "service_account" and not (fields.get("service_account_json") or "").strip():+ return {"ok": False, "error": "Paste a service-account JSON to test."}try:- creds = load_credentials(fields.get("service_account_json"))+ creds = None+ if method == "service_account":+ creds = load_credentials(fields.get("service_account_json"))if creds is None:import google.authdiff --git a/coworker/providers/vertex_provider.py b/coworker/providers/vertex_provider.pyindex 3110dd64..0891339a 100644--- a/coworker/providers/vertex_provider.py+++ b/coworker/providers/vertex_provider.py@@ -12,11 +12,22 @@ An id with no recognized family segment is best-effort routed by name (gemini*claude* → Claude, anything else → MaaS) so a raw id pasted without the add-model dropdownstill works.-Credentials: an explicit service-account JSON (pasted content or a file path) when the-profile has one, else Application Default Credentials (`gcloud auth application-default-login`). The MaaS path authenticates with a google-auth bearer token that expires ~hourly —-this wrapper refreshes it and rebuilds the OpenAI sub-client as needed; the two native SDK-clients take the credentials object and refresh internally.+Auth is ONE method at a time, selected by the profile's `auth_method` (a segmented choice+in Settings, mirroring Bedrock — owner call 2026-07-26):++- `adc` — Application Default Credentials (`gcloud auth application-default+ login`), Google's own recommended path. Nothing stored.+- `service_account` — an explicit service-account JSON (pasted content or a file path).+- `api_key` — a Vertex API key (express mode). GEMINI FAMILY ONLY: the genai SDK+ takes it (and it excludes project/location — mutually exclusive there), but Claude+ (AnthropicVertex) and the MaaS endpoint require OAuth credentials, so those families+ raise a clear error directing the user to the other methods.++The MaaS path authenticates with a google-auth bearer token that expires ~hourly — this+wrapper refreshes it and rebuilds the OpenAI sub-client as needed; the two native SDK+clients take the credentials object and refresh internally. Fields from non-selected+methods are dropped at construction; a missing/unknown method falls back to whichever+fields are present (service account, else ADC)."""from __future__ import annotations@@ -59,14 +70,25 @@ class VertexProvider(ProviderClient):*,project: Optional[str] = None,location: Optional[str] = None,+ auth_method: Optional[str] = None,service_account_json: Optional[str] = None,+ api_key: Optional[str] = None,credentials: Any = None,gemini_client: Optional[ProviderClient] = None,claude_client: Optional[ProviderClient] = None,openweight_client: Optional[ProviderClient] = None,):+ # Narrow to the selected auth method here, once — stale values stored under a+ # previously-selected method must never reach a different credential path.+ if auth_method == "adc":+ service_account_json = api_key = None+ elif auth_method == "service_account":+ api_key = None+ elif auth_method == "api_key":+ service_account_json = Noneself._project = projectself._location = location+ self._api_key = api_keyself._service_account_json = service_account_jsonself._credentials = credentials # test seam; normally resolved lazily# Test seams: pre-built sub-providers skip the SDK construction below.@@ -117,6 +139,12 @@ class VertexProvider(ProviderClient):# -- family sub-clients --------------------------------------------------------def _family_client(self, family: str) -> ProviderClient:+ if self._api_key and family != "gemini":+ raise RuntimeError(+ "Vertex API keys cover Gemini models only — switch the Vertex provider "+ "to Google Cloud login or a service account for Claude and open-weight "+ "models (Settings ▸ Models)."+ )if family == "openweight":return self._openweight_client()client = self._clients.get(family)@@ -124,14 +152,18 @@ class VertexProvider(ProviderClient):if family == "gemini":from google import genai- client = GeminiProvider(- client=genai.Client(+ if self._api_key:+ # Express mode: the key excludes project/location (SDK enforces+ # mutual exclusivity — the key already identifies the project).+ sdk = genai.Client(vertexai=True, api_key=self._api_key)+ else:+ sdk = genai.Client(vertexai=True,project=self._project,location=self._location,credentials=self._explicit_credentials(),)- )+ client = GeminiProvider(client=sdk)else:from anthropic import AnthropicVertexdiff --git a/surfaces/gui/src/api.ts b/surfaces/gui/src/api.tsindex 516b6662..dcb54ac7 100644--- a/surfaces/gui/src/api.ts+++ b/surfaces/gui/src/api.ts@@ -1265,7 +1265,9 @@ export interface ProviderField {help: string;placeholder: string;default?: string; // pre-filled editable value (e.g. an OpenAI-compatible vendor's endpoint)- choices?: { value: string; label: string }[]; // non-empty → segmented choice, not a text input+ // Non-empty → segmented choice, not a text input. tag = tiny badge ("Easiest");+ // desc = one-liner atop the method panel; command = copyable terminal command.+ choices?: { value: string; label: string; tag?: string; desc?: string; command?: string }[];show_when?: Record<string, string> | null; // render only while these fields hold these values}diff --git a/surfaces/gui/src/providers/ProviderSetup.tsx b/surfaces/gui/src/providers/ProviderSetup.tsxindex 27e522e2..b2f962d4 100644--- a/surfaces/gui/src/providers/ProviderSetup.tsx+++ b/surfaces/gui/src/providers/ProviderSetup.tsx@@ -4,6 +4,7 @@ import {removeProvider,setProvider,verifyProvider,+ type ProviderField as ProviderFieldT,type ProviderInfo,} from "../api";import { openExternal } from "../tauri";@@ -321,7 +322,73 @@ export function ProviderForm({const label = "block text-[12px] text-muted mt-3 mb-1";const input ="w-full px-3 py-2 rounded-lg border bg-panel text-[13.5px] outline-none focus:border-accent";+ const fieldsAll = info?.fields || [];+ const keyed = fieldsAll.some((x) => x.secret);+ // Cloud providers declare a segmented auth-method choice; the selected method's+ // credential fields render inside a panel with its own Test & save footer.+ const choice = fieldsAll.find((f) => f.choices && f.choices.length);+ const method = choice ? ps.fields[choice.key] || choice.default || "" : "";+ const selected = choice?.choices?.find((c) => c.value === method);+ const methodFields = choice+ ? fieldsAll.filter(+ (f) =>+ f.show_when &&+ Object.entries(f.show_when).every(([k, v]) => (ps.fields[k] || "") === v),+ )+ : [];+ // Without a choice control, Test lives next to the required secret (the API key), or+ // the first field for keyless providers (Ollama's Detect).+ const requiredSecret = fieldsAll.find((x) => x.secret && x.required);+ const testKey = requiredSecret ? requiredSecret.key : fieldsAll[0]?.key;if (!sel) return null;++ const fieldRow = (f: ProviderFieldT, testable: boolean) => (+ <div key={f.key}>+ <label className={label}>{f.label}</label>+ <div className="flex gap-2">+ <div className="relative flex-1 min-w-0">+ <input+ className={input + (ps.savedState && testable ? " border-ok pr-32" : " border-line")}+ type={f.secret ? "password" : "text"}+ placeholder={f.secret && ps.credentialed && !ps.dirty ? "••••••••" : f.placeholder}+ value={ps.fields[f.key] || ""}+ data-testid={`${tp}-field-${f.key}`}+ onChange={(e) => ps.setFieldValue(f.key, e.target.value)}+ onBlur={f.secret ? undefined : () => void ps.saveField(f.key)}+ />+ {ps.fieldSaved === f.key && (+ <span+ className="absolute right-2 top-1/2 -translate-y-1/2 text-[11px] font-medium text-ok bg-okSoft rounded-full px-2 py-0.5 pointer-events-none"+ data-testid={`${tp}-field-saved-${f.key}`}+ >+ ✓ Saved+ </span>+ )}+ {/* §39: state lives IN the field — no status lines below. */}+ {ps.savedState && testable && (+ <span+ className="absolute right-2 top-1/2 -translate-y-1/2 text-[11px] font-medium text-ok bg-okSoft rounded-full px-2 py-0.5 pointer-events-none"+ data-testid={`${tp}-saved-pill`}+ >+ {info?.needs_key ? <>✓ Tested & saved</> : <>✓ Detected</>}+ </span>+ )}+ </div>+ {testable && (+ <button+ className="px-4 rounded-lg border border-line text-[13px] font-medium text-ink hover:border-lineStrong shrink-0 disabled:opacity-40"+ onClick={() => ps.runTestAndSave()}+ disabled={ps.verify.state === "testing" || (!ps.secretFilled && !ps.credentialed)}+ data-testid={`${tp}-test`}+ >+ {ps.verify.state === "testing" ? "…" : info?.needs_key ? "Test" : "Detect"}+ </button>+ )}+ </div>+ {f.help && <p className="text-[11.5px] text-faint mt-1">{f.help}</p>}+ </div>+ );+return (<div><button className="text-[12.5px] text-muted hover:text-ink" onClick={ps.backToGallery} data-testid={`${tp}-back`}>@@ -336,98 +403,87 @@ export function ProviderForm({</div>{info?.blurb && <p className="text-[11.5px] text-faint mt-1">{info.blurb}</p>}- {(info?.fields || []).map((f) => {- const keyed = (info?.fields || []).some((x) => x.secret);- // A keyed provider's base_url is an expert option — it renders BELOW the key-help- // line as its own advanced section (owner nit 2026-07-19), not inside the loop.- if (f.key === "base_url" && keyed) return null;- // Conditional fields (Bedrock's per-auth-method inputs) render only while their- // controlling field holds the matching value.- if (f.show_when && !Object.entries(f.show_when).every(([k, v]) => (ps.fields[k] || "") === v))- return null;- // Segmented choice (e.g. Bedrock's "Connect with"): a button per option, stored- // like any field value. Switching methods requires a fresh Test to save.- if (f.choices?.length)- return (- <div key={f.key}>- <label className={label}>{f.label}</label>- <div className="flex gap-1.5" role="radiogroup" aria-label={f.label}>- {f.choices.map((c) => {- const active = (ps.fields[f.key] || "") === c.value;- return (- <button- key={c.value}- role="radio"- aria-checked={active}- className={- "px-3 py-1.5 rounded-lg border text-[12.5px] transition-colors " +- (active- ? "border-accent text-ink font-medium"- : "border-line text-muted hover:border-lineStrong")- }- data-testid={`${tp}-choice-${f.key}-${c.value}`}- onClick={() => ps.setFieldValue(f.key, c.value)}- >- {c.label}- </button>- );- })}- </div>- {f.help && <p className="text-[11.5px] text-faint mt-1">{f.help}</p>}- </div>- );- // Test lives next to the required secret (the API key) when there is one; cloud- // providers whose secrets are all optional (Bedrock, Vertex) test from the first- // field instead — their credentials may be ambient (~/.aws, ADC).- const requiredSecret = (info?.fields || []).find((x) => x.secret && x.required);- const testable = requiredSecret ? f.key === requiredSecret.key : f.key === (info?.fields || [])[0]?.key;- return (- <div key={f.key}>- <label className={label}>{f.label}</label>- <div className="flex gap-2">- <div className="relative flex-1 min-w-0">- <input- className={input + (ps.savedState && testable ? " border-ok pr-32" : " border-line")}- type={f.secret ? "password" : "text"}- placeholder={f.secret && ps.credentialed && !ps.dirty ? "••••••••" : f.placeholder}- value={ps.fields[f.key] || ""}- data-testid={`${tp}-field-${f.key}`}- onChange={(e) => ps.setFieldValue(f.key, e.target.value)}- onBlur={f.secret ? undefined : () => void ps.saveField(f.key)}- />- {ps.fieldSaved === f.key && (- <span- className="absolute right-2 top-1/2 -translate-y-1/2 text-[11px] font-medium text-ok bg-okSoft rounded-full px-2 py-0.5 pointer-events-none"- data-testid={`${tp}-field-saved-${f.key}`}- >- ✓ Saved- </span>- )}- {/* §39: state lives IN the field — no status lines below. */}- {ps.savedState && testable && (- <span- className="absolute right-2 top-1/2 -translate-y-1/2 text-[11px] font-medium text-ok bg-okSoft rounded-full px-2 py-0.5 pointer-events-none"- data-testid={`${tp}-saved-pill`}- >- {info?.needs_key ? <>✓ Tested & saved</> : <>✓ Detected</>}- </span>- )}- </div>- {testable && (+ {fieldsAll+ .filter(+ (f) =>+ !f.show_when &&+ !(f.choices && f.choices.length) &&+ !(f.key === "base_url" && keyed),+ )+ .map((f) => fieldRow(f, !choice && f.key === testKey))}++ {/* Auth-method segmented control + the selected method's panel (owner call+ 2026-07-26): one joined track, then a soft inset card holding only that+ method's description, fields, and its own Test & save footer. */}+ {choice && (+ <div>+ <label className={label}>{choice.label}</label>+ <div+ className="inline-flex gap-0.5 rounded-[10px] border border-line bg-line/40 p-[3px]"+ role="radiogroup"+ aria-label={choice.label}+ >+ {(choice.choices || []).map((c) => {+ const active = method === c.value;+ return (<button- className="px-4 rounded-lg border border-line text-[13px] font-medium text-ink hover:border-lineStrong shrink-0 disabled:opacity-40"- onClick={() => ps.runTestAndSave()}- disabled={ps.verify.state === "testing" || (!ps.secretFilled && !ps.credentialed)}- data-testid={`${tp}-test`}+ key={c.value}+ role="radio"+ aria-checked={active}+ className={+ "flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-[12.5px] whitespace-nowrap transition-colors " ++ (active+ ? "bg-panel text-ink font-medium shadow-sm ring-1 ring-line"+ : "text-muted hover:text-ink")+ }+ data-testid={`${tp}-choice-${choice.key}-${c.value}`}+ onClick={() => ps.setFieldValue(choice.key, c.value)}>- {ps.verify.state === "testing" ? "…" : info?.needs_key ? "Test" : "Detect"}+ {c.label}+ {c.tag && (+ <span className="text-[9.5px] font-semibold uppercase tracking-wide text-accent bg-accentSoft rounded-full px-1.5 py-px">+ {c.tag}+ </span>+ )}</button>+ );+ })}+ </div>++ <div className="mt-2.5 rounded-xl border border-line bg-paper/60 px-4 pb-3.5 pt-3">+ {selected?.desc && <p className="text-[12px] text-muted">{selected.desc}</p>}+ {selected?.command && (+ <button+ className="mt-2.5 inline-flex items-center gap-2 rounded-lg border border-line bg-panel px-2.5 py-1.5 text-[12px] font-mono text-ink hover:border-lineStrong"+ onClick={() => void navigator.clipboard?.writeText(selected.command || "")}+ title="Copy command"+ data-testid={`${tp}-cmd-copy`}+ >+ {selected.command}+ <span className="font-sans text-[11px] text-faint">⧉</span>+ </button>+ )}+ {methodFields.map((f) => fieldRow(f, false))}+ <div className="mt-3.5 flex items-center justify-between gap-3 border-t border-line pt-3">+ {ps.savedState ? (+ <span className="text-[11.5px] font-medium text-ok" data-testid={`${tp}-saved-pill`}>+ ✓ Tested & saved+ </span>+ ) : (+ <span className="text-[11.5px] text-faint">Runs one read-only check, then saves.</span>)}+ <button+ className="shrink-0 rounded-lg border border-accent bg-accent px-4 py-1.5 text-[13px] font-medium text-white hover:brightness-105 disabled:opacity-40"+ onClick={() => ps.runTestAndSave()}+ disabled={ps.verify.state === "testing"}+ data-testid={`${tp}-test`}+ >+ {ps.verify.state === "testing" ? "…" : <>Test & save</>}+ </button></div>- {f.help && <p className="text-[11.5px] text-faint mt-1">{f.help}</p>}</div>- );- })}+ </div>+ )}{info?.needs_key && KEY_HELP[sel] && (<p className="text-[11.5px] text-faint mt-2">diff --git a/tests/test_vertex_provider.py b/tests/test_vertex_provider.pyindex b1f52b95..48055b03 100644--- a/tests/test_vertex_provider.py+++ b/tests/test_vertex_provider.py@@ -142,10 +142,25 @@ def test_vertex_descriptor_and_builder():d = get_descriptor("vertex")assert d is not None and d.needs_key- assert [f.key for f in d.fields] == ["project", "location", "service_account_json"]+ assert [f.key for f in d.fields] == [+ "project",+ "location",+ "auth_method",+ "service_account_json",+ "vertex_api_key",+ ]assert [f.key for f in d.fields if f.required] == ["project", "location"]- sa = next(f for f in d.fields if f.key == "service_account_json")- assert sa.secret and "Application Default Credentials" in sa.help+ # ADC is the default method (Google's own recommendation) and carries the copyable+ # sign-in command; the two credential fields hide behind their methods.+ method = next(f for f in d.fields if f.key == "auth_method")+ assert method.default == "adc"+ assert [c["value"] for c in method.choices] == ["adc", "service_account", "api_key"]+ adc = next(c for c in method.choices if c["value"] == "adc")+ assert adc["command"].startswith("gcloud auth application-default")+ by_key = {f.key: f for f in d.fields}+ assert by_key["service_account_json"].show_when == {"auth_method": "service_account"}+ assert by_key["vertex_api_key"].show_when == {"auth_method": "api_key"}+ assert by_key["service_account_json"].secret and by_key["vertex_api_key"].secretfrom coworker.providers.matrix import models_for_provider@@ -158,6 +173,108 @@ def test_vertex_descriptor_and_builder():assert p._project == "proj" and p._location == "europe-west1"+def test_auth_method_narrows_out_other_methods_fields():+ """Stale values stored under a previously-selected method must never leak into a+ different auth path."""+ p = VertexProvider(+ project="proj",+ location="us-east5",+ auth_method="adc",+ service_account_json="{stale}",+ api_key="AQ.stale",+ )+ assert p._service_account_json is None and p._api_key is None+ p2 = VertexProvider(+ project="proj",+ location="us-east5",+ auth_method="api_key",+ api_key="AQ.live",+ service_account_json="{stale}",+ )+ assert p2._api_key == "AQ.live" and p2._service_account_json is None+++def test_api_key_method_is_gemini_only():+ p = VertexProvider(+ project="proj", location="us-east5", auth_method="api_key", api_key="AQ.k"+ )+ msgs = [{"role": "user", "content": "x"}]+ with pytest.raises(RuntimeError, match="Gemini models only"):+ p.complete(model="claude/claude-sonnet-4-6", messages=msgs)+ with pytest.raises(RuntimeError, match="Gemini models only"):+ p.complete(model="openweight/meta/llama-4-maverick-maas", messages=msgs)+++def test_api_key_method_builds_express_gemini_client(monkeypatch):+ """Express mode: the key goes to genai.Client WITHOUT project/location (the SDK+ treats them as mutually exclusive with an API key)."""+ from google import genai++ captured: dict = {}++ class _FakeClient:+ def __init__(self, **kwargs):+ captured.update(kwargs)++ monkeypatch.setattr(genai, "Client", _FakeClient)+ p = VertexProvider(+ project="proj", location="us-east5", auth_method="api_key", api_key="AQ.k"+ )+ sub = p._family_client("gemini")+ from coworker.providers import GeminiProvider++ assert isinstance(sub, GeminiProvider)+ assert captured == {"vertexai": True, "api_key": "AQ.k"}+++def test_verify_vertex_api_key_method(monkeypatch):+ import httpx++ from coworker.providers.registry import verify_provider_key++ out = verify_provider_key(+ "vertex",+ fields={"project": "p", "location": "l", "auth_method": "api_key"},+ )+ assert not out["ok"] and "API key" in out["error"]++ captured: dict = {}++ def fake_get(url, headers=None, timeout=None, **kw):+ captured["url"] = url+ captured["headers"] = headers++ class _Resp:+ status_code = 200++ return _Resp()++ monkeypatch.setattr(httpx, "get", fake_get)+ out = verify_provider_key(+ "vertex",+ fields={+ "project": "p",+ "location": "l",+ "auth_method": "api_key",+ "vertex_api_key": "AQ.k",+ },+ )+ assert out == {"ok": True}+ assert captured["headers"]["x-goog-api-key"] == "AQ.k"+ # Express mode is global — no region host, no project in the path.+ assert captured["url"] == "https://aiplatform.googleapis.com/v1/publishers/google/models"+++def test_verify_vertex_service_account_requires_json():+ from coworker.providers.registry import verify_provider_key++ out = verify_provider_key(+ "vertex",+ fields={"project": "p", "location": "l", "auth_method": "service_account"},+ )+ assert not out["ok"] and "service-account JSON" in out["error"]++def test_vertex_configured_needs_project_and_location():from coworker.providers.registry import descriptor_configured, get_descriptor