indusagi 0.12.32 → 0.12.34

package/dist/types/interop/protocol-bridge/endpoint.d.ts

@@ -0,0 +1,124 @@
+/**
+ * A single live connection to one external Model Context Protocol server.
+ *
+ * {@link ServerEndpoint} (the interface) is declared in `./contract`; this module
+ * is its one concrete implementation over the official MCP SDK {@link Client}.
+ * An endpoint owns exactly one transport, advances through the
+ * {@link EndpointPhase} machine, and translates every SDK / transport failure
+ * into a discriminated {@link ProtocolFault} so callers branch on a cause class
+ * rather than parse message text.
+ *
+ * Responsibilities, kept deliberately narrow:
+ *
+ *   - Build the right transport from a {@link ServerConfig} — a
+ *     {@link StdioClientTransport} for `stdio`, an {@link SSEClientTransport}
+ *     for `sse`.
+ *   - Drive the lifecycle: `idle → connecting → ready`, with any failure short-
+ *     circuiting to `faulted`; `ready → closing → closed` on a clean shutdown.
+ *   - Cache the tool listing after the first successful `listTools()`.
+ *   - Surface the raw {@link RemoteCallResult} of an invocation; mapping content
+ *     blocks onto the kernel's tool contract is a sibling module's concern.
+ */
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { EndpointPhase, EndpointStatus, RemoteCallResult, RemoteTool, ServerConfig, ServerEndpoint } from "./contract";
+/**
+ * One connection to one MCP server, over the official SDK {@link Client}.
+ *
+ * Construct with a {@link ServerConfig}; the transport is chosen from
+ * {@link ServerConfig.kind} but not opened until {@link connect}. The endpoint
+ * is single-shot: once it reaches a terminal phase (`closed` or `faulted`) it is
+ * not reusable.
+ */
+export declare class ServerEndpointImpl implements ServerEndpoint {
+    /** The configuration that defines this endpoint. */
+    readonly config: ServerConfig;
+    /** Backing field for the public {@link phase} accessor. */
+    private _phase;
+    /** The SDK client, created lazily on the first {@link connect}. */
+    private client?;
+    /** In-flight connection, shared by concurrent {@link connect} callers. */
+    private opening?;
+    /** Memoized tool listing, populated by the first successful {@link listTools}. */
+    private toolCache?;
+    /** The fault that retired this endpoint, set when {@link _phase} is `faulted`. */
+    private fault?;
+    /**
+     * A pre-built transport injected at construction, used in place of one derived
+     * from {@link config}. This is the seam in-process callers (and tests) use to
+     * connect an endpoint to a transport they already hold — an
+     * {@link InMemoryTransport} client half, say — instead of spawning a process or
+     * opening a socket. When present, {@link buildTransport} is bypassed entirely.
+     */
+    private readonly injectedTransport?;
+    constructor(config: ServerConfig, transport?: Transport);
+    /** A stable handle for logs and status keys: the server's configured id. */
+    get id(): string;
+    /** The endpoint's current lifecycle phase. */
+    get phase(): EndpointPhase;
+    /**
+     * Open the transport and initialize the MCP session.
+     *
+     * Idempotent: a second call while a connection is in flight awaits the same
+     * attempt, and a call on an already-`ready` endpoint resolves immediately. A
+     * call on a terminal (`closed` / `faulted`) endpoint rejects, since the
+     * transport cannot be revived.
+     */
+    connect(): Promise<void>;
+    /**
+     * The {@link ServerEndpoint} interface's name for {@link connect}; delegates
+     * verbatim so the contract's vocabulary and the prompt's `connect()` both
+     * resolve to one implementation.
+     */
+    open(): Promise<void>;
+    /** The single-flight body behind {@link connect}. */
+    private doConnect;
+    /** Construct the transport implied by {@link ServerConfig.kind}. */
+    private buildTransport;
+    /**
+     * List the tools this server advertises, mapped to {@link RemoteTool}s and
+     * cached. The first call performs the round-trip; later calls return the
+     * memoized listing. Requires a `ready` endpoint.
+     */
+    listTools(): Promise<readonly RemoteTool[]>;
+    /** A point-in-time projection of this endpoint's tool cache. */
+    tools(): readonly RemoteTool[];
+    /**
+     * Invoke a remote tool by its *unqualified* server-side name. Returns the raw
+     * {@link RemoteCallResult}; a result the server flagged `isError` is reported
+     * faithfully (`isError: true`) rather than thrown — that is the model's signal,
+     * not a transport fault. A genuine transport/protocol failure throws a
+     * {@link ProtocolFault}. Requires a `ready` endpoint.
+     */
+    invoke(name: string, args: unknown): Promise<RemoteCallResult>;
+    /** A point-in-time projection of this endpoint's health. */
+    status(): EndpointStatus;
+    /**
+     * Gracefully close the transport. Idempotent and safe in any phase: a never-
+     * connected, already-closed, or faulted endpoint closes to a no-op without
+     * overwriting a `faulted` terminal state. A close error is swallowed — there
+     * is nothing left to do with the connection — but still moves the phase to
+     * `closed`.
+     */
+    close(): Promise<void>;
+    /** Return the live client or throw a `not_connected` fault. */
+    private requireClient;
+    /**
+     * Record a fault, transition to `faulted`, and return the {@link ProtocolFault}
+     * for the caller to throw. Centralizing this keeps the phase and the stored
+     * fault consistent at every failure site.
+     */
+    private faultFrom;
+    /** Coerce an SDK tool input schema into the gateway's {@link JsonSchema}. */
+    private normalizeSchema;
+    /** The SDK expects a record of arguments; map anything else to an empty one. */
+    private normalizeArgs;
+}
+/**
+ * Construct a {@link ServerEndpoint} for one server.
+ *
+ * Pass a pre-built `transport` to connect over a transport the caller already
+ * holds — an in-process {@link InMemoryTransport} client half, for instance —
+ * rather than one derived from `config`. Omit it for the normal path, where the
+ * endpoint builds the transport implied by `config.kind` on connect.
+ */
+export declare function createServerEndpoint(config: ServerConfig, transport?: Transport): ServerEndpointImpl;

