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

package/lib/types/gemini.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Wire translation for Google's own Gemini models on Vertex AI: the request
+ * body `publishers/google` accepts, the SSE response shape, and (the part that
+ * makes tool calling work at all on Gemini 3) the thought signature that has to
+ * travel back with every replayed function call.
+ *
+ * Everything here is pure: the adapter feeds it bytes and yields the chunks it
+ * returns, so the protocol is testable without a harness or a network.
+ *
+ * @module dsh-google-vertex/gemini
+ */
+import type { FinishReason, GenerateOptions, Message, StreamChunk, TokenUsage } from './host.ts';
+import type { VertexWireConfig } from './wire.ts';
+import type { VertexModel } from './adapter.ts';
+/** Harness code reported when the provider refused on safety grounds. */
+export declare const SAFETY_BLOCKED_CODE = "SAFETY";
+/**
+ * Gemini context capacity: every current Gemini model serves roughly a million
+ * tokens, and the catalog below narrows nothing.
+ */
+export declare const DEFAULT_GEMINI_CONTEXT_WINDOW = 1048576;
+/**
+ * Output cap applied when a caller omits one.
+ *
+ * Vertex's ceiling here is EXCLUSIVE: `maxOutputTokens: 65536` is refused with
+ * "supported range is from 1 (inclusive) to 65536 (exclusive)", so the highest
+ * accepted value is one less.
+ */
+export declare const DEFAULT_GEMINI_MAX_TOKENS = 65535;
+/**
+ * Gemini models the global endpoint serves, in picker order. Ids are the
+ * provider's own aliases, so a promoted release needs no edit here.
+ */
+export declare const DEFAULT_GEMINI_MODELS: readonly VertexModel[];
+/**
+ * The streaming publisher path for one Gemini model.
+ * @param project - Google Cloud project id.
+ * @param location - region, or `global`.
+ * @param model - publisher model id, e.g. `gemini-3.5-flash`.
+ * @returns the absolute request URL, with the SSE response encoding.
+ */
+export declare function geminiEndpointFor(project: string, location: string, model: string): string;
+/** One function call the model requested. */
+interface GeminiFunctionCall {
+    name: string;
+    args?: Record<string, unknown>;
+    id?: string;
+}
+/** One function result being sent back. */
+interface GeminiFunctionResponse {
+    name: string;
+    id?: string;
+    response: Record<string, unknown>;
+}
+/** One content part on the wire. */
+interface GeminiPart {
+    text?: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+    functionCall?: GeminiFunctionCall;
+    functionResponse?: GeminiFunctionResponse;
+}
+/** One wire content turn. */
+export interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+/** One wire tool declaration. */
+interface GeminiToolDeclaration {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+/** The request body `:streamGenerateContent` accepts. */
+export interface GeminiRequestBody {
+    contents: GeminiContent[];
+    systemInstruction?: {
+        parts: {
+            text: string;
+        }[];
+    };
+    tools?: {
+        functionDeclarations: GeminiToolDeclaration[];
+    }[];
+    generationConfig?: {
+        temperature?: number;
+        maxOutputTokens?: number;
+        stopSequences?: string[];
+    };
+}
+/**
+ * Index-aligned provider metadata for one emitted block.
+ *
+ * Vertex requires the thought signature of a function call to be echoed when the
+ * call is replayed with its result; dropping it is a 400
+ * ("Function call is missing a thought_signature"). Text parts can carry one
+ * too, so the entry is kept for both block kinds.
+ */
+interface GeminiReplayBlock {
+    readonly type: 'text' | 'tool-call';
+    readonly thoughtSignature?: string;
+}
+/** The envelope the harness stores on an assistant message and hands back. */
+interface GeminiReplayEnvelope {
+    readonly response: {
+        readonly kind: 'google-vertex-gemini';
+        readonly version: 1;
+        readonly model: string;
+    };
+    readonly blocks: readonly GeminiReplayBlock[];
+}
+/**
+ * Build the replay envelope for one finished response.
+ * @param model - the model that produced the response.
+ * @param blocks - per-block metadata in emitted order.
+ * @returns the envelope for the terminal finish chunk.
+ */
+export declare function geminiReplayState(model: string, blocks: readonly GeminiReplayBlock[]): GeminiReplayEnvelope;
+/**
+ * Read back the replay metadata for one assistant message.
+ *
+ * Anything unexpected (a foreign envelope, another model, a block count that no
+ * longer lines up with the content) yields undefined, which degrades to sending
+ * the call without its signature rather than throwing: the provider then decides,
+ * and a cross-provider history stays replayable.
+ * @param message - the assistant message from history.
+ * @param model - the model about to be called; signatures do not cross models.
+ * @returns index-aligned metadata, or undefined when unusable.
+ */
+export declare function readGeminiReplay(message: Message, model: string): readonly GeminiReplayBlock[] | undefined;
+/**
+ * Build the request body for one model call.
+ *
+ * History is projected part by part (tool results become `functionResponse`
+ * parts, replayed tool calls carry their thought signature), and consecutive
+ * same-role turns are merged, which is the one turn shape Gemini accepts.
+ *
+ * No `thinkingConfig` is ever sent: Gemini's own default (dynamic thinking) is
+ * what keeps 2.5 Pro working, since that model refuses a zero thinking budget.
+ * @param options - the harness request.
+ * @param config - project, location, and default output cap.
+ * @returns the wire body.
+ */
+export declare function buildGeminiRequest(options: GenerateOptions, config: VertexWireConfig): GeminiRequestBody;
+/** Raw usage counters as Vertex reports them. */
+interface GeminiUsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    cachedContentTokenCount?: number;
+    thoughtsTokenCount?: number;
+    totalTokenCount?: number;
+}
+/**
+ * Map Gemini's counters onto harness accounting.
+ *
+ * Gemini folds cached input into `promptTokenCount` and reports it separately as
+ * well, so the harness's disjoint rule means subtracting it out; thinking tokens
+ * are billed as output, exactly as the harness's own pi-ai mapping treats them.
+ * @param usage - the latest cumulative counters seen on the stream.
+ * @returns disjoint harness counts.
+ */
+export declare function mapGeminiUsage(usage: GeminiUsageMetadata): TokenUsage;
+/**
+ * Map Gemini's finish reason onto the harness vocabulary.
+ *
+ * `STOP`, `OTHER`, and an absent reason all mean the same thing here, and so
+ * does any reason a provider release adds: the turn ended, and only a tool call
+ * in it changes what that is called.
+ * @param reason - the `finishReason` Vertex reported.
+ * @param sawToolCall - whether the response contained a function call, which
+ *   Gemini reports as an ordinary `STOP`.
+ * @returns the harness finish reason.
+ */
+export declare function mapGeminiFinishReason(reason: string | undefined, sawToolCall: boolean): FinishReason;
+/**
+ * Translate Gemini's `streamGenerateContent` chunks into harness chunks.
+ *
+ * Gemini streams whole parts rather than deltas, so the shape of this translator
+ * is: text parts append to one open text block, a function call closes that block
+ * and is itself closed immediately (arguments arrive complete), and the terminal
+ * chunk carries usage plus the stop reason.
+ */
+export declare class GeminiStreamTranslator {
+    #private;
+    /**
+     * @param model - the model being called, recorded in the replay envelope.
+     */
+    constructor(model: string);
+    /**
+     * Feed one decoded SSE payload.
+     * @param event - the parsed chunk.
+     * @returns the chunks this payload completes, in order.
+     */
+    handle(event: Record<string, unknown>): StreamChunk[];
+    /** True once the provider reported a finish reason. */
+    get sawFinish(): boolean;
+    /** True once an in-band error ended the stream, which `handle` already reported. */
+    get failed(): boolean;
+    /** {@inheritDoc StreamTranslatorLike.terminal} */
+    get terminal(): boolean;
+    /**
+     * Terminal chunks: the closed tail, usage, and the finish reason.
+     *
+     * Called once, after the body ends. A response that produced nothing at all is
+     * reported as an empty response rather than as a silent success.
+     * @returns the trailing chunks in emission order.
+     */
+    finish(): StreamChunk[];
+}
+export {};

