dsh-llm-omp-transports 0.2.4 → 0.2.6

package/README.md

@@ -11,16 +11,17 @@ and the plugin page lists both bundle components
 |---|---|
 | npm package | `dsh-llm-omp-transports` |
 | Plugin id | `llm-omp-transports` |
-| Route | `cursor` (first provider; the seam is provider-generic) |
-| Credential scope | `llm-omp-transports/<provider>`, today `llm-omp-transports/cursor` |
+| Routes | `cursor`, `devin`, `google-gemini-cli`, `google-antigravity` (the seam is provider-generic) |
+| Credential scope | `llm-omp-transports/<provider>`: `llm-omp-transports/cursor`, `llm-omp-transports/devin`, `llm-omp-transports/google-gemini-cli`, `llm-omp-transports/google-antigravity` |
 | Runtime | Node 24 (the bundle imports Node builtins only) |
 | License | MIT |
 
 The plugin registers its own route on the DSH `llm` seam, so it depends on no
 upstream DSH change. `@oh-my-pi/pi-ai` and `@oh-my-pi/pi-catalog` are used at
-**build time only**: the build inlines the pinned omp Cursor transport into one
-ESM artifact (`lib/omp/cursor.mjs`), and the published package imports nothing
-from `@oh-my-pi/*` or `bun:*` at runtime.
+**build time only**: the build inlines the pinned omp transports into one ESM
+artifact per route (`lib/omp/cursor.mjs`, `lib/omp/devin.mjs`), plus one shared
+artifact for the two Google routes (`lib/omp/google.mjs`), and the published
+package imports nothing from `@oh-my-pi/*` or `bun:*` at runtime.
 
 ## Cursor support status
 
@@ -47,6 +48,82 @@ from `@oh-my-pi/*` or `bun:*` at runtime.
 - **Images** — not yet. The route advertises text-only input and refuses image
   blocks with `CONTENT_UNSUPPORTED`; see [known limits](docs/known-limits.md).
 