package/dist/types/interop/protocol-bridge/fleet.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The server fleet — a name-keyed collection of {@link ServerEndpoint}s driven
+ * through one lifecycle.
+ *
+ * {@link ServerFleet} (the interface) is declared in `./contract`; this module is
+ * its one concrete implementation. The fleet's defining responsibility is
+ * *failure isolation*: when many external MCP servers are connected at once, one
+ * server that refuses to spawn, hangs, or speaks a broken handshake must not sink
+ * the others. Every connection is therefore attempted in parallel and settled
+ * independently — a faulted endpoint is simply left in its `faulted` phase, its
+ * fault recorded in the aggregate {@link FleetStatus}, while its healthy peers go
+ * on serving.
+ *
+ * The fleet owns no transport of its own; it constructs one
+ * {@link ServerEndpointImpl} per {@link ServerConfig} and delegates. It exposes
+ * immutable snapshots — `endpoints()` and `status()` return fresh, frozen
+ * projections — so a caller can never mutate the fleet's internal bookkeeping
+ * through a returned handle.
+ */
+import type { BridgeConfig, FleetStatus, ServerEndpoint, ServerFleet } from "./contract";
+/**
+ * A {@link ServerFleet} over the SDK-backed {@link ServerEndpointImpl}.
+ *
+ * Construct empty, then {@link start} it with a {@link BridgeConfig} to mint and
+ * connect one endpoint per configured server. The fleet keys endpoints by
+ * {@link ServerConfig.id} in configuration order and preserves that order in
+ * every projection it returns.
+ */
+export declare class ServerFleetImpl implements ServerFleet {
+    /**
+     * Endpoints keyed by server id, in insertion (configuration) order. A `Map`
+     * gives O(1) lookup by id while preserving the declaration order that every
+     * snapshot reproduces.
+     */
+    private readonly byId;
+    /** The configuration the fleet was last {@link start}ed with, if any. */
+    private config?;
+    /**
+     * Connect every server in `config` in parallel, isolating per-server failures.
+     *
+     * One endpoint is minted per {@link ServerConfig} and registered immediately
+     * (so even an endpoint that fails to connect appears in `endpoints()` and
+     * `status()` carrying its fault). Connections are then awaited together via
+     * `Promise.allSettled`: a rejection from any single `open()` is absorbed — the
+     * endpoint records its own {@link import("./contract").ProtocolFault} and moves
+     * to `faulted` — and never propagates out of `start`, so a single bad server
+     * cannot prevent the rest of the fleet from coming up.
+     *
+     * A later id in `config` silently supersedes an earlier duplicate, matching the
+     * registry's last-registration-wins convention.
+     */
+    start(config: BridgeConfig): Promise<void>;
+    /**
+     * {@link ServerFleet} vocabulary for {@link start}. The fleet was constructed
+     * empty, so `spinUp` reconnects against the configuration the fleet already
+     * holds; it throws if the fleet has never been {@link start}ed.
+     */
+    spinUp(): Promise<void>;
+    /**
+     * Gracefully close every endpoint, in parallel. Each `close()` is idempotent
+     * and any-phase safe, and `allSettled` ensures one endpoint's close error does
+     * not prevent its peers from closing.
+     */
+    close(): Promise<void>;
+    /** {@link ServerFleet} vocabulary for {@link close}. */
+    tearDown(): Promise<void>;
+    /** Look up a single endpoint by its server id, or `undefined` if absent. */
+    endpoint(server: string): ServerEndpoint | undefined;
+    /**
+     * Every endpoint currently held, in configuration order, as a fresh frozen
+     * array. The snapshot is immutable: callers cannot reorder or grow the fleet's
+     * internal collection through the returned handle.
+     */
+    endpoints(): readonly ServerEndpoint[];
+    /**
+     * The aggregate health of every endpoint: one {@link EndpointStatus} per
+     * server, keyed by id, as a fresh frozen record. Each status is the endpoint's
+     * own point-in-time projection, so the snapshot reflects phases and faults at
+     * the moment of the call.
+     */
+    status(): FleetStatus;
+    /** Mint one endpoint for a server config. Isolated for overriding in tests. */
+    private mint;
+}
+/**
+ * Construct and start a {@link ServerFleet} for a {@link BridgeConfig}.
+ *
+ * The returned fleet has already attempted every connection (in parallel, with
+ * per-server failure isolation); inspect {@link ServerFleet.status} to learn
+ * which servers came up `ready` and which `faulted`.
+ */
+export declare function startServerFleet(config: BridgeConfig): Promise<ServerFleetImpl>;