package/lib/types/gemini_adapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Provider adapter for Google's own Gemini models on Vertex AI.
+ *
+ * Same credential as the Claude route beside it (one service-account file, one
+ * bearer token per request) over the `publishers/google` endpoint instead of
+ * `publishers/anthropic`. Both live in one plugin row so project, region, and
+ * credentials are configured once.
+ *
+ * The route is text-only: `inputModalities: ['text']` makes `LlmRuntime` project
+ * images and files to placeholder text before dispatch. Tool calling is fully
+ * supported, including Vertex's required thought-signature replay.
+ *
+ * @module dsh-google-vertex/gemini-adapter
+ */
+import { VertexPublisherAdapter } from './adapter.ts';
+import type { TokenProvider, VertexModel } from './adapter.ts';
+import type { FetchLike, ServiceAccount } from './auth.ts';
+import type { VertexWireConfig } from './wire.ts';
+import type { GenerateOptions, StreamChunk } from './host.ts';
+/** Resolved adapter configuration for the Gemini route. */
+export interface GeminiAdapterConfig extends VertexWireConfig {
+    readonly serviceAccount: ServiceAccount;
+    readonly models: readonly VertexModel[];
+    /** Bound on the interval between two stream reads, in milliseconds. */
+    readonly streamIdleTimeoutMs: number;
+}
+/**
+ * Duck-typed adapter over Vertex's Gemini publisher endpoint.
+ *
+ * The metadata face and the streaming pipeline are the shared ones; this class
+ * supplies the Gemini catalog, wording, endpoint, body, and translator.
+ */
+export declare class GoogleVertexGeminiAdapter extends VertexPublisherAdapter<GeminiAdapterConfig> {
+    /**
+     * @param config - the resolved configuration this adapter serves.
+     * @param options - transport, token-source, and discovery overrides for tests.
+     */
+    constructor(config: GeminiAdapterConfig, options?: {
+        fetch?: FetchLike;
+        tokens?: TokenProvider;
+        discover?: () => Promise<readonly VertexModel[]>;
+    });
+    /**
+     * Stream one completion through `:streamGenerateContent?alt=sse`.
+     *
+     * Gemini has no terminal event: the body simply ends, and the finish reason
+     * rides the last content chunk. A body that ends without one is therefore a
+     * truncated response, which is what {@link GeminiStreamTranslator.sawFinish}
+     * distinguishes, unless an in-band error or the idle watchdog already ended
+     * the turn. The shared pump owns the watchdog, the token mint, and the SSE
+     * loop; this route's finish is built at the end of the body.
+     */
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}

