dsh-gateway-provider 1.0.0

package/lib/pi-provider.js

@@ -0,0 +1,148 @@
+/**
+ * Construct a pi-ai `Provider` for one newapi gateway.
+ *
+ * The gateway advertises models over `GET /v1/models` (with per-model
+ * `supported_endpoint_types`). This module maps each discovered model into a
+ * pi-ai `Model` whose `api` field names the wire protocol pi-ai's protocol
+ * layer should speak for it, then builds the provider with
+ * `createProvider({ id, baseUrl, auth, models, api })`.
+ *
+ * The gateway's endpoint-type vocabulary (openai / openai-response /
+ * anthropic / gemini) maps onto pi-ai's API identifiers:
+ *
+ * | gateway endpoint type | pi-ai api              |
+ * |----------------------|------------------------|
+ * | openai               | openai-completions     |
+ * | openai-response      | openai-responses       |
+ * | anthropic            | anthropic-messages     |
+ * | gemini               | google-generative-ai   |
+ *
+ * A model advertising several types picks the first that matches the gateway's
+ * configured priority (default openai-responses → anthropic → openai → gemini).
+ *
+ * @module dsh-gateway-provider/pi-provider
+ */
+
+import { createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
+import { DEFAULT_MAX_TOKENS, NO_COST } from "./catalog.js";
+import { findPiModel } from "./thinking.js";
+import { apiOfEndpointType, pickModelApi, DEFAULT_ENDPOINT_PRIORITY } from "./protocols.js";
+
+// Re-exported for existing importers; the mapping itself lives in protocols.js.
+export { apiOfEndpointType, pickModelApi, DEFAULT_ENDPOINT_PRIORITY };
+
+/** pi-ai protocol factories keyed by their API identifier. */
+const PROTOCOLS = {
+  "openai-completions": openAICompletionsApi,
+  "openai-responses": openAIResponsesApi,
+  "anthropic-messages": anthropicMessagesApi,
+  "google-generative-ai": googleGenerativeAIApi,
+};
+
+/**
+ * Normalize the gateway base URL for one pi-ai API.
+ *
+ * The OpenAI Node SDK (used by pi-ai for openai-completions / openai-responses)
+ * expects the baseURL to already include `/v1` — its default is
+ * `https://api.openai.com/v1`, and `responses.create()` only appends
+ * `/responses`. A gateway baseURL without `/v1` makes the SDK request
+ * `{base}/responses`, which the gateway answers with its HTML UI (HTTP 200,
+ * content-type text/html) instead of an SSE stream, so the SDK receives zero
+ * events. Anthropic and Google protocols build their own full paths, so they
+ * need no `/v1` appended.
+ * @param baseURL - the gateway base URL as configured.
+ * @param api - the pi-ai API identifier the model will use.
+ * @returns the baseURL the OpenAI SDK should point at.
+ */
+function sdkBaseURL(baseURL, api) {
+  const trimmed = String(baseURL ?? "").replace(/\/+$/, "");
+  if (api === "openai-completions" || api === "openai-responses") {
+    if (!/\/v\d+$/.test(trimmed)) return `${trimmed}/v1`;
+  }
+  return trimmed;
+}
+
+/**
+ * Build one pi-ai `Model` from a discovered gateway entry, enriched with
+ * models.dev parameters and the user's per-model overrides.
+ * @param entry - the enriched catalog entry (id, name, contextWindow, …).
+ * @param providerId - the provider route key (becomes `model.provider`).
+ * @param baseURL - the gateway base URL (becomes `model.baseUrl`).
+ * @param priority - endpoint-type preference order.
+ * @param defaults - fallback capacities (contextWindow, maxTokens); when it
+ *   carries `apiBases` (protocol URL fields configured), that entry wins for
+ *   the model's API instead of deriving from `baseURL`.
+ * @param override - per-model override object from settings (may be undefined).
+ * @returns the pi-ai Model object.
+ */
+export function buildModel(entry, providerId, baseURL, priority, defaults, override) {
+  const api = pickModelApi(entry.endpointTypes, priority);
+  // Cost comes from the pi-ai builtin catalog when the model resolves there;
+  // models without a pi-ai match (custom gateway entries, internal-test ids)
+  // carry NO_COST — the harness only reads cost for usage accounting and
+  // tolerates zero values gracefully.
+  const piModel = findPiModel(entry.id);
+  // A gateway with protocol URL fields (custom template) carries exact SDK
+  // bases per API; otherwise derive from the single base URL.
+  const apiBase = defaults?.apiBases?.[api];
+  return {
+    id: entry.id,
+    name: entry.name ?? entry.id,
+    api,
+    provider: providerId,
+    baseUrl: apiBase !== undefined ? apiBase : sdkBaseURL(baseURL, api),
+    reasoning: entry.reasoning ?? false,
+    input: entry.input ?? ["text"],
+    cost: piModel?.cost ?? NO_COST,
+    contextWindow: override?.contextWindow ?? entry.contextWindow ?? defaults?.defaultContextWindow ?? defaults?.contextWindow,
+    maxTokens: override?.maxTokens ?? entry.maxTokens ?? defaults?.maxTokens,
+    ...entry.thinkingLevelMap !== undefined ? { thinkingLevelMap: entry.thinkingLevelMap } : {},
+    ...piModel?.thinkingLevelMap !== undefined ? { thinkingLevelMap: piModel.thinkingLevelMap } : {},
+    ...piModel?.compat !== undefined ? { compat: piModel.compat } : {},
+    ...entry.compat !== undefined ? { compat: entry.compat } : {},
+  };
+}
+
+/**
+ * Construct the pi-ai Provider for one gateway connection.
+ *
+ * The provider carries every discovered model. `api` is passed as a **map**
+ * keyed by pi-ai API identifier (openai-completions / openai-responses /
+ * anthropic-messages / google-generative-ai): pi-ai's `createProvider` then
+ * dispatches each model to the protocol its `model.api` field names. Passing a
+ * single ProviderStreams instead would force every model through one protocol
+ * regardless of its `api` field.
+ *
+ * @param spec - the resolved gateway facts.
+ * @returns the pi-ai Provider registered into the adapter's Models collection.
+ */
+export function buildProvider(spec) {
+  return createProvider({
+    id: spec.providerId,
+    name: spec.displayName,
+    baseUrl: spec.baseURL,
+    auth: { apiKey: gatewayAuth(spec.displayName) },
+    models: spec.models,
+    api: {
+      "openai-completions": openAICompletionsApi(),
+      "openai-responses": openAIResponsesApi(),
+      "anthropic-messages": anthropicMessagesApi(),
+      "google-generative-ai": googleGenerativeAIApi(),
+    },
+  });
+}
+
+/** Api-key auth resolved from the harness credential the adapter holds. */
+function gatewayAuth(name) {
+  return {
+    name,
+    resolve: ({ credential }) => Promise.resolve({
+      auth: credential?.key === void 0 ? {} : { apiKey: credential.key },
+      source: name,
+    }),
+  };
+}

package/lib/protocols.js

@@ -0,0 +1,150 @@
+/**
+ * Shared endpoint-type ↔ pi-ai protocol vocabulary.
+ *
+ * The gateway advertises per-model endpoint types (openai / openai-response /
+ * anthropic / gemini); pi-ai identifies wire protocols by API id
+ * (openai-completions / openai-responses / anthropic-messages /
+ * google-generative-ai). This module owns the mapping and the priority-based
+ * selection so both the catalog (discovery preview) and the pi-provider
+ * (request dispatch) share one source of truth without importing each other.
+ *
+ * @module dsh-gateway-provider/protocols
+ */
+
+/** Default endpoint-type preference: prefer the modern Responses API. */
+export const DEFAULT_ENDPOINT_PRIORITY = ["openai-response", "anthropic", "openai", "gemini"];
+
+/**
+ * Known endpoint path suffixes each wire protocol is served under, used to
+ * reduce a fully-qualified endpoint URL to the SDK base URL. The OpenAI SDK
+ * (chat + responses) expects a base ending in `/v1` and appends the suffix
+ * itself; the Anthropic SDK appends `/v1/messages`.
+ */
+const ENDPOINT_SUFFIXES = {
+  "openai-completions": "/chat/completions",
+  "openai-responses": "/responses",
+  "anthropic-messages": "/v1/messages",
+};
+
+/** Trim a configured URL and strip one known endpoint suffix if present. */
+function stripSuffix(url, suffix) {
+  const s = String(url ?? "").trim().replace(/\/+$/, "");
+  if (s.length === 0) return undefined;
+  if (s.toLowerCase().endsWith(suffix)) return s.slice(0, -suffix.length).replace(/\/+$/, "") || undefined;
+  return s;
+}
+
+/**
+ * Derive the per-protocol facts from fully-qualified endpoint URLs
+ * (`openaiURL` / `responsesURL` / `anthropicURL`). Unset URLs mean the
+ * protocol is unavailable on this gateway ("没填的就是没有"): the returned
+ * `availableTypes` is exactly the configured set.
+ *
+ * Each URL may be the complete endpoint address (`…/v1/chat/completions`),
+ * an SDK base (`…/v1`), or — for anthropic — a bare host; the derivation
+ * strips the known suffix and re-adds the version segment where the SDK
+ * expects it.
+ * @param urls - the gateway's protocol URL fields (any may be absent).
+ * @returns `{ apiBases, availableTypes, catalogBase }` where apiBases maps
+ *   pi-ai API id → SDK base URL, availableTypes lists gateway endpoint
+ *   types, and catalogBase is the bare base for `/v1/models` discovery
+ *   (null when no OpenAI-style URL is set); undefined when no URL is set.
+ */
+export function deriveProtocolURLs(urls) {
+  if (urls === null || typeof urls !== "object") return undefined;
+  const apiBases = {};
+  const availableTypes = [];
+  let catalogBase;
+
+  const oc = stripSuffix(urls.openaiURL, ENDPOINT_SUFFIXES["openai-completions"]);
+  if (oc !== undefined) {
+    apiBases["openai-completions"] = /\/v\d+$/.test(oc) ? oc : `${oc}/v1`;
+    availableTypes.push("openai");
+  }
+  const rs = stripSuffix(urls.responsesURL, ENDPOINT_SUFFIXES["openai-responses"]);
+  if (rs !== undefined) {
+    apiBases["openai-responses"] = /\/v\d+$/.test(rs) ? rs : `${rs}/v1`;
+    availableTypes.push("openai-response");
+  }
+  // Anthropic: the SDK appends `/v1/messages` itself, so accept the full
+  // endpoint URL, a base ending in `/v1`, or a bare host.
+  const anRaw = String(urls.anthropicURL ?? "").trim().replace(/\/+$/, "");
+  if (anRaw.length > 0) {
+    const lower = anRaw.toLowerCase();
+    const stripped = lower.endsWith(ENDPOINT_SUFFIXES["anthropic-messages"])
+      ? anRaw.slice(0, -ENDPOINT_SUFFIXES["anthropic-messages"].length)
+      : lower.endsWith("/v1") ? anRaw.slice(0, -"/v1".length) : anRaw;
+    const an = stripped.replace(/\/+$/, "");
+    if (an.length > 0) {
+      apiBases["anthropic-messages"] = an;
+      availableTypes.push("anthropic");
+    }
+  }
+  if (availableTypes.length === 0) return undefined;
+  for (const api of ["openai-completions", "openai-responses"]) {
+    if (apiBases[api] !== undefined) { catalogBase = apiBases[api].replace(/\/v\d+$/, ""); break; }
+  }
+  return { apiBases, availableTypes, catalogBase: catalogBase ?? null };
+}
+
+/**
+ * Intersect a model's advertised endpoint types with the protocols the
+ * gateway actually has addresses for. Models that advertise nothing inherit
+ * the full available set (the gateway's protocols define their fallback).
+ * @param endpointTypes - protocols the model advertises (may be undefined).
+ * @param availableTypes - configured protocols, or undefined = all allowed.
+ * @returns the effective endpoint-type list, or null when the model cannot
+ *   be served on any configured protocol (caller drops it).
+ */
+export function effectiveEndpointTypes(endpointTypes, availableTypes) {
+  if (availableTypes === undefined) return endpointTypes;
+  if (!Array.isArray(endpointTypes) || endpointTypes.length === 0) return availableTypes;
+  const kept = endpointTypes.filter((t) => availableTypes.includes(t));
+  return kept.length > 0 ? kept : null;
+}
+
+/** Gateway endpoint type → pi-ai API identifier. */
+export function apiOfEndpointType(type) {
+  switch (type) {
+    case "openai": return "openai-completions";
+    case "openai-response": return "openai-responses";
+    case "anthropic": return "anthropic-messages";
+    case "gemini": return "google-generative-ai";
+    default: return undefined;
+  }
+}
+
+/** pi-ai API identifier → gateway endpoint type (inverse mapping). */
+export function endpointTypeOfApi(api) {
+  switch (api) {
+    case "openai-completions": return "openai";
+    case "openai-responses": return "openai-response";
+    case "anthropic-messages": return "anthropic";
+    case "google-generative-ai": return "gemini";
+    default: return api;
+  }
+}
+
+/**
+ * Choose the pi-ai API for one model from its advertised endpoint types,
+ * honoring the priority order (most-preferred first).
+ * @param {string[]} endpointTypes - protocols the model advertises (gateway vocabulary).
+ * @param {string[]} priority - ordered gateway endpoint types to try.
+ * @returns {string} the pi-ai API identifier, or "openai-completions" as fallback.
+ */
+export function pickModelApi(endpointTypes, priority) {
+  const advertised = Array.isArray(endpointTypes) ? endpointTypes : [];
+  if (advertised.length === 0) return "openai-completions";
+  for (const preferred of priority ?? DEFAULT_ENDPOINT_PRIORITY) {
+    if (advertised.includes(preferred)) {
+      const api = apiOfEndpointType(preferred);
+      if (api !== undefined) return api;
+    }
+  }
+  // Fall back to any advertised type we recognize.
+  for (const type of advertised) {
+    const api = apiOfEndpointType(type);
+    if (api !== undefined) return api;
+  }
+  return "openai-completions";
+}

package/lib/thinking.js

@@ -0,0 +1,219 @@
+/**
+ * Model thinking-level management, reusing the DeepSeek Harness's own model
+ * directory and reasoning machinery from `@earendil-works/pi-ai` (the library
+ * behind the official `llm-pi-ai` adapter, always installed with the harness).
+ *
+ * Instead of heuristically deriving reasoning levels, this module:
+ *
+ * 1. looks the model up in pi-ai's builtin catalog (1100+ models across 37
+ *    providers) by id — every entry carries `reasoning` plus a
+ *    `thinkingLevelMap` that spells the provider-native wire value for each
+ *    thinking level (`null` = unsupported, absent = supported with the level
+ *    string itself as the wire value);
+ * 2. derives the selectable levels with pi-ai's own
+ *    {@link getSupportedThinkingLevels} (levels `off` / `minimal` / `low` /
+ *    `medium` / `high` / `xhigh` / `max` with pi-ai's asymmetric defaulting:
+ *    an absent key supports the base levels, while `xhigh`/`max` need an
+ *    explicit value);
+ * 3. serializes the thinking parameters following pi-ai's openai-completions
+ *    branches: `compat.thinkingFormat === "deepseek"` models get
+ *    `thinking: {type: enabled|disabled}` (+ `reasoning_effort` unless
+ *    `supportsReasoningEffort` is false), everything else gets OpenAI-style
+ *    `reasoning_effort` mapped through `thinkingLevelMap`.
+ *
+ * Gateway model ids are first normalized to their base form (namespace prefix
+ * and channel suffixes like `-highspeed` stripped) so variants such as
+ * `glm-5.2-highspeed` resolve to `glm-5.2`; the same model advertised under
+ * several providers is resolved to its first-party entry (native wire
+ * semantics) rather than an arbitrary aggregator copy.
+ *
+ * Only when the pi-ai catalog misses a model (custom gateway entries) does the
+ * module fall back to models.dev inference (`reasoning: true` + family), with
+ * an optional `extended` mode that widens the fallback to the full normalized
+ * level set for the user to choose explicitly.
+ *
+ * @module dsh-gateway-provider/thinking
+ */
+
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { getBuiltinModels, getBuiltinProviders } from "@earendil-works/pi-ai/providers/all";
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+
+/** Gateway channel-suffix markers stripped before a catalog lookup. */
+const MODEL_VARIANT_SUFFIXES = ["highspeed", "high-speed", "lowspeed", "low-speed"];
+const VARIANT_SUFFIX_RE = new RegExp(`-(${MODEL_VARIANT_SUFFIXES.join("|")})$`, "i");
+
+/**
+ * Normalize a gateway model id to its base form: lowercase, strip any
+ * `provider/` namespace, and drop a trailing gateway channel suffix
+ * (`-highspeed`, `-lowspeed`, ...). Variants like `glm-5.2-highspeed`
+ * resolve to their catalog model `glm-5.2`. Variant identity is preserved
+ * separately by {@link variantLabel} so pickers can tell them apart.
+ * @param id - the gateway-advertised model id.
+ * @returns the normalized base id, or "" when there is nothing usable.
+ */
+export function baseModelId(id) {
+  const s = String(id ?? "").trim().toLowerCase();
+  if (s.length === 0) return "";
+  const bare = s.includes("/") ? s.slice(s.lastIndexOf("/") + 1) : s;
+  return bare.replace(VARIANT_SUFFIX_RE, "");
+}
+
+/**
+ * The human-readable variant tag stripped by {@link baseModelId}, Title-Cased
+ * (e.g. `glm-5.2-highspeed` → `Highspeed`, `gpt-5.5-lowspeed` → `Lowspeed`).
+ * Returns "" for non-variant ids so the base model name is left untouched.
+ * @param id - the gateway-advertised model id.
+ */
+export function variantLabel(id) {
+  const m = VARIANT_SUFFIX_RE.exec(String(id ?? ""));
+  if (m === null) return "";
+  const tag = m[1].replace(/-/g, "").toLowerCase();
+  return tag.charAt(0).toUpperCase() + tag.slice(1);
+}
+
+/** Providers whose entries describe the model's native wire format. */
+const FIRST_PARTY = new Set([
+  "deepseek", "minimax", "minimax-cn", "zai", "zai-coding-cn",
+  "moonshotai", "moonshotai-cn", "kimi-coding",
+  "anthropic", "openai", "openai-codex", "google", "google-vertex", "xai",
+  "mistral", "groq", "cerebras", "nvidia", "together", "xiaomi", "ant-ling",
+]);
+
+/** Preferred first-party provider per model family (the lab's native wire). */
+const FAMILY_PROVIDER = [
+  [/deepseek/, "deepseek"],
+  [/glm|zai/, "zai"],
+  [/kimi/, "moonshotai"],
+  [/minimax/, "minimax"],
+  [/gpt|chatgpt|\bo[1-9]/, "openai"],
+  [/claude|anthropic/, "anthropic"],
+  [/gemini|google/, "google"],
+  [/grok/, "xai"],
+  [/mistral|codestral/, "mistral"],
+];
+
+/**
+ * Pick the most authoritative entry among several provider copies of one
+ * model: the family's first-party provider wins, then any first-party entry,
+ * then the original (stable) order.
+ */
+function preferEntry(entries, id) {
+  if (entries.length === 1) return entries[0];
+  const hint = FAMILY_PROVIDER.find(([re]) => re.test(id))?.[1];
+  if (hint !== undefined) {
+    const hit = entries.find((e) => e.provider === hint);
+    if (hit !== undefined) return hit;
+  }
+  const firstParty = entries.find((e) => FIRST_PARTY.has(e.provider));
+  return firstParty ?? entries[0];
+}
+
+/** One shared base-id → pi-ai model entry index over all built-in providers. */
+let piIndex;
+function indexPiModels() {
+  if (piIndex !== undefined) return piIndex;
+  const map = new Map();
+  for (const provider of getBuiltinProviders()) {
+    for (const model of getBuiltinModels(provider)) {
+      const key = baseModelId(model.id);
+      if (key.length === 0) continue;
+      if (!map.has(key)) map.set(key, []);
+      map.get(key).push(model);
+    }
+  }
+  piIndex = map;
+  return map;
+}
+
+/**
+ * Look up a gateway model id in the harness's builtin pi-ai catalog, resolving
+ * namespace/suffix variants and provider copies to the authoritative entry.
+ */
+export function findPiModel(id) {
+  const key = baseModelId(id);
+  if (key.length === 0) return undefined;
+  const entries = indexPiModels().get(key);
+  return entries === undefined ? undefined : preferEntry(entries, key);
+}
+
+/**
+ * The reasoning family of one model, used for fallback and MiniMax handling.
+ * The family comes from models.dev metadata when present, else from the model
+ * id prefix, else from the pi-ai provider.
+ */
+export function reasoningFamilyOf(entry, model, piModel) {
+  const id = String(model ?? piModel?.id ?? entry?.id ?? "").toLowerCase();
+  const family = typeof entry?.family === "string" ? entry.family.toLowerCase() : "";
+  const provider = typeof piModel?.provider === "string" ? piModel.provider.toLowerCase() : "";
+  if (family.startsWith("deepseek") || id.startsWith("deepseek") || provider === "deepseek") return "deepseek";
+  if (family.startsWith("minimax") || id.startsWith("minimax") || provider.startsWith("minimax")) return "minimax";
+  return "generic";
+}
+
+function capitalize(level) {
+  return level.length === 0 ? level : `${level.charAt(0).toUpperCase()}${level.slice(1)}`;
+}
+
+const effort = (level) => ({ id: ReasoningEffortId(level), name: capitalize(level) });
+
+/** The normalized thinking-level vocabulary ReasoningEffortId accepts. */
+const KNOWN_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+
+/**
+ * Build a selectable effort set from an explicit user override (the per-model
+ * `reasoningLevels` array). Unknown / duplicate entries are dropped; an empty
+ * result means the caller should fall back to catalog inference.
+ */
+export function effortsFromLevels(levels) {
+  if (!Array.isArray(levels)) return [];
+  const seen = new Set();
+  const clean = [];
+  for (const raw of levels) {
+    const level = String(raw ?? "").toLowerCase();
+    if (!KNOWN_LEVELS.has(level) || seen.has(level)) continue;
+    seen.add(level);
+    clean.push(effort(level));
+  }
+  return clean;
+}
+
+/** Native DeepSeek reasoning set (off / high / max). */
+const DEEPSEEK_EFFORTS = [effort("off"), effort("high"), effort("max")];
+/** MiniMax has a two-state wire (`adaptive|disabled`): off + one "on" level. */
+const MINIMAX_EFFORTS = [effort("off"), effort("high")];
+/** OpenAI-standard generic set, safe for unknown reasoning models. */
+const GENERIC_EFFORTS = [effort("off"), effort("low"), effort("medium"), effort("high")];
+/** Full normalized set, offered only under the explicit `extended` opt-in. */
+const EXTENDED_EFFORTS = [effort("off"), effort("minimal"), effort("low"), effort("medium"), effort("high"), effort("xhigh"), effort("max")];
+
+/**
+ * The selectable reasoning efforts for one model.
+ *
+ * With a pi-ai catalog hit the level set is pi-ai's own answer for that exact
+ * model (including its per-level support matrix), except MiniMax, which is
+ * collapsed to its real two-state wire. Without a hit, models.dev inference
+ * falls back to family heuristics; `extended` widens the generic fallback to
+ * the full normalized set for explicit user choice.
+ */
+export function thinkingEffortsOf(entry, piModel, opts = {}) {
+  const extended = opts.extended === true;
+  if (piModel !== undefined) {
+    if (piModel.reasoning !== true) return undefined;
+    if (reasoningFamilyOf(entry, undefined, piModel) === "minimax") return { efforts: MINIMAX_EFFORTS };
+    const levels = getSupportedThinkingLevels(piModel);
+    if (levels.length === 0 || levels.length === 1 && levels[0] === "off") return undefined;
+    return { efforts: levels.map((level) => ({ id: ReasoningEffortId(level), name: capitalize(level) })) };
+  }
+  if (entry === undefined || entry.reasoning !== true) return undefined;
+  switch (reasoningFamilyOf(entry)) {
+    case "deepseek":
+      return { efforts: DEEPSEEK_EFFORTS };
+    case "minimax":
+      return { efforts: MINIMAX_EFFORTS };
+    default:
+      return { efforts: extended ? EXTENDED_EFFORTS : GENERIC_EFFORTS };
+  }
+}
+
+

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "dsh-gateway-provider",
+  "version": "1.0.0",
+  "description": "Generic LLM gateway model provider plugin for DeepSeek Harness: mounts newapi / LiteLLM / Higress / any OpenAI-compatible gateway as provider routes, auto-discovers the model list, enriches every model with models.dev parameters, and dispatches each model over its native wire protocol (OpenAI / Anthropic / Gemini) via the pi-ai SDK",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "cordis.patch.yml"
+  ],
+  "scripts": {
+    "link": "bash scripts/link.sh",
+    "smoke": "node test/smoke.mjs",
+    "test:client": "node test/client-render.mjs",
+    "test:urls": "node test/protocol-urls.mjs"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "cordis",
+    "llm",
+    "llm-provider",
+    "provider",
+    "newapi",
+    "new-api",
+    "openai",
+    "anthropic",
+    "gemini",
+    "models.dev",
+    "dsh-plugin",
+    "pi-ai"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-web-react"
+      ],
+      "platform": "web"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-anonymous-user-id": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@earendil-works/pi-ai": "^0.82.1"
+  }
+}