package/dist/types/interop/protocol-bridge/host.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The provider host — this agent acting as an MCP *server*.
+ *
+ * The rest of the bridge runs the agent as a client of external servers
+ * ({@link ServerEndpoint}, {@link ServerFleet}). This module is the mirror image:
+ * a {@link ProviderHost} stands up an MCP server over the official SDK and
+ * publishes *our* built-in tools — a {@link ToolBox} assembled by the
+ * capabilities layer — so an external MCP client can enumerate and invoke them.
+ *
+ * The host is a thin,
+ * stateless adapter in two directions:
+ *
+ *   - **Catalog.** A `tools/list` request answers with the box's
+ *     {@link ToolBox.descriptors}, each mapped to the MCP tool shape
+ *     (`{ name, description, inputSchema }`).
+ *   - **Dispatch.** A `tools/call` request is routed straight into
+ *     `box.runner.run`, and the resulting {@link ToolOutcome} is projected onto
+ *     the MCP call result (`{ content: [{ type: 'text', text }], isError }`).
+ *
+ * Tool arguments and outputs are the only translation surface: MCP carries
+ * `arguments` as a record and expects `content` blocks back, while our runtime
+ * speaks `input: unknown` and `output: unknown`.
+ */
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { ToolBox } from "../../runtime/contract";
+/** Identifying metadata the host advertises to connecting MCP clients. */
+export interface ProviderHostInfo {
+    /** The server name surfaced during MCP initialization. */
+    readonly name: string;
+    /** The server version surfaced during MCP initialization. */
+    readonly version: string;
+}
+/**
+ * An MCP server exposing this agent's built-in tools to external clients.
+ *
+ * The host is inert until {@link ProviderHost.connect} binds it to a transport;
+ * once bound, the underlying SDK server answers `tools/list` and `tools/call`
+ * for the lifetime of the connection.
+ */
+export interface ProviderHost {
+    /**
+     * Bind the host to a transport and begin serving. The transport governs how a
+     * client reaches the host (stdio pipe, SSE stream, in-memory pair); the host
+     * is transport-agnostic. Resolves once the MCP session is established.
+     */
+    connect(transport: Transport): Promise<void>;
+}
+/**
+ * Stand up a {@link ProviderHost} over the box's tools.
+ *
+ * The returned host is not yet listening — wire it to a transport with
+ * {@link ProviderHost.connect}. The two MCP request handlers are registered
+ * eagerly against a fresh SDK {@link Server}; both close over `box`, so each
+ * `tools/list` reflects the box's descriptors at call time and each
+ * `tools/call` dispatches through the box's live runner.
+ *
+ * @param box  the assembled tool box whose tools are published
+ * @param info optional identity advertised to clients; defaults to a generic
+ *             provider identity when omitted
+ */
+export declare function createProviderHost(box: ToolBox, info?: ProviderHostInfo): ProviderHost;