+## Devin support status
+
+- **Text streaming** — yes. Assistant text and reasoning are projected onto
+  DSH's `StreamChunk` stream, with the per-turn usage the chat frames report.
+- **Reasoning streaming** — yes as content; no reasoning-effort selector. Both
+  pinned rows advertise no efforts, and a request that selects one is refused
+  with `UNSUPPORTED_REASONING_EFFORT`.
+- **Tool-call handoff** — yes, native to DSH's tool loop. The transport emits
+  the call, finishes the turn `toolUse`, and DSH executes it; the result is
+  replayed from history on the next request. Unlike Cursor, no call is
+  transport-resolved, so nothing is filtered from the handoff.
+- **Sign-in** — yes, by pasting the callback. The pinned omp login is a
+  declarative `oauth-code` rule whose loopback listener is Bun-only; this
+  package registers the `llm-omp-transports/devin` flow, opens the authorize
+  page, and asks for the address the browser landed on (or just the code).
+  There is **no refresh** (`refresh "none"`): an expired grant demands a new
+  sign-in.
+- **Models** — from the pinned catalog: the Devin slice of
+  `@oh-my-pi/pi-catalog@18.12.3` (2 rows: `swe-1-6`, `swe-1-6-fast`) is
+  generated into `src/catalog/devin.ts` and served without a network call.
+- **Route** — `devin`, declared configurable so the Models page has a
+  `providers.devin` profile with an allow-list.
+- **Images** — not yet, same as Cursor: text-only input, image blocks refused
+  with `CONTENT_UNSUPPORTED`.
+
+## Google support status
+
+Two routes share one artifact: `google-gemini-cli` (Google's Gemini CLI client)
+and `google-antigravity` (the Antigravity hub client). The bundled
+`streamGoogleGeminiCli` dispatches on `model.provider`, so the route is a data
+difference — separate OAuth client, catalogs, hosts, scopes and credential
+records — not a second code path.
+
+- **Text streaming** — yes, including reasoning parts and usage.
+- **Reasoning streaming** — yes, with each row's own effort ladder: the
+  budget-mode rows send `thinkingConfig.thinkingBudget`, the Gemini-3+ rows send
+  `thinkingLevel`. A row with `requiresEffort` refuses a turn that selects no
+  effort (`UNSUPPORTED_REASONING_EFFORT`), exactly as omp does.
+- **Tool-call handoff** — yes, native to DSH's tool loop, like Devin: the
+  transport emits the call and finishes the turn `toolUse`. Antigravity's
+  default tool mode (`VALIDATED`) is sent on every request that declares tools.
+- **Sign-in** — yes, with a real loopback listener on `127.0.0.1`:
+  `:8085/oauth2callback` for Gemini CLI and `:51121/oauth-callback` for
+  Antigravity, as the pinned rules declare. The browser redirect completes the
+  flow automatically; if the port is taken the listener falls back to an
+  ephemeral port and the authorize page names the port it actually bound. The
+  full address the browser landed on (or `code#state`) can also be pasted; a
+  pasted code without the state is refused, because that is exactly the shape a
+  forged callback would have. Anything the listener does not recognise — a
+  foreign `state`, an `error=`, a missing code — is answered `400` and dropped
+  without ending the attempt, so a stray request cannot kill the sign-in. The
+  listener closes on the matching callback, on an aborted attempt and **on a
+  timeout** (five minutes, `GoogleFlowOptions.waitMs` for tests): an expired wait
+  fails with `AUTH_FAILED` and commits nothing.
+- **Refresh** — yes. The resolver refreshes once, under the credential store's
+  per-key lock, when `expires - 60 s <= now`, keeps the `projectId` and an
+  un-rotated `refresh_token`, and reports a dead sign-in as `REAUTH_REQUIRED`.
+- **Credential record** — `llm-omp-transports/<route>` with
+  `{access, refresh, expires, projectId, email?}`. The adapter hands the
+  transport the structured JSON envelope (`token`, `projectId`, `refreshToken`,
+  `expiresAt`, `email`) that omp parses.
+- **Project discovery** — sign-in finishes with the Cloud Code Assist project:
+  `loadCodeAssist` → (tier onboarding `onboardUser` + LRO poll, or the required
+  `GOOGLE_CLOUD_PROJECT` / `GOOGLE_CLOUD_PROJECT_ID` variable for a
+  `legacy-tier`/paid account). Antigravity additionally checks free-tier
+  eligibility and bounds onboarding at 30 s.
+- **Models** — generated from the pinned `@oh-my-pi/pi-catalog@18.12.3`: 7 rows
+  for `google-gemini-cli`, 22 for `google-antigravity`, served without a network
+  call.
+- **Routes** — both declared configurable, so the Models page has
+  `providers.google-gemini-cli` and `providers.google-antigravity` allow-lists.
+- **Images** — not yet, same posture as the other routes: text-only input, image
+  blocks refused with `CONTENT_UNSUPPORTED`. omp's Antigravity image path
+  decodes through `Bun.Image`, which does not exist under Node, so that path is
+  dead here by construction; the projection never reaches it.
+
 ## Hard constraints
 
 - **Pinned, build-time-only omp.** `@oh-my-pi/pi-ai` and `@oh-my-pi/pi-catalog`
@@ -65,8 +142,9 @@ from `@oh-my-pi/*` or `bun:*` at runtime.
   committed manifest is unchanged after a build, so an omp bump that changes
   the contract shows up as a reviewable manifest diff before it can reach a
   request.
-- **Generated catalog.** The Cursor model table is generated from the pinned
-  catalog and is not hand-edited. An omp or catalog bump requires
+- **Generated catalogs.** The model tables (`cursor`, `devin`,
+  `google-gemini-cli`, `google-antigravity`) are generated from the pinned
+  catalog and are not hand-edited. An omp or catalog bump requires
   `pnpm -C packages/llm-omp run generate:catalog`.
 
 ## Limits and risks
@@ -95,14 +173,71 @@ from `@oh-my-pi/*` or `bun:*` at runtime.
   stops at the handoff; the result is only replayed on the follow-up request.
   Tool declarations travel as MCP definitions, and `toolHistory` is accepted
   but cannot be replayed (the active tool set is the projection).
-- **Only MCP calls are handed off.** Cursor-native exec frames (`read`, `shell`,
-  `write`, `delete`, `grep`, `ls`, `diagnostics`, streamed edits) are answered
-  by the transport with `Tool not available` and are **not** executed by DSH
-  (live reachability unverified).
+- **Colliding DSH tools are aliased, not dropped.** The transport keeps
+  Cursor's own `read`/`bash`/`write`/`delete`/`ls`/`grep`/`todo` names off the
+  MCP advertisement, so a DSH tool with one of those names is advertised as
+  `dsh_<name>`; the event stream restores the DSH name on the tool call, while
+  history replay keeps the advertised alias so the follow-up request stays
+  consistent. The seven `dsh_<native>` names are reserved: a DSH tool that
+  already carries one is refused with `TOOL_ALIAS_COLLISION`, which fails the
+  whole request and requires renaming the tool. Any other tool name travels
+  unchanged. Cursor-native exec frames (`read`, `shell`, `write`, `delete`,
+  `grep`, `ls`, `diagnostics`, streamed edits) are still answered by the
+  transport with `Tool not available` and are **not** executed by DSH (live
+  reachability unverified).
 - **Advisory request knobs are ignored.** Cursor's agent protocol has no field
   for an output cap, sampling temperature, stop sequences or an auxiliary-call
   purpose; DSH's `maxTokens`, `temperature`, `stop` and `purpose` never reach
   the wire, and Cursor applies the catalog output limit server-side.
+- **Unofficial Devin client.** The transport presents the released Devin CLI
+  identity (`ideName: "devin-cli"`, `ideType: "chisel"`, `ideVersion:
+  "3000.11.3"`) and a `connect-go` client header the omp sources copy from the
+  CLI. Same posture as Cursor's S4: a first live turn rejected with `401`/`403`
+  stops the route until a product decision, never a retry under another
+  identity.
+- **Attribution deviates on one call.** The Devin chat request must keep the
+  transport's own `connect-go` client header — the backend gates on it. The
+  header-less `GetUserJwt` handshake has no identity of its own, so the adapter
+  fills DSH's attribution `user-agent` only where a header is absent. Cursor's
+  requests keep full attribution.
+- **Devin has no refresh.** The pinned rule declares `refresh "none"`, so the
+  record is a static bearer with a derived `expires` (JWT `exp` minus five
+  minutes, else one year). An expired or corrupt record is `REAUTH_REQUIRED`,
+  not renewed. Because the omp loopback listener is Bun-only and the browser
+  half is untestable offline, the flow is paste-only for now; a bare pasted
+  code skips the state check (the page is the only place the state could
+  travel).
+
+- **Unofficial Google clients.** The Google routes reuse the OAuth clients and
+  client identities the pinned omp rules capture — Gemini CLI
+  (`GeminiCLI/0.46.0/...` plus `Client-Metadata`) and Antigravity
+  (`antigravity/hub/<version> ...`). Same posture as the Cursor and Devin
+  routes: the MIT license covers the code, not the service, and a first live
+  turn rejected with `401`/`403` on a valid token stops the route until a
+  product decision (stop condition **S4**) — never a retry under another
+  identity.
+- **Antigravity version lookup.** Before the first Antigravity request the
+  artifact reads the client version from the public update manifest (D11),
+  because the backend gates newer models on that version. A failed lookup is
+  silent and falls back to the pinned `2.19.1` for ten minutes; an explicit
+  `PI_AI_ANTIGRAVITY_VERSION` skips the lookup. That is the only outbound
+  request the routes make besides the vendor API itself.
+- **Google sign-in waits at most five minutes.** The loopback listener is
+  bounded by a wait budget (five minutes by default): a browser that never
+  returns fails the attempt with `AUTH_FAILED`, closes the socket and commits
+  nothing. An aborted attempt is reported as a cancellation, not a failure.
+  When the configured port is taken, the fallback is an ephemeral port; a host
+  that can bind neither fails the sign-in rather than silently dropping the
+  browser half (pasting still works only while the listener is up).
+- **Google attribution deviates on both routes.** The Cloud Code Assist wire
+  sets a vendor `user-agent` that the backend gates on, so DSH's attribution
+  `user-agent` is filled only where a request left the header absent — the same
+  fill-absent wrapper the Devin handshake uses.
+- **Real Google endpoints unverified.** The wire suite drives the bundled
+  transport end to end over a stubbed `fetch` (URL, envelope, headers, SSE,
+  in-band errors, Antigravity failover and the version manifest), but it never
+  calls Google. A first live sign-in and turn is a manual smoke check, not a
+  claim of server acceptance.
 
 ## Develop and test
 
@@ -113,9 +248,10 @@ pnpm -C packages/llm-omp test
 pnpm -C packages/llm-omp run generate:catalog
 ```
 
-`build` bundles the pinned omp graph from `scripts/omp-entry.ts` into
-`lib/omp/cursor.mjs` and rewrites `scripts/omp-manifest.json`; run it before
-`test` after a pin or shim change. CI runs the same sequence and then fails if
+`build` bundles the pinned omp graphs from `scripts/omp-entry.ts`,
+`scripts/omp-entry-devin.ts` and `scripts/omp-entry-google.ts` into
+`lib/omp/cursor.mjs`, `lib/omp/devin.mjs` and `lib/omp/google.mjs` and rewrites
+`scripts/omp-manifest.json`; run it before `test` after a pin or shim change. CI runs the same sequence and then fails if
 the committed manifest drifted.
 
 The install proof lives at the repository root and needs `pnpm` and `dsh` on
@@ -128,7 +264,7 @@ node scripts/verify-install.mjs
 It packs both packages, installs the root tarball into a fresh DSH profile,
 and asserts that the composed profile carries both loader rows
 (`dsh-keys-manager` and `llm-omp-transports`). It does not exercise the
-plugin-manager UI or any Cursor network behavior.
+plugin-manager UI or any provider network behavior.
 
 ## Release
 
@@ -146,3 +282,12 @@ plugin surface.
 ## License
 
 Released under the [MIT License](../../LICENSE).
+
+## Deferred
+
+`factory-droid` is **not** part of this component yet. Its omp graph pulls
+`providers/register-builtins`, which statically imports every builtin provider,
+measuring 327 modules / 16 991 893 B at the current pin — far past the plan's
+stop rule — so the route waits for its own plan (tracked as issue `I-000253`,
+with a build-substitution remedy as one candidate). Nothing in this package
+reads or registers a `factory-droid` route.

package/bundle/cordis.patch.yml

@@ -1,5 +1,5 @@
 # Mounts the llm-omp-transports transport plugin when this package is installed on its
-# own. It owns the `cursor` (later `devin`, …) LLM routes and the
+# own. It owns the `cursor` and `devin` LLM routes and the
 # `llm-omp-transports/<provider>` credential scope.
 - insert:
     - id: llm-omp-transports

package/lib/adapter.d.ts

@@ -1,15 +1,16 @@
 /**
- * Adapter for the omp-owned `cursor` route.
+ * Adapter for the omp-owned routes this plugin serves.
  *
- * The route speaks Cursor's own agent protocol (`agent.v1.AgentService/Run`
- * over HTTP/2) through the omp build artifact in `lib/omp/cursor.mjs`. The
+ * Two routes share one shape: the provider speaks its own agent protocol
+ * (Cursor's `agent.v1.AgentService/Run`, Devin's Connect-framed
+ * `GetChatMessage`) through an omp build artifact in `lib/omp/*.mjs`. The
  * transport is injected rather than imported so this module stays free of the
- * 14 MB build artifact and tests can replay recorded event scripts. The plugin
- * wires the bundled `streamCursor` at registration and the credential seam
- * provides {@link OmpCursorAdapterConfig.access}, which refreshes an expiring
- * grant under the store's lock before it answers.
+ * bundled artifacts and tests can replay recorded event scripts. A
+ * {@link TransportRoute} carries what differs per route: the catalog, the
+ * projection and the credential key; the base class carries the shared
+ * credential/turn ordering.
  *
- * The catalog is the generated `src/catalog/cursor.ts`, so `listModels` and
+ * The catalogs are the generated `src/catalog/*.ts`, so `listModels` and
  * `resolveModel` answer without a network call and carry the transport flags the
  * projection needs (effort routing, max mode, glyph tokenization).
  *
@@ -17,30 +18,95 @@
  */
 import { LlmAdapter } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
-import type { OmpCursorTransport } from './omp.js';
-/** The provider route this adapter owns. */
+import type { RouteProfile } from './projection.js';
+import type { OmpAssistantMessageEvent, OmpContext } from './omp.js';
+import type { CursorModelRow, DevinModelRow, GoogleModelRow, OmpCursorModel, OmpCursorOptions, OmpDevinModel, OmpDevinOptions, OmpGoogleModel, OmpGoogleOptions } from './omp.js';
+/** The Cursor provider route this adapter owns. */
 export declare const CURSOR_ROUTE = "cursor";
+/** The Devin provider route this adapter owns. */
+export declare const DEVIN_ROUTE = "devin";
+/** The Gemini CLI provider route this adapter owns. */
+export declare const GOOGLE_GEMINI_CLI_ROUTE = "google-gemini-cli";
+/** The Antigravity provider route this adapter owns. */
+export declare const GOOGLE_ANTIGRAVITY_ROUTE = "google-antigravity";
 /** Machine code for a model id the generated catalog does not contain. */
 export declare const UNKNOWN_MODEL = "UNKNOWN_MODEL";
 /** Machine code for a provider route this adapter does not serve. */
 export declare const UNKNOWN_PROVIDER = "UNKNOWN_PROVIDER";
-/** What the adapter needs from its host plugin. */
-export interface OmpCursorAdapterConfig {
+/** The catalog fields every route's row must carry. */
+interface TransportRow {
+    readonly id: string;
+    readonly name: string;
+    readonly contextWindow: number;
+}
+/** The transport options both routes accept at their shared surface. */
+interface TransportOptions {
+    readonly apiKey?: string;
+    readonly signal?: AbortSignal;
+}
+/** One omp transport function, narrowed to the plugin's event contract. */
+export type OmpTransportOf<Model, Options> = (model: Model, context: OmpContext, options: Options) => AsyncIterable<OmpAssistantMessageEvent>;
+/** The three positional transport arguments a projection produces. */
+export interface ProjectedTransportRequest<Model, Options> {
+    readonly model: Model;
+    readonly context: OmpContext;
+    /** Transport options without the credential; the adapter injects `apiKey`. */
+    readonly options: Omit<Options, 'apiKey'> & {
+        readonly apiKey?: string;
+    };
+}
+/** What differs between the routes: identity, catalog, projection and credential record. */
+export interface TransportRoute<Row extends TransportRow, Model, Options extends TransportOptions> {
+    /** Provider id; also the registered route set the projection's profile accepts. */
+    readonly id: 'cursor' | 'devin' | 'google-gemini-cli' | 'google-antigravity';
+    /** Models-page / provider-info display name. */
+    readonly displayName: string;
+    /** The `ctx.credentials` record this route reads. */
+    readonly credentialKey: string;
+    /** Projection facts: identity, fallback error code and transport-resolved marker. */
+    readonly profile: RouteProfile;
+    /** The generated catalog. */
+    readonly models: readonly Row[];
+    /** Project one DSH request onto this route's transport arguments. */
+    readonly project: (row: Row, options: GenerateOptions) => ProjectedTransportRequest<Model, Options>;
+    /**
+     * The row's advertised reasoning efforts.
+     *
+     * Cursor's rows carry `thinking.efforts`; Devin's rows advertise none (a
+     * selected effort is refused by its projection), so the route may omit this.
+     */
+    readonly efforts?: (row: Row) => readonly string[] | undefined;
+}
+/** The Cursor route's facts. */
+export declare const CURSOR_TRANSPORT_ROUTE: TransportRoute<CursorModelRow, OmpCursorModel, OmpCursorOptions>;
+/** The Devin route's facts. */
+export declare const DEVIN_TRANSPORT_ROUTE: TransportRoute<DevinModelRow, OmpDevinModel, OmpDevinOptions>;
+/**
+ * The two Google routes' facts.
+ *
+ * One artifact serves both: `streamGoogleGeminiCli` dispatches on
+ * `model.provider`, so only the profile, the catalog and the credential record
+ * differ. The credential key is the route id under the package namespace
+ * (`llm-omp-transports/<route>`), as it is for cursor and devin; the Google
+ * resolver reads and writes those records.
+ */
+export declare const GOOGLE_GEMINI_CLI_TRANSPORT_ROUTE: TransportRoute<GoogleModelRow, OmpGoogleModel, OmpGoogleOptions>;
+/** The Antigravity route's facts: the same provider over its own catalog and endpoint family. */
+export declare const GOOGLE_ANTIGRAVITY_TRANSPORT_ROUTE: TransportRoute<GoogleModelRow, OmpGoogleModel, OmpGoogleOptions>;
+/** What an adapter needs from its host plugin. */
+export interface OmpAdapterOptions<Model, Options extends TransportOptions> {
     /**
-     * Resolve the Cursor bearer token for one request.
+     * Resolve the route's bearer token for one request.
      *
      * @remarks
-     * Asynchronous because it reads and refreshes the `llm-omp-transports/cursor`
+     * Asynchronous because it reads (and, for Cursor, refreshes) the route's
      * credential through the credentials seam. The request signal is forwarded
      * so an aborted turn can abandon a refresh instead of writing it late. Tests
      * inject a fake.
      */
     access: (signal?: AbortSignal) => Promise<string>;
-    /**
-     * The omp transport, normally the `streamCursor` export of
-     * `lib/omp/cursor.mjs`. The seam tests drive it with recorded event scripts.
-     */
-    transport: OmpCursorTransport;
+    /** The omp transport, normally the artifact's stream export. Tests script it. */
+    transport: OmpTransportOf<Model, Options>;
     /**
      * Read the configured allow-list of catalog ids.
      *
@@ -48,32 +114,62 @@ export interface OmpCursorAdapterConfig {
      * A getter because the profile is a volatile setting: a save updates the
      * running config reference without re-running the plugin, so a captured
      * array would go stale. An absent or empty list advertises the full catalog,
-     * so the schema default (`providers.cursor.models: []`) is today's behavior;
+     * so the schema default (`providers.<route>.models: []`) is today's behavior;
      * a non-empty list narrows the advertised models and the accepted ids.
      */
     models?: () => readonly string[] | undefined;
 }
-/** The DSH llm adapter for every route this plugin's omp transport serves. */
-export declare class OmpCursorAdapter extends LlmAdapter {
+/** The adapter configuration for one concrete route. */
+interface OmpRouteAdapterConfig<Row extends TransportRow, Model, Options extends TransportOptions> extends OmpAdapterOptions<Model, Options> {
+    readonly route: TransportRoute<Row, Model, Options>;
+}
+/**
+ * The DSH llm adapter for one omp-backed route.
+ *
+ * @remarks
+ * The per-turn order is fixed: refuse an already-aborted turn, resolve the row,
+ * project the request (refusals must not pay a credential read), read the
+ * credential, validate it, then stream. Cursor's grant can be refreshed under
+ * that read; Devin's resolver only reads.
+ */
+declare abstract class OmpTransportAdapter<Row extends TransportRow, Model, Options extends TransportOptions> extends LlmAdapter {
     private readonly config;
-    constructor(config: OmpCursorAdapterConfig);
-    /**
-     * Describe the route.
-     *
-     * @remarks
-     * Cursor's agent protocol takes no client-side output cap, sampling
-     * temperature, stop sequence or auxiliary-call purpose: the wire carries no
-     * field for any of them, so the projection ignores those `GenerateOptions`
-     * values instead of forwarding them. Cursor applies the catalog `maxTokens`
-     * limit server-side.
-     */
-    providerInfo(provider: string): LlmProviderInfo;
-    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
-    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
-    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private readonly rows;
+    protected constructor(config: OmpRouteAdapterConfig<Row, Model, Options>);
     /** The configured ids, or undefined when the route advertises the full catalog. */
     private allowed;
     /** Resolve one catalog row, refusing ids the configured allow-list excludes. */
     private rowFor;
+    providerInfo(provider: string): LlmProviderInfo;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** Refuse routes this adapter does not own instead of describing another provider's models. */
+    private assertRoute;
     private call;
+    /** Build the seam's exact-model metadata from one catalog row. */
+    private modelInfo;
+}
+/** The DSH llm adapter configuration for the Cursor route. */
+export type OmpCursorAdapterConfig = OmpAdapterOptions<OmpCursorModel, OmpCursorOptions>;
+/** The Cursor adapter: the bundled `streamCursor` over the generated Cursor catalog. */
+export declare class OmpCursorAdapter extends OmpTransportAdapter<CursorModelRow, OmpCursorModel, OmpCursorOptions> {
+    constructor(options: OmpCursorAdapterConfig);
+}
+/** The DSH llm adapter configuration for the Devin route. */
+export type OmpDevinAdapterConfig = OmpAdapterOptions<OmpDevinModel, OmpDevinOptions>;
+/** The Devin adapter: the bundled `streamDevin` over the generated Devin catalog. */
+export declare class OmpDevinAdapter extends OmpTransportAdapter<DevinModelRow, OmpDevinModel, OmpDevinOptions> {
+    constructor(options: OmpDevinAdapterConfig);
+}
+/** The DSH llm adapter configuration for a Google route. */
+export type OmpGoogleAdapterConfig = OmpAdapterOptions<OmpGoogleModel, OmpGoogleOptions>;
+/** The Gemini CLI adapter: the bundled `streamGoogleGeminiCli` over the Gemini CLI catalog. */
+export declare class OmpGoogleGeminiCliAdapter extends OmpTransportAdapter<GoogleModelRow, OmpGoogleModel, OmpGoogleOptions> {
+    constructor(options: OmpGoogleAdapterConfig);
+}
+/** The Antigravity adapter: the same artifact and transport over the Antigravity catalog. */
+export declare class OmpGoogleAntigravityAdapter extends OmpTransportAdapter<GoogleModelRow, OmpGoogleModel, OmpGoogleOptions> {
+    constructor(options: OmpGoogleAdapterConfig);
 }
+export {};