@maci0/dsh-google-vertex 0.0.0-stage → 0.12.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,167 @@
-# Temporary Holding Version
+# dsh-google-vertex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+One Google service-account JSON file unlocks eleven models inside DeepSeek Harness: Claude Opus 4.6, Sonnet 4.6, Opus 4.5, Sonnet 4.5, Haiku 4.5, plus Gemini 3.5 Flash, 3.1 Pro Preview, 3 Flash Preview, 2.5 Pro, 2.5 Flash, 2.5 Flash-Lite.
+Install it when your model capacity already lives in a Google Cloud project and you would rather point Harness at a credential file than paste an API key.
+Nothing is copied into the harness credential store: the file is read once at mount, and each request trades a signed RS256 assertion for a cached OAuth token.
+
+## What you get
+
+- Two provider routes from one configuration row (`google-vertex-anthropic` for Claude and `google-vertex-gemini` for Gemini), both in the Web model picker.
+- Service-account auth with no API key: a path in config, or `GOOGLE_APPLICATION_CREDENTIALS`.
+- Streaming with tool calling on both routes. Claude emits raw JSON argument deltas; Gemini emits complete function calls and replays the thought signature Gemini 3 requires.
+- The Gemini catalog discovered from Vertex at runtime behind a five-minute cache, with the built-in list as the fallback when the provider cannot be reached. The Claude catalog is served from the configured (or built-in) list.
+- A **Refresh models** control on this plugin's row page, which drops both caches and re-reads the model picker without restarting `dsh web`.
+- Claude prompt-cache breakpoints on tools, system, and the final conversation block, with cache read/write counts reported as usage.
+- Failure codes the harness can act on: `429` → `RATE_LIMIT`, `5xx` → `SERVER`, `RESOURCE_EXHAUSTED` → `QUOTA`, oversized → `CONTEXT_WINDOW_EXCEEDED`, a stalled stream → `TIMEOUT`.
+- Environment fallbacks for the credential, project, and region.
+
+## Install
+
+> **Install it as a bundle.** `dsh plugin add …` mounts the row from the
+> package's own patch layer, which is what the settings editor can write to. A
+> row added with `--patch` is an overlay: it disappears at the next start, and
+> the Plugins card cannot save into it (the editor refuses a write an overlay
+> would win).
+
+```sh
+dsh plugin --profile web add @maci0/dsh-google-vertex@0.12.4
+```
+
+This installs the public npm package; no GitHub token or `~/.secrets` setup is needed.
+The version is pinned. To upgrade, run the same command with a newer version,
+then restart `dsh web` (bundle layers compose at boot).
+
+The package declares `dsh.bundle`, so `dsh plugin` appends it to `dsh.profile.bundles` and the package's own `cordis.patch.yml` inserts the `google-vertex` row: there is no row to paste. Adding that row by hand while the package is a bundle mounts the plugin twice, because `insert` does not dedupe ids.
+
+## Configure
+
+Override the row by id in `~/.dsh/profiles/web/cordis.patch.yml`:
+
+```yaml
+- id: google-vertex
+  config:
+    serviceAccountFile: ~/.secrets/global-claude-project.json
+    project: global-claude-project
+    location: global
+```
+
+`~` is expanded, and the file is read once at mount, so a typo fails loudly instead of mid-turn. A patch replaces the targeted row's whole `config`, so restate every key you keep. This file is live-watched: saving it remounts the plugin, no restart.
+
+| Key | Default | Meaning |
+|---|---|---|
+| `serviceAccountFile` | `$GOOGLE_APPLICATION_CREDENTIALS` | Path to the service-account JSON; `~` is expanded. Nothing is copied into the harness credential store: the file is the credential, and it is read once at mount. |
+| `project` | `$GOOGLE_CLOUD_PROJECT`, `$GCLOUD_PROJECT`, then the file's `project_id` | Google Cloud project id, used by both routes. |
+| `location` | `$GOOGLE_CLOUD_LOCATION`, then `global` | Region for both endpoints, or `global` for `aiplatform.googleapis.com`. |
+| `models` | the Claude catalog below | Claude ids to advertise, replacing the built-in catalog. Any id is accepted at request time regardless. |
+| `geminiModels` | the Gemini catalog below | Gemini ids to advertise, served as written: a configured list turns live discovery off. Every entry serves the same context/output pair. |
+| `contextWindow` | `200000` | Claude context window reported per model. |
+| `maxTokens` | `32000` | Claude output cap applied when a caller omits one. |
+| `streamIdleTimeoutMs` | `300000` | Bound on the interval between two stream reads, on both routes. |
+
+Environment variables are read from `process.env` of the harness process.
+
+## Routes and models
+
+Vertex serves the two publishers over different paths, which is why one row registers two routes. The service-account path, project, and region are written once.
+
+| Route | Provider path | Serves |
+|---|---|---|
+| `google-vertex-anthropic` | `publishers/anthropic/models/{model}:streamRawPredict` | Claude, picker group **Google Vertex AI (Anthropic)** |
+| `google-vertex-gemini` | `publishers/google/models/{model}:streamGenerateContent?alt=sse` | Gemini, picker group **Google Vertex AI (Gemini)** |
+
+Claude defaults. Every listed family serves 200k context and caps output at 32k unless a caller asks otherwise:
+
+| Picker label | Model id |
+|---|---|
+| Claude Opus 4.6 (Vertex) | `claude-opus-4-6` |
+| Claude Sonnet 4.6 (Vertex) | `claude-sonnet-4-6` |
+| Claude Opus 4.5 (Vertex) | `claude-opus-4-5` |
+| Claude Sonnet 4.5 (Vertex) | `claude-sonnet-4-5` |
+| Claude Haiku 4.5 (Vertex) | `claude-haiku-4-5` |
+
+Gemini defaults. Every entry serves the same context/output pair:
+
+| Picker label | Model id | Context | Max output |
+|---|---|---|---|
+| Gemini 3.5 Flash (Vertex) | `gemini-3.5-flash` | 1,048,576 | 65,535 |
+| Gemini 3.1 Pro Preview (Vertex) | `gemini-3.1-pro-preview` | 1,048,576 | 65,535 |
+| Gemini 3 Flash Preview (Vertex) | `gemini-3-flash-preview` | 1,048,576 | 65,535 |
+| Gemini 2.5 Pro (Vertex) | `gemini-2.5-pro` | 1,048,576 | 65,535 |
+| Gemini 2.5 Flash (Vertex) | `gemini-2.5-flash` | 1,048,576 | 65,535 |
+| Gemini 2.5 Flash-Lite (Vertex) | `gemini-2.5-flash-lite` | 1,048,576 | 65,535 |
+
+The Gemini cap is one below Vertex's own ceiling on purpose: `maxOutputTokens: 65536` is refused with "supported range is from 1 (inclusive) to 65536 (exclusive)".
+
+Ids are Vertex's aliases, so a promoted release needs no edit here. Both catalogs are overridable from configuration for a deployment that pins dated versions.
+
+### Discovery and refresh
+
+The lists above are the fallback, not the whole catalog. Gemini models are read from Vertex's `publishers/google/models` list (a `v1beta1` method: v1 has no list), keeping `gemini-` ids except the embedding, TTS, image, Live, and audio variants this text route cannot drive. A built-in id keeps its picker label; any other is labelled by its id. The result is cached for five minutes so opening the model picker is not a network call. The Claude list is served exactly as configured, because Vertex exposes no Anthropic model listing endpoint.
+
+The picker re-reads that catalog when the host says a model input changed, so a model Google published a minute ago stays invisible until then. This plugin's row page carries the control that forces it: open **Plugins** in the sidebar, open the `dsh-google-vertex` bundle, and configure the `google-vertex` row. **Refresh models** drops the cached Gemini catalog and makes the picker re-read it from this process. The card records the last manual refresh in its own `google-vertex` settings namespace, and the write is also the signal: a browser half has no other channel to the host.
+
+## Try it
+
+1. Restart `dsh web`, then open a session.
+2. Type `/model` in the composer, or click the model seat beside it.
+3. Pick **Google Vertex AI (Anthropic)** → **Claude Sonnet 4.6 (Vertex)**, or the Gemini group for a Gemini model. Selecting a model also makes it the default for new sessions; a session that already sent a request keeps the model recorded in its own log.
+4. Type a prompt that needs a tool:
+
+```
+List the files in this directory and tell me which one is largest.
+```
+
+The agent runs a shell tool and answers from its output. The same works on the Gemini group, including the signed replay of the model's function call.
+
+## How it works
+
+Failed HTTP requests forward valid `Retry-After` seconds or HTTP dates to the harness retry policy. Invalid, non-positive, and past delays are omitted.
+
+- **Auth.** The service-account JSON is read once at mount. Per request, a JWT is signed with its private key, sent to the file's `token_uri` (or Google's public token endpoint when the file omits one), and traded for an access token (`https://www.googleapis.com/auth/cloud-platform`), which is cached and refreshed five minutes before expiry. The request carries it as a bearer token. A credential problem reports `AUTH`; a token-endpoint transport problem reports `TRANSPORT`.
+- **Streaming.** Both routes bound every read by `streamIdleTimeoutMs`, including HTTP error bodies. The watchdog owns its own controller, so a stalled read is torn down and the turn ends with a single `TIMEOUT` failure instead of hanging. Caller cancellation ends as an `aborted` finish, not a provider error.
+- **Failure classification.** A refused HTTP response and an in-band provider error envelope classify the same way: a named cause first (`RESOURCE_EXHAUSTED` → `QUOTA`, oversized prompt → `CONTEXT_WINDOW_EXCEEDED`), then the numeric code (`429` → `RATE_LIMIT`, `5xx` → `SERVER`, `404` → `NOT_FOUND`). Gemini has no terminal event, so a body that ends without a finish reason is a truncated response unless the watchdog or an in-band error already ended the turn.
+- **Replay.** Gemini 3 signs its function calls, and a replay that drops the signature is refused with `400 INVALID_ARGUMENT: Function call is missing a thought_signature in functionCall parts`. The adapter stores each emitted block's `thoughtSignature` in the harness replay envelope and echoes it on the next request. Signatures are per model, so a cross-model replay sends the call unsigned rather than failing. No `thinkingConfig` is ever sent: Gemini's dynamic-thinking default is what keeps `gemini-2.5-pro` working. Thinking tokens still arrive in `usageMetadata` and count as output.
+- **Attribution.** Requests carry `attributionHeaders()` from `@deepseek-ai/dsh-llm` rather than a pinned release line, so `User-Agent` cannot drift from the installed harness.
+
+## Limits
+
+- **Text only.** Both routes declare `inputModalities: ['text']`, so the harness projects images and files to placeholder text before dispatch. Claude and Gemini on Vertex both accept images; wiring the attachment service into these adapters is the work that would add it.
+- **No extended thinking on Claude.** That route never sends a `thinking` block, and replaying one needs a thinking signature the harness reasoning block cannot hold. Enabling thinking without it makes every tool round trip fail.
+- **Gemini thought summaries are dropped** for the same signature reason, so only answer text is shown.
+- **Vertex AI API must be enabled** on the project, and the service account needs `roles/aiplatform.user`.
+- **Claude is not servable in every region.** `global`, `us-east5`, and `europe-west1` answered; `us-central1` returned `400 FAILED_PRECONDITION: … is not servable in region us-central1`. A `404 NOT_FOUND` naming the publisher model means the id does not exist on Vertex; `429 RESOURCE_EXHAUSTED` is the project's quota, not a bad request.
+- **Claude prompt caching has provider-side minimums.** Blocks under the cacheable minimum are accepted and simply not cached.
+
+### The pi-ai `google-vertex` route
+
+Harness already ships a pi-ai-backed `google-vertex` route that serves Gemini from a credential record carrying the same three environment values. It accepts images and surfaces thinking summaries; this plugin's Gemini route is text-only and drops them. Choose it when those matter. Its record in `~/.dsh/.credentials.yaml` (owner-only, mode 600, live-watched):
+
+```yaml
+records:
+  llm-pi-ai/google-vertex:
+    kind: api-key
+    env:
+      GOOGLE_APPLICATION_CREDENTIALS: /path/to/service-account.json
+      GOOGLE_CLOUD_PROJECT: global-claude-project
+      GOOGLE_CLOUD_LOCATION: global
+```
+
+Two of its catalog entries disagree with Vertex's own limits, so those models need an override in `~/.dsh/settings.yaml` under `llm-pi-ai.providers.google-vertex.modelOverrides`: `gemini-2.5-pro` needs `reasoningEfforts: false` (Vertex rejects `thinkingBudget: 0` with `400 INVALID_ARGUMENT`), and `gemini-2.5-flash-lite` needs `maxTokens: 65535`. This plugin's own Gemini route needs neither.
+
+## Development
+
+```sh
+bun test           # hermetic, stubbed transport, no network
+bun run build      # tsc -p tsconfig.build.json → lib/index.js + lib/types/
+bun run typecheck  # tsc -p tsconfig.json
+```
+
+The package ships the built `lib/` and declares `dsh.bundle`, so a change to `src/` needs `bun run build` before it takes effect. For local development, run `bun run build`, then `dsh plugin --profile <name> add <path-to-checkout>` and restart `dsh web`. `lib/client.js` is the exception: the browser half is authored directly as plain JavaScript in the client module loader's factory format and is not produced by `tsc`.
+
+Coverage: the signed assertion, token caching and refresh, both auth failure classes, request projection, cache breakpoints, Gemini request projection with signature replay, SSE framing across split chunks, every terminal finish class (including the stream idle bound and an in-band provider error envelope), usage reported only when the provider reported it, and configuration validation. A real Cordis `Context` mount proves both routes are registered and withdrawn with the fiber, and that the plugin's settings change drops both cached catalogs. The browser half is imported from `lib/client.js` under a stub of the module loader's own registration format, which is how its slot, its Refresh control, and its write are covered without a browser.
+
+dsh loads plugins on Node `^22.19.0 || >=24.0.0`; development and tests run on bun.
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