package/dist/types/interop/protocol-bridge/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The protocol bridge — public surface.
+ *
+ * One import site for the bridge's vocabulary. The behavioural modules
+ * (`endpoint`, `fleet`, `provider-host`, `mount`) import their nouns from
+ * `./contract`; downstream consumers import them from this barrel.
+ */
+export { ProtocolFault, protocolFault, isProtocolFault, isUsablePhase, isTerminalPhase, QUALIFIER, qualifyToolName, } from "./contract";
+export type { FaultKind, EndpointPhase, StdioServerConfig, SseServerConfig, ServerConfig, TransportKind, BridgeConfig, RemoteToolRef, RemoteTool, RemoteCallResult, EndpointStatus, FleetStatus, MountedBridge, ServerEndpoint, ServerFleet, } from "./contract";
+export { createProviderHost } from "./host";
+export type { ProviderHost, ProviderHostInfo } from "./host";
+export { ServerEndpointImpl, createServerEndpoint } from "./endpoint";
+export { ServerFleetImpl, startServerFleet } from "./fleet";
+export { mountProtocolBridge } from "./bridge";
+export type { MountedProtocolBridge } from "./bridge";
+export { normalizeSchema } from "./schema";

package/dist/types/interop/protocol-bridge/schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSON-Schema normalizer for the protocol bridge.
+ *
+ * A remote MCP server advertises each tool with an `inputSchema` it authored to
+ * its own taste: it may omit `type`, nest schemas built against a different JSON
+ * Schema draft, or sprinkle in vendor keywords no provider understands. Before
+ * that schema can become a {@link ToolDescriptor.parameters} the model is shown,
+ * it must be reshaped into a small, defensive, draft-agnostic subset every
+ * provider accepts.
+ *
+ * {@link normalizeSchema} performs that reshaping. It is built from pure,
+ * table-driven functions rather than a single sprawling `switch`: a dispatch
+ * table keyed by the schema's declared `type` selects a per-type normalizer,
+ * and a {@link relax} combinator strips the keywords no provider validates
+ * against. Every function here is total and side-effect free — given the same
+ * input it returns the same fresh object and never mutates its argument.
+ */
+import type { JsonSchema } from "../../llmgateway/contract";
+/**
+ * Normalize an untrusted remote `inputSchema` into a clean, defensive
+ * {@link JsonSchema} suitable for {@link ToolDescriptor.parameters}.
+ *
+ * The declared `type` selects a per-type normalizer from {@link NORMALIZERS};
+ * an absent, non-string, or unrecognized `type` (including the array-of-types
+ * form) routes to {@link normalizeUntyped}, which yields a closed object schema.
+ * Unsupported keywords are stripped at every level by {@link relax}, and child
+ * schemas are normalized recursively. The argument is never mutated.
+ */
+export declare function normalizeSchema(input: unknown): JsonSchema;

package/dist/types/llmgateway/catalog/cards.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Static model catalog: a flat registry of {@link ModelCard} entries.
+ *
+ * This is deliberately a single linear array rather than a nested map keyed by
+ * provider — the query layer (see `./query`) builds predicates over the flat
+ * list, which keeps filtering composable and avoids the rigidity of a
+ * map-of-maps.
+ *
+ * PRICING DISCLAIMER: every number in the `cost` sheets below is an
+ * APPROXIMATE, BEST-EFFORT figure expressed in USD per million tokens (per
+ * MTok). These are hand-entered ballpark values for local estimation only and
+ * are NOT transcribed from any vendor price list. Treat them as rough — verify
+ * against the provider's live pricing before billing anyone real money.
+ *
+ * Context-window and max-output figures are likewise approximate and rounded.
+ */
+import type { ModelCard } from "../contract";
+export declare const MODEL_CARDS: readonly ModelCard[];

package/dist/types/llmgateway/catalog/cost.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn token counts into dollars using a card's per-MTok {@link CostSheet}.
+ */
+import type { ModelCard, Usage } from "../contract";
+/**
+ * Estimate the USD cost of a single response given the card's pricing sheet and
+ * the reported token usage.
+ *
+ * Cache tiers are billed only when both the usage reports them and the card
+ * prices them; cached reads/writes are treated as additive to (not a
+ * replacement for) the base input/output charges, matching how the per-tier
+ * `*PerMTok` fields are expressed. Returns a best-effort estimate — accuracy is
+ * bounded by the approximate prices baked into the catalog.
+ */
+export declare function estimateCost(card: ModelCard, usage: Usage): number;

package/dist/types/llmgateway/catalog/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Catalog barrel: the static model registry, fluent query layer, and cost
+ * estimator for the LLM gateway.
+ */
+export { MODEL_CARDS } from "./cards";
+export { CardSelection, models, getCard } from "./query";
+export { estimateCost } from "./cost";