package/lib/types/host.d.ts

@@ -0,0 +1,202 @@
+/**
+ * The slice of the DeepSeek Harness host surface this plugin uses, declared
+ * structurally.
+ *
+ * Like the other plugins under `~/dsh-plugins`, this package is installed
+ * outside the harness checkout and cannot resolve `@deepseek-ai/*` from its own
+ * directory, so it carries no runtime dependency on them. `LlmRuntime` reaches
+ * adapters through plain method calls (there is no `instanceof LlmAdapter`
+ * check anywhere in it), so a duck-typed adapter is a supported shape.
+ *
+ * Each declaration is narrowed to what this adapter reads or emits. Fields the
+ * adapter never touches are deliberately absent: a mirrored field that nothing
+ * reads is a field whose absence goes unnoticed. Widen a declaration when the
+ * adapter starts using it, not before.
+ *
+ * @module dsh-google-vertex/host
+ */
+/** Disposer returned by every host registration. */
+type Disposable = () => void;
+/** Content block the harness may hand us in request history. */
+export type ContentBlock = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'tool-call';
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+} | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+};
+/** One message in a fully-assembled request. */
+export interface Message {
+    readonly id: string;
+    /**
+     * The harness carries a tool result as its own `tool`-role message, with the
+     * call identity and error flag on the message rather than in its content.
+     */
+    readonly role: 'system' | 'developer' | 'user' | 'assistant' | 'tool';
+    readonly content: readonly ContentBlock[];
+    /** Tool-role only: the provider call id this message answers. */
+    readonly toolCallId?: string;
+    /** Tool-role only: whether the tool invocation failed. */
+    readonly isError?: boolean;
+    /**
+     * Producer attribution. Only `replayState` is read: an assistant message this
+     * adapter produced carries the provider's per-block metadata (Vertex's
+     * thought signatures), which the next request must echo back.
+     */
+    readonly source?: {
+        readonly kind?: string;
+        readonly replayState?: unknown;
+    };
+}
+/** JSON-schema description of one tool, as the harness sends it. */
+export interface ToolSchema {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+}
+/** A single model request, narrowed to the fields this adapter reads. */
+export interface GenerateOptions {
+    readonly provider?: string;
+    readonly model: string;
+    readonly messages: readonly Message[];
+    readonly system?: string;
+    readonly tools?: readonly ToolSchema[];
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly stop?: readonly string[];
+    readonly signal?: AbortSignal;
+}
+/** Token accounting for one model call. */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+}
+/** Stable provider-neutral failure shape. */
+export interface LlmFailure {
+    readonly message: string;
+    readonly code: string;
+    readonly status?: number;
+    /** Positive provider-requested retry delay in milliseconds. */
+    readonly providerRetryAfterMs?: number;
+}
+/** Why a model response stopped. */
+export type FinishReason = {
+    readonly kind: 'stop';
+} | {
+    readonly kind: 'tool-calls';
+} | {
+    readonly kind: 'max-tokens';
+} | {
+    readonly kind: 'aborted';
+    readonly failure: LlmFailure;
+} | {
+    readonly kind: 'error';
+    readonly failure: LlmFailure;
+};
+/** Adapter-private lossless-JSON state carried by a terminal finish chunk. */
+interface ReplayEnvelope {
+    /** Response-level metadata (ids, native stop reason). */
+    readonly response: unknown;
+    /** Per-block metadata, one entry per emitted block in stream order. */
+    readonly blocks?: readonly unknown[];
+}
+/** The chunk shapes this adapter emits. */
+export type StreamChunk = {
+    readonly type: 'block-start';
+    readonly index: number;
+    readonly blockType: string;
+} | {
+    readonly type: 'text-delta';
+    readonly index: number;
+    readonly text: string;
+} | {
+    readonly type: 'tool-call-delta';
+    readonly index: number;
+    readonly id: string;
+    readonly name?: string;
+    readonly argumentsDelta: string;
+} | {
+    readonly type: 'block-end';
+    readonly index: number;
+    readonly block: ContentBlock;
+} | {
+    readonly type: 'usage';
+    readonly usage: TokenUsage;
+} | {
+    readonly type: 'finish';
+    readonly reason: FinishReason;
+    readonly replayState?: ReplayEnvelope;
+};
+/** Display metadata for one adapter-owned provider route. */
+export interface LlmProviderInfo {
+    readonly id: string;
+    readonly name: string;
+}
+/** One adapter-advertised model. */
+export interface LlmModelInfo {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly inputModalities?: readonly string[];
+}
+/** Exact-route model metadata resolved by its owning adapter. */
+export interface LlmResolvedModelInfo extends LlmModelInfo {
+    readonly context?: {
+        readonly contextWindow: number;
+    };
+    readonly defaultMaxTokens?: number;
+}
+/** What `prepareCall` binds: exact model metadata plus one-generation dispatch. */
+export interface PreparedAdapterCall {
+    readonly model: LlmResolvedModelInfo;
+    readonly stream: (options: GenerateOptions) => AsyncIterable<StreamChunk>;
+}
+/**
+ * The adapter face `ctx.llm.registerAdapter()` consumes.
+ *
+ * The list is the full public surface of the harness `LlmAdapter` base class,
+ * including the members that only have defaults there. `LlmRuntime` calls
+ * `providerRetryPolicy` and `imageRequestPricing` on every dispatch, so a
+ * duck-typed adapter that omits them throws on the first registration rather
+ * than falling back to the base-class default.
+ */
+export interface LlmAdapterLike {
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(provider: string): unknown;
+    imageRequestPricing(provider: string, model: string): unknown;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+/** The `ctx.llm` seam, narrowed to the one call this plugin makes. */
+interface LlmServiceLike {
+    registerAdapter(providers: string[], adapter: LlmAdapterLike): Disposable;
+}
+/** The host context slice this plugin touches. */
+export interface HostContext {
+    readonly llm: LlmServiceLike;
+    readonly logger: {
+        info(message: unknown): void;
+        warn(message: unknown): void;
+    };
+    /**
+     * Subscribe to a host event. Optional: a bare test host may omit it, in which
+     * case no cached catalog is dropped.
+     */
+    on?(event: 'loader/volatile-update', listener: () => void): unknown;
+}
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * dsh-google-vertex: use Google-hosted models from Vertex AI inside DeepSeek
+ * Harness, authenticated with a service-account file.
+ *
+ * Two capabilities, one configuration row: an `ctx.llm` provider adapter for
+ * Vertex's Anthropic publisher endpoint (Claude) and one for its Google
+ * publisher endpoint (Gemini). Registering them makes both routes selectable in
+ * the Web client's model picker, because `buildModelCatalog()` enumerates
+ * `ctx.llm.listProviders()` and asks each adapter for `listModels()` /
+ * `resolveModel()`.
+ *
+ * A third: the `google-vertex` settings namespace. The Gemini adapter discovers
+ * its catalog at runtime behind a five-minute cache, and a browser half has no
+ * other way to reach this process, so the namespace's one write (the Refresh
+ * control on this plugin's row page under Plugins) is what drops that cache
+ * on demand.
+ *
+ * The credential is the service-account JSON itself: a path in configuration,
+ * or `GOOGLE_APPLICATION_CREDENTIALS` in the launch environment. Nothing is
+ * copied into the harness credential store, and the file is read once at mount
+ * so a typo fails loudly instead of on the first message.
+ *
+ * @module dsh-google-vertex
+ */
+import type { Volatile } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import type { VertexAnthropicConfig, VertexModel } from './adapter.ts';
+import type { GeminiAdapterConfig } from './gemini_adapter.ts';
+import type { HostContext } from './host.ts';
+/** Plugin name as it appears in the loader. */
+export declare const name = "google-vertex";
+/** The `ctx.llm` route serving Google-hosted Anthropic (Claude) models. */
+export declare const PROVIDER = "google-vertex-anthropic";
+/** The `ctx.llm` route serving Gemini models. */
+export declare const GEMINI_PROVIDER = "google-vertex-gemini";
+/**
+ * Settings namespace the browser half's card edits: the join key between the
+ * two halves. The card registers into `plugins.row.config` under this namespace,
+ * and the settings tab pairs the two without knowing what the namespace means.
+ */
+export declare const GOOGLE_VERTEX_SETTINGS_NAMESPACE = "google-vertex";
+/** The one service this plugin needs mounted. */
+export declare const inject: string[];
+/**
+ * Claude models Vertex serves, in picker order. Ids are the provider's own
+ * aliases, which track the newest dated release of each family and need no
+ * edit when Vertex promotes one; the catalog is overridable from configuration
+ * for a deployment that pins dated versions or uses a different listing.
+ */
+export declare const DEFAULT_MODELS: readonly VertexModel[];
+/** Context capacity reported for every Claude model; every listed family serves 200k. */
+export declare const DEFAULT_CONTEXT_WINDOW = 200000;
+/**
+ * Output cap used when a caller omits one. Well under the models' 64k ceiling:
+ * an agent turn rarely needs more, and the harness enforces its own budget.
+ */
+export declare const DEFAULT_MAX_TOKENS = 32000;
+/**
+ * Configuration received by the plugin: the row as the exported schema emits
+ * it, so the volatile stamp arrives as a live reference rather than a string.
+ *
+ * A profile patch supplies `Options`; `resolveConfig` normalizes one into the
+ * adapter configuration.
+ */
+export interface Config {
+    /** Service-account JSON path, `~` allowed; defaults to `GOOGLE_APPLICATION_CREDENTIALS`. */
+    readonly serviceAccountFile?: string;
+    /**
+     * Project id; defaults to `GOOGLE_CLOUD_PROJECT`, then `GCLOUD_PROJECT`, then
+     * the credentials file's own `project_id`.
+     */
+    readonly project?: string;
+    /** Region, or `global` (the default); defaults to `GOOGLE_CLOUD_LOCATION`. */
+    readonly location: string;
+    /** Claude model ids to advertise, replacing the built-in catalog. */
+    readonly models: string[];
+    /** Gemini model ids to advertise, replacing the built-in catalog. */
+    readonly geminiModels: string[];
+    /**
+     * Claude context window reported for every model; defaults to 200000. The
+     * Gemini route reports {@link DEFAULT_GEMINI_CONTEXT_WINDOW} for every model
+     * it serves, which is why this key has no Gemini counterpart.
+     */
+    readonly contextWindow: number;
+    /** Claude output cap applied when a caller omits one; defaults to 32000. */
+    readonly maxTokens: number;
+    /**
+     * Bound on the interval between two stream reads on either route; defaults to
+     * 300000. A provider that stops sending is reported as `TIMEOUT` instead of
+     * holding the turn open forever.
+     */
+    readonly streamIdleTimeoutMs: number;
+    /**
+     * Stamp written by the Refresh control; absent until the first manual refresh.
+     * Volatile in the schema, so the settings document (which accepts only
+     * volatile fields) commits the write into this running reference and its
+     * `loader/volatile-update` drops both cached catalogs. The host never reads
+     * the value; the write itself is the signal.
+     */
+    readonly revalidatedAt: Volatile<string | undefined>;
+}
+/** Raw row values accepted from a profile patch, with live references unwrapped. */
+export type Options = {
+    [K in keyof Config]?: Config[K] extends Volatile<infer T> ? T : Config[K];
+};
+/**
+ * Row schema: defaults live here, so a deployment only states what it changes.
+ *
+ * `serviceAccountFile`, `project`, `models`, and `geminiModels` carry no
+ * `.default()`: the first two fall back to the environment, and an omitted
+ * catalog materializes empty, which `resolveConfig` treats exactly like an
+ * absent one and replaces with the built-in list.
+ *
+ * `revalidatedAt` is volatile (the only kind of field the settings document
+ * accepts) and carries no default: absence means "never refreshed manually".
+ */
+export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    serviceAccountFile: Schema<string, string, "plain">;
+    project: Schema<string, string, "plain">;
+    location: Schema<string, string, "defined">;
+    models: Schema<string[], string[], "plain">;
+    geminiModels: Schema<string[], string[], "plain">;
+    contextWindow: Schema<number, number, "defined">;
+    maxTokens: Schema<number, number, "defined">;
+    streamIdleTimeoutMs: Schema<number, number, "defined">;
+    revalidatedAt: Schema<string, string, "volatile">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    serviceAccountFile: Schema<string, string, "plain">;
+    project: Schema<string, string, "plain">;
+    location: Schema<string, string, "defined">;
+    models: Schema<string[], string[], "plain">;
+    geminiModels: Schema<string[], string[], "plain">;
+    contextWindow: Schema<number, number, "defined">;
+    maxTokens: Schema<number, number, "defined">;
+    streamIdleTimeoutMs: Schema<number, number, "defined">;
+    revalidatedAt: Schema<string, string, "volatile">;
+}>>, "plain">;
+/** Validated configuration plus the file it was read from. */
+interface ResolvedConfig {
+    readonly anthropic: VertexAnthropicConfig;
+    readonly gemini: GeminiAdapterConfig;
+    /** Absolute path of the service-account file, for the mount log line. */
+    readonly serviceAccountFile: string;
+}
+/**
+ * Validate and normalize one configuration row.
+ *
+ * Invalid values throw rather than being silently defaulted: a typo'd path or
+ * project would otherwise present as an opaque provider error mid-turn.
+ * @param config - raw row values, as a profile patch or an unwrapped row.
+ * @param env - environment consulted for the credential and region defaults.
+ * @returns the resolved adapter configuration.
+ */
+export declare function resolveConfig(config?: Options, env?: NodeJS.ProcessEnv): ResolvedConfig;
+/**
+ * Mount both adapters.
+ * @param ctx - host context; `ctx.llm` must be mounted (`inject` guarantees it).
+ * @param config - this plugin's row, as the schema emits it.
+ */
+export declare function apply(ctx: HostContext, config: Config): void;
+export {};

package/lib/types/wire-shared.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Helpers the two publisher wire translators (Anthropic and Gemini) share:
+ * tool-argument parsing, system-text collection, and usage-counter merging.
+ *
+ * @module dsh-google-vertex/wire-shared
+ */
+import type { GenerateOptions } from './host.ts';
+/** Parse a model-produced arguments string into the object the provider requires. */
+export declare function toolInput(argumentsJson: string): Record<string, unknown>;
+/** System-role text the request carries, in assembly order. */
+export declare function systemParts(options: GenerateOptions): string[];
+/**
+ * Read the named counters out of one usage payload, keeping only the ones the
+ * provider actually sent.
+ * @param raw - the payload's usage member.
+ * @param names - the counter names this route reads.
+ * @returns only the present, well-formed counters.
+ */
+export declare function takeCounters(raw: unknown, names: readonly string[]): Record<string, number>;