package/cordis.patch.yml

@@ -0,0 +1,34 @@
+# The dsh-google-vertex bundle patch: applied automatically when a profile
+# lists this bundle. Users override this row from their profile's own
+# cordis.patch.yml (live-watched; dsh.profile.bundles is frozen at boot) with a
+# `- id: google-vertex` row, which replaces the row's whole `config`.
+#
+# One row registers two routes:
+#   google-vertex-anthropic: Google-hosted Claude (publishers/anthropic)
+#   google-vertex-gemini:    Gemini (publishers/google)
+- insert:
+    - id: google-vertex
+      name: '@maci0/dsh-google-vertex'
+      config:
+        # Service-account JSON path ('~' allowed). Left unset here so the
+        # $GOOGLE_APPLICATION_CREDENTIALS fallback applies; a deployment that
+        # keeps the file elsewhere overrides this row with the path. Mount
+        # fails loudly when neither is set.
+        # serviceAccountFile: ~/.secrets/your-service-account.json
+        # Google Cloud project. Optional: falls back to $GOOGLE_CLOUD_PROJECT,
+        # $GCLOUD_PROJECT, then the credentials file's own project_id.
+        # project: my-project
+        # Region for both Vertex endpoints, or 'global' (default) for
+        # aiplatform.googleapis.com. Optional: falls back to
+        # $GOOGLE_CLOUD_LOCATION. Claude is not servable in every region.
+        # location: us-east5
+        # Claude model ids, replacing the built-in catalog.
+        # models:
+        #   - claude-sonnet-4-5
+        # Gemini model ids, replacing the built-in catalog and live discovery.
+        # geminiModels:
+        #   - gemini-3.5-flash
+        #   - gemini-2.5-pro
+        # Claude context window and output cap reported for every model.
+        # contextWindow: 200000
+        # maxTokens: 32000