package/dist/types/llmgateway/catalog/query.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Fluent, predicate-driven querying over the flat {@link MODEL_CARDS} list.
+ *
+ * Rather than indexing the catalog into a nested map keyed by provider/api, we
+ * accumulate an array of predicates and apply them lazily. Each chained method
+ * narrows the candidate set; terminal methods (`all`, `find`) materialize it.
+ * This keeps the catalog a single source of truth and makes filters composable
+ * in any order.
+ */
+import type { ApiKind, ModelCard, ProviderId } from "../contract";
+/**
+ * Lazy, chainable query over a fixed pool of model cards. Filter methods return
+ * a *new* selection (immutably accumulating predicates); terminal methods read
+ * the result out.
+ */
+export declare class CardSelection {
+    private readonly pool;
+    private readonly tests;
+    private constructor();
+    /** Begin a query over the given pool (defaults to the full catalog). */
+    static over(pool: readonly ModelCard[]): CardSelection;
+    private withTest;
+    /** Keep only cards from a specific vendor. */
+    byProvider(provider: ProviderId): CardSelection;
+    /** Keep only cards served over a specific wire dialect. */
+    byApi(api: ApiKind): CardSelection;
+    /** Keep cards whose reasoning capability matches `enabled`. */
+    reasoning(enabled: boolean): CardSelection;
+    /** Materialize every card that satisfies all accumulated predicates. */
+    all(): ModelCard[];
+    /**
+     * Terminal lookup by exact `id`, also respecting any accumulated predicates.
+     * Returns `undefined` when no surviving card matches.
+     */
+    find(id: string): ModelCard | undefined;
+}
+/** Entry point: open a fluent query over the full model catalog. */
+export declare function models(): CardSelection;
+/** Direct id lookup against the full catalog, bypassing the fluent builder. */
+export declare function getCard(id: string): ModelCard | undefined;

package/dist/types/llmgateway/connectors/anthropic.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Anthropic Messages connector.
+ *
+ * Speaks the native `/v1/messages` dialect — Anthropic's streaming format is
+ * its own beast (typed `content_block_*` and `message_*` SSE events rather than
+ * OpenAI-style choice deltas), so this connector owns a bespoke decode loop
+ * instead of delegating to the shared OpenAI-compatible streamer.
+ *
+ * Wire shape (re-derived from Anthropic's public streaming docs):
+ *
+ *   event: message_start          data: {"message":{"usage":{...}}}
+ *   event: content_block_start    data: {"index":0,"content_block":{"type":"text"|"thinking"|"tool_use",...}}
+ *   event: content_block_delta    data: {"index":0,"delta":{"type":"text_delta","text":"..."}}
+ *   event: content_block_stop     data: {"index":0}
+ *   event: message_delta          data: {"delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":N}}
+ *   event: message_stop           data: {}
+ *
+ * Body assembly is delegated to `toAnthropicRequest`; the connector only adds
+ * `stream: true` and the auth/version headers.
+ */
+import type { Connector, CredentialResolver } from "../contract";
+/** Dependencies the factory needs to mint a working connector. */
+export interface AnthropicConnectorDeps {
+    /** Resolves the Anthropic API key (env / override) at call time. */
+    readonly resolveSecret: CredentialResolver["resolve"];
+}
+/**
+ * Build the Anthropic Messages connector.
+ *
+ * Serves every `anthropic-messages` card in the catalog — `claude-opus-4`,
+ * `claude-sonnet-4`, and `claude-haiku-3-5`. The API key is resolved lazily on
+ * each call via the injected `resolveSecret`, honoring a per-call
+ * `options.apiKey` override before falling back to the environment.
+ */
+export declare function createanthropicConnector(deps: AnthropicConnectorDeps): Connector;

package/dist/types/llmgateway/connectors/azure-openai.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Azure OpenAI connector.
+ *
+ * Azure exposes the OpenAI Chat Completions dialect, but behind a different URL
+ * layout and a different auth header than vanilla OpenAI: requests go to a
+ * per-deployment path on the resource endpoint, the model is selected by the
+ * deployment name baked into that path (not a `model` body field), and the key
+ * travels in an `api-key` header rather than a bearer token. An `api-version`
+ * query parameter pins the contract.
+ *
+ * Because the body/SSE shape is identical to OpenAI's, this is a thin adapter:
+ * it resolves the resource key, composes the deployment URL, and hands the wire
+ * work to the shared {@link streamOpenAICompatibleChat} streamer. All request
+ * assembly, SSE decoding, and chunk→emission translation live there.
+ *
+ * Serves: any catalog card whose `api` is `azure-openai` (provider `azure`).
+ * The deployment segment is taken from `model.id`, so each card's id must match
+ * the Azure deployment it targets.
+ */
+import type { Connector, CredentialResolver } from "../contract";
+/** Dependencies this connector pulls from the gateway runtime. */
+export interface AzureOpenAIDeps {
+    /** Resolves the Azure resource key, honoring a per-call override. */
+    readonly resolveSecret: CredentialResolver["resolve"];
+}
+/**
+ * Build an Azure OpenAI {@link Connector}.
+ *
+ * The lone dependency is the credential resolver (typically
+ * `environmentCredentialResolver.resolve`), injected so the connector stays
+ * free of ambient environment access and is trivial to fake in tests.
+ */
+export declare function createazureopenaiConnector(deps: AzureOpenAIDeps): Connector;

package/dist/types/llmgateway/connectors/bedrock.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Amazon Bedrock connector (`amazon-bedrock` dialect).
+ *
+ * Speaks the Bedrock Runtime **Converse** API. The streaming variant posts to
+ *
+ *   POST https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/converse-stream
+ *
+ * and receives an AWS binary `application/vnd.amazon.eventstream` body whose
+ * frames carry JSON payloads such as `contentBlockDelta`, `messageStop`, and
+ * `metadata`. This module owns the *neutral* half of that bridge: it builds the
+ * Converse request body from a {@link Conversation}, maps each decoded
+ * converse-stream event into a gateway {@link Emission}, and translates Bedrock
+ * stop reasons into the {@link StopReason} union.
+ *
+ * Out of scope for this phase (and deliberately so): AWS SigV4 request signing
+ * and the binary event-stream *framing* codec. Bedrock will reject any
+ * unsigned request, so rather than ship a broken transport we fail fast — when
+ * the AWS credential/region cannot be resolved, or signing is not yet wired up,
+ * the call raises `gatewayError("unsupported", ...)`. Everything around that
+ * gap (body shaping, model addressing, event mapping, types) is complete and
+ * type-checked, so dropping in a SigV4 signer later is a localized change.
+ *
+ * No `aws-sdk` and no provider SDKs: only the request shape and the
+ * converse-stream event shape, re-derived from the public Bedrock Runtime docs.
+ */
+import type { Connector, Conversation, CredentialResolver, Emission, ModelCard, StopReason, StreamOptions } from "../contract";
+/** Dependencies injected into the connector factory. */
+export interface BedrockConnectorDeps {
+    /** Resolves the AWS credential signal for `provider` (bearer token / chain). */
+    readonly resolveSecret: CredentialResolver["resolve"];
+}
+/** A single JSON-able wire object in the Converse schema. */
+type WireObject = Record<string, unknown>;
+/**
+ * Build the full Converse request body for `conversation`. The `modelId` lives
+ * in the URL path, so it is intentionally absent from the body. This is pure,
+ * JSON-able data ready to hand to a signer + `JSON.stringify`.
+ */
+export declare function buildConverseBody(model: ModelCard, conversation: Conversation, options: StreamOptions): WireObject;
+/**
+ * One decoded converse-stream event. After the binary event-stream framing is
+ * peeled away, each frame's payload is a JSON object discriminated by which key
+ * is present. We model the union loosely (open records) because the framing
+ * codec, not this mapper, owns precise typing of the byte layer.
+ */
+export interface ConverseStreamEvent {
+    readonly messageStart?: {
+        readonly role?: string;
+    };
+    readonly contentBlockStart?: {
+        readonly contentBlockIndex?: number;
+        readonly start?: {
+            readonly toolUse?: {
+                readonly toolUseId?: string;
+                readonly name?: string;
+            };
+        };
+    };
+    readonly contentBlockDelta?: {
+        readonly contentBlockIndex?: number;
+        readonly delta?: {
+            readonly text?: string;
+            readonly reasoningContent?: {
+                readonly text?: string;
+            };
+            readonly toolUse?: {
+                readonly input?: string;
+            };
+        };
+    };
+    readonly contentBlockStop?: {
+        readonly contentBlockIndex?: number;
+    };
+    readonly messageStop?: {
+        readonly stopReason?: string;
+    };
+    readonly metadata?: {
+        readonly usage?: {
+            readonly inputTokens?: number;
+            readonly outputTokens?: number;
+            readonly cacheReadInputTokens?: number;
+            readonly cacheWriteInputTokens?: number;
+        };
+    };
+}
+/**
+ * Map a Bedrock Converse `stopReason` onto the neutral {@link StopReason}.
+ * Unknown reasons collapse to `complete` — a benign default for an end-of-turn
+ * signal we do not specifically recognize.
+ */
+export declare function mapBedrockStopReason(reason: string | undefined): StopReason;
+/**
+ * Translate one decoded converse-stream event into zero or more neutral
+ * {@link Emission}s. Tool-call identity flows through `contentBlockIndex`: the
+ * `start` frame carries the id + name, later `delta` frames carry only the JSON
+ * argument fragment for that same index, so we key a synthetic call id off the
+ * index when the event omits one.
+ *
+ * `done`/`error` are *not* produced here — those terminal envelopes are the
+ * streamer's responsibility once the byte stream closes.
+ */
+export declare function mapConverseStreamEvent(event: ConverseStreamEvent, indexToCallId: Map<number, string>): Emission[];
+/**
+ * Build the Amazon Bedrock connector.
+ *
+ * The connector is fully assembled — request body, model addressing, and the
+ * converse-stream event mapper are production-ready and exercised by the type
+ * checker. The *transport* (SigV4 signing + binary framing) is the one piece
+ * left for a follow-up, so every invocation currently terminates in an
+ * `unsupported` gateway error at call time.
+ */
+export declare function createbedrockConnector(deps: BedrockConnectorDeps): Connector;
+export {};

package/dist/types/llmgateway/connectors/google-vertex.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Google Vertex AI connector.
+ *
+ * Vertex exposes the same *generative* request/response grammar as the Gemini
+ * Developer API, but reached through a project- and region-scoped endpoint and
+ * authenticated with a Google OAuth bearer access token rather than an API key:
+ *
+ *   POST {baseUrl}/v1/projects/{project}/locations/{location}
+ *        /publishers/google/models/{model}:streamGenerateContent?alt=sse
+ *   Authorization: Bearer <googleAccessToken>
+ *
+ * The streamed body is a sequence of server-sent events whose `data` payloads
+ * are JSON `GenerateContentResponse` chunks. Each chunk carries a `candidates`
+ * array; the first candidate's `content.parts` hold text, thinking (parts with
+ * `thought: true`), and `functionCall` fragments, while `finishReason` and the
+ * top-level `usageMetadata` describe how the turn concluded.
+ *
+ * Because the wire grammar is Google's — not OpenAI's — this connector decodes
+ * the SSE stream itself (via the shared {@link sseEvents} framer) instead of
+ * delegating to {@link streamOpenAICompatibleChat}. Request bodies are built
+ * with the neutral Google mappers, and chunks are translated into neutral
+ * {@link Emission}s that {@link foldReply} collapses into a {@link Reply}.
+ */
+import type { Connector, CredentialResolver } from "../contract";
+/** Dependencies a Vertex connector needs from the gateway host. */
+export interface GoogleVertexDeps {
+    /** Resolves the Google OAuth access token (honors a per-request override). */
+    readonly resolveSecret: CredentialResolver["resolve"];
+}
+/**
+ * Build a {@link Connector} for Google Vertex AI.
+ *
+ * The connector resolves a Google OAuth access token via the injected
+ * `resolveSecret`, honoring a per-request `apiKey` override. With no token in
+ * reach, both {@link Connector.stream} and {@link Connector.complete} fail with
+ * an `auth` {@link GatewayError}.
+ */
+export declare function creategooglevertexConnector(deps: GoogleVertexDeps): Connector;