package/icon.svg

@@ -0,0 +1,6 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M16.4 11.2L11.2 23.4M19.6 11.2L24.8 23.4M12.4 26.2h11.2" stroke="#3D5AFE" stroke-width="1.8" stroke-linecap="round"/>
+  <circle cx="18" cy="8.2" r="3.2" fill="#5B6CFF"/>
+  <circle cx="9" cy="26.6" r="3.2" fill="#45D9E7"/>
+  <circle cx="27" cy="26.6" r="3.2" fill="#7CB7FF"/>
+</svg>

package/lib/adapter.js

@@ -0,0 +1,398 @@
+/**
+ * The machinery both Vertex publisher adapters share, plus the Claude route's
+ * own adapter: one metadata face the harness calls on every dispatch, and one
+ * streaming pipeline carrying the per-read idle watchdog, the token mint, the
+ * fetch, the refusal classification, the SSE loop, and the single-terminal-chunk
+ * guarantee.
+ *
+ * Two things separate the Claude route from the pi-ai-backed `google-vertex`
+ * route the harness already ships. Its credential is a service-account file,
+ * turned into a bearer token per request by {@link ServiceAccountTokens} rather
+ * than typed in as an API key. And its models are Claude, which Vertex serves
+ * through `publishers/anthropic`, a path and body the Gemini protocol cannot
+ * express.
+ *
+ * Both routes are text-only: `inputModalities: ['text']` makes `LlmRuntime`
+ * project images and files to placeholder text before dispatch, which is honest
+ * about what these adapters send.
+ *
+ * The two routes differ in exactly three things: how a request is addressed
+ * and built, what the provider's payloads mean, and what a body that ends
+ * without a terminal event should be called. Each is an injected callback;
+ * everything else lives here once.
+ *
+ * @module dsh-google-vertex/adapter
+ */
+import { attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { ServiceAccountTokens, VertexAuthError } from './auth.js';
+import { ModelCache } from './discovery.js';
+import { buildRequestBody, endpointFor, failureForStatus, parseSseRecord, SseRecordReader, StreamTranslator, } from './wire.js';
+/** Terminal error finish carrying one failure. */
+function errorFinish(failure) {
+    return { type: 'finish', reason: { kind: 'error', failure } };
+}
+/** Terminal aborted finish carrying one failure. */
+function abortedFinish(failure) {
+    return { type: 'finish', reason: { kind: 'aborted', failure } };
+}
+/**
+ * The failure for a stream that produced no bytes within the configured bound.
+ * @param idleTimeoutMs - the configured per-read bound.
+ * @returns the terminal failure, coded `TIMEOUT`.
+ */
+function idleTimeoutFailure(idleTimeoutMs) {
+    return {
+        message: `google-vertex: no stream data for ${idleTimeoutMs}ms (streamIdleTimeoutMs)`,
+        code: 'TIMEOUT',
+    };
+}
+/** Classify a credential failure raised before the request was sent. */
+function credentialFailure(error) {
+    if (error instanceof VertexAuthError) {
+        return { message: error.message, code: error.code };
+    }
+    return {
+        message: `google-vertex: ${error instanceof Error ? error.message : String(error)}`,
+        code: 'AUTH',
+    };
+}
+/** Classify a fetch or body-read failure, distinguishing cancellation. */
+function transportFinish(options, error) {
+    if (options.signal?.aborted === true) {
+        return abortedFinish({ message: 'google-vertex: request aborted', code: 'ABORTED' });
+    }
+    return errorFinish({
+        message: `google-vertex: ${error instanceof Error ? error.message : String(error)}`,
+        code: 'TRANSPORT',
+    });
+}
+/**
+ * One streaming completion, shared by both publisher routes.
+ *
+ * The bearer token is minted before the request, so a credentials failure is
+ * reported as a terminal finish rather than as a thrown error escaping the
+ * generator; `LlmRuntime` would turn a throw into a finish too, but would code
+ * it `UNKNOWN` and lose the `AUTH` versus `TRANSPORT` classification.
+ *
+ * Every read is bounded by `streamIdleTimeoutMs`: a provider that stops sending
+ * is a terminal `TIMEOUT` rather than a turn that never ends. The watchdog owns
+ * its own controller so the stalled read can be torn down; the caller's signal
+ * is combined with it when present. The token mint is armed and cleared with
+ * the same bound, because it is a network call too.
+ *
+ * Exactly one terminal chunk leaves this stream. A body that ended without the
+ * provider's terminal event is a truncated response, unless the watchdog or the
+ * caller ended the turn, which is the more specific account of the same missing
+ * event.
+ * @param config - the resolved configuration this adapter serves.
+ * @param options - the harness request.
+ * @param fetch - transport, already defaulted by the adapter.
+ * @param tokens - token source, already defaulted by the adapter.
+ * @param makeTranslator - builds this route's payload translator for one model.
+ * @param pump - this route's endpoint, body, and terminal wording.
+ * @yields every chunk the provider's stream completes.
+ */
+export async function* streamVertex(config, options, fetch, tokens, makeTranslator, pump) {
+    const model = options.model.length > 0 ? options.model : config.models[0]?.id ?? '';
+    const consumer = new AbortController();
+    const signal = options.signal === undefined
+        ? consumer.signal
+        : AbortSignal.any([options.signal, consumer.signal]);
+    let idleTimedOut = false;
+    let idleTimer;
+    /** True while an operation of the provider's is outstanding. */
+    let idleReading = false;
+    let idleStartedAt = 0;
+    /**
+     * One timer wakes when the outstanding read would have outlived the bound;
+     * while the provider keeps answering it re-arms itself for the remainder, so
+     * a stream costs one timer instead of one `setTimeout`/`clearTimeout` pair per
+     * transport read.
+     */
+    const checkIdle = () => {
+        idleTimer = undefined;
+        // Nothing outstanding: leave the timer unarmed; the next arm creates one.
+        // This also keeps a stream a consumer abandoned collectable.
+        if (!idleReading)
+            return;
+        const elapsed = performance.now() - idleStartedAt;
+        if (elapsed >= config.streamIdleTimeoutMs) {
+            idleTimedOut = true;
+            consumer.abort('google-vertex: stream idle timeout');
+            return;
+        }
+        // The wake-up preceded this read's own deadline: sleep the remainder.
+        idleTimer = setTimeout(checkIdle, config.streamIdleTimeoutMs - elapsed);
+    };
+    const armIdle = () => {
+        idleReading = true;
+        idleStartedAt = performance.now();
+        idleTimer ??= setTimeout(checkIdle, config.streamIdleTimeoutMs);
+    };
+    /** A read resolved: nothing of the provider's is outstanding any more. */
+    const clearIdle = () => {
+        idleReading = false;
+    };
+    /** No operation will be armed again: leave no timer holding the event loop. */
+    const disarmIdle = () => {
+        idleReading = false;
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+        idleTimer = undefined;
+    };
+    let token;
+    armIdle();
+    try {
+        // The token mint is a network call too: an unbounded one stalls the same
+        // way a stalled body does.
+        token = await tokens.get(signal);
+    }
+    catch (error) {
+        if (idleTimedOut) {
+            yield errorFinish(idleTimeoutFailure(config.streamIdleTimeoutMs));
+            return;
+        }
+        if (options.signal?.aborted === true) {
+            yield transportFinish(options, error);
+            return;
+        }
+        yield errorFinish(credentialFailure(error));
+        return;
+    }
+    finally {
+        disarmIdle();
+    }
+    let response;
+    armIdle();
+    try {
+        response = await fetch(pump.endpoint(model, config), {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'accept': 'text/event-stream',
+                ...attributionHeaders(),
+                'authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify(pump.body(options, config)),
+            signal,
+        });
+    }
+    catch (error) {
+        if (idleTimedOut) {
+            yield errorFinish(idleTimeoutFailure(config.streamIdleTimeoutMs));
+            return;
+        }
+        yield transportFinish(options, error);
+        return;
+    }
+    finally {
+        disarmIdle();
+    }
+    if (!response.ok) {
+        let body;
+        armIdle();
+        try {
+            body = await response.text().catch(() => '');
+        }
+        finally {
+            disarmIdle();
+        }
+        yield idleTimedOut ? errorFinish(idleTimeoutFailure(config.streamIdleTimeoutMs))
+            : options.signal?.aborted === true ? transportFinish(options, options.signal.reason)
+                : errorFinish(failureForStatus(response.status, body, `model "${model}" in ${config.location}`, response.headers));
+        return;
+    }
+    if (response.body === null) {
+        yield errorFinish({ message: 'google-vertex: response carried no body', code: 'TRANSPORT' });
+        return;
+    }
+    const translator = makeTranslator(model);
+    try {
+        // The reader is driven directly rather than through an async generator:
+        // one record costs one loop turn instead of a suspended generator frame,
+        // a promise, and a microtask.
+        const reader = new SseRecordReader(response.body, { armIdle, clearIdle });
+        try {
+            for (let records = await reader.read(); records !== undefined; records = await reader.read()) {
+                for (const record of records) {
+                    const event = parseSseRecord(record);
+                    if (event === undefined)
+                        continue;
+                    yield* translator.handle(event);
+                    // The provider ended the turn mid-body (`message_stop`, or an
+                    // in-band error envelope). Its finish has been emitted, so neither the
+                    // end of the body nor a close fault may add a second one.
+                    if (translator.terminal)
+                        return;
+                }
+            }
+        }
+        finally {
+            await reader.close();
+        }
+    }
+    catch (error) {
+        // The provider already ended the turn, so a fault while closing the body
+        // cannot add a second terminal chunk.
+        if (translator.terminal)
+            return;
+        if (idleTimedOut) {
+            yield errorFinish(idleTimeoutFailure(config.streamIdleTimeoutMs));
+            return;
+        }
+        yield transportFinish(options, error);
+        return;
+    }
+    finally {
+        disarmIdle();
+    }
+    if (idleTimedOut) {
+        yield errorFinish(idleTimeoutFailure(config.streamIdleTimeoutMs));
+        return;
+    }
+    if (options.signal?.aborted === true) {
+        yield transportFinish(options, options.signal?.reason);
+        return;
+    }
+    // The body ended without the provider's own finish: a truncated response,
+    // which is the more specific account of a turn the caller or the watchdog
+    // already ended.
+    if (!(translator.sawFinish ?? translator.terminal)) {
+        yield errorFinish({ message: pump.truncatedMessage(model), code: 'TRANSPORT' });
+        return;
+    }
+    yield* translator.finish?.() ?? [];
+}
+/**
+ * Duck-typed base for both Vertex publisher adapters.
+ *
+ * `LlmRuntime` reaches adapters through plain method calls, so these objects
+ * need no harness base class; the plugin's only runtime `@deepseek-ai/*`
+ * dependency is `@deepseek-ai/dsh-llm`'s pure `attributionHeaders()` helper.
+ * The metadata face below is identical for both routes, so it is written once
+ * and parameterized by {@link AdapterMetadata}.
+ */
+export class VertexPublisherAdapter {
+    #metadata;
+    #modelCache;
+    #discover;
+    /** The config this adapter serves, for the stream pipeline below. */
+    config;
+    /** The transport this adapter was built with. */
+    fetch;
+    /** The token source this adapter asks before each request. */
+    tokens;
+    /**
+     * @param metadata - display name, capacities, and description text.
+     * @param config - the resolved configuration this adapter serves.
+     * @param options - transport, token-source, and discovery overrides.
+     */
+    constructor(metadata, config, options = {}) {
+        this.#metadata = metadata;
+        this.config = config;
+        this.fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+        this.tokens = options.tokens ?? new ServiceAccountTokens(config.serviceAccount, { fetch: this.fetch });
+        this.#discover = options.discover;
+        this.#modelCache = new ModelCache(config.models);
+    }
+    /** {@inheritDoc LlmAdapterLike.providerInfo} */
+    providerInfo(provider) {
+        return { id: provider, name: this.#metadata.providerName };
+    }
+    /**
+     * No provider-owned retry policy: Vertex's own 429s carry a quota code the
+     * harness already classifies, and a per-request backoff belongs to the
+     * harness defaults.
+     *
+     * This and {@link imageRequestPricing} exist because `LlmRuntime` calls them
+     * on every dispatch; a duck-typed adapter must supply them or the first
+     * registration throws.
+     */
+    providerRetryPolicy(_provider) {
+        return undefined;
+    }
+    /** No route charges visual tokens: these adapters are text-only. */
+    imageRequestPricing(_provider, _model) {
+        return undefined;
+    }
+    /**
+     * The current model catalog, fetched from the provider when discovery is
+     * configured, falling back to the static catalog on failure.
+     *
+     * The result is cached with a five-minute TTL so the model picker does
+     * not make a network call on every open.
+     */
+    async listModels(provider) {
+        const models = await this.#modelCache.get(this.#discover);
+        return models.map(model => this.#info(provider, model.id, model.name));
+    }
+    /**
+     * Drop the cached catalog, so the next `listModels` re-discovers from the
+     * provider. Both adapters answer the plugin's manual refresh with this.
+     */
+    invalidateModels() {
+        this.#modelCache.invalidate();
+    }
+    /** {@inheritDoc LlmAdapterLike.resolveModel} */
+    resolveModel(provider, model, _signal) {
+        const capacity = this.#metadata.capacity;
+        return Promise.resolve({
+            ...this.#info(provider, model),
+            context: { contextWindow: capacity.contextWindow },
+            defaultMaxTokens: capacity.defaultMaxTokens,
+        });
+    }
+    /** {@inheritDoc LlmAdapterLike.prepareCall} */
+    async prepareCall(provider, model, signal) {
+        return {
+            model: await this.resolveModel(provider, model, signal),
+            stream: (options) => this.stream(options),
+        };
+    }
+    /** Display metadata for one model id, named from the catalog or the given name. */
+    #info(provider, model, overrideName) {
+        const known = this.config.models.find(entry => entry.id === model);
+        const name = overrideName ?? known?.name ?? model;
+        return {
+            provider,
+            id: model,
+            name,
+            description: this.#metadata.describe(this.config),
+            inputModalities: ['text'],
+        };
+    }
+}
+/**
+ * Duck-typed adapter over Vertex's Anthropic publisher endpoint.
+ *
+ * The route is text-only and declares no server-executed tools, and every
+ * Claude family in the default catalog serves the same 200k context, so a
+ * model's capacities are the configured pair rather than a per-model entry.
+ */
+export class GoogleVertexAnthropicAdapter extends VertexPublisherAdapter {
+    /**
+     * @param config - the resolved configuration this adapter serves.
+     * @param options - transport, token-source, and discovery overrides for tests.
+     */
+    constructor(config, options = {}) {
+        super({
+            providerName: 'Google Vertex AI (Anthropic)',
+            capacity: { contextWindow: config.contextWindow, defaultMaxTokens: config.maxTokens },
+            describe: row => `Google-hosted Anthropic model on Vertex AI (project ${row.project}, ${row.location}).`,
+        }, config, options);
+    }
+    /**
+     * Stream one completion through `:streamRawPredict`.
+     *
+     * The shared pump owns the watchdog, the token mint, the SSE loop, and the
+     * single terminal chunk; `message_stop` closes the turn mid-body, so this
+     * route's finish rides that event.
+     */
+    stream(options) {
+        return streamVertex(this.config, options, this.fetch, this.tokens, () => new StreamTranslator(), {
+            endpoint: (model, config) => endpointFor(config.project, config.location, model),
+            body: (request, config) => buildRequestBody(request, config),
+            truncatedMessage: model => `google-vertex: model "${model}" stream ended before message_stop`,
+        });
+    }
+}