dsh-loop-engine 0.1.5-rc4 → 0.1.5-rc5

package/lib/index.js

@@ -685,6 +685,9 @@ function sessionModelOverrideOf(ctx, session) {
 }
 
 // src/driver-core/model-handover.ts
+var SHIPPED_ROUTE_APIS = {
+  "deepseek-official": "openai-completions"
+};
 var warned = /* @__PURE__ */ new WeakMap();
 function warnOnce(ctx, key, message) {
   let seen = warned.get(ctx);
@@ -711,10 +714,9 @@ function readProviderProfile(ctx, address) {
   const record = node;
   const { baseURL, api, apiKeyEnv } = record;
   if (typeof baseURL !== "string" || baseURL.length === 0) return void 0;
-  if (typeof api !== "string" || api.length === 0) return void 0;
   return {
     baseURL,
-    api,
+    api: typeof api === "string" && api.length > 0 ? api : void 0,
     apiKeyEnv: typeof apiKeyEnv === "string" && apiKeyEnv.length > 0 ? apiKeyEnv : void 0
   };
 }
@@ -734,7 +736,7 @@ async function resolveModelHandover(ctx, override) {
   }
   const profile = readProviderProfile(ctx, address);
   if (profile === void 0) {
-    return refuse(ctx, override, `the "${address.settingsNs}" settings section names no baseURL and wire protocol for it`);
+    return refuse(ctx, override, `the "${address.settingsNs}" settings section names no baseURL for it`);
   }
   const apiKey = await readApiKey(ctx, profile.apiKeyEnv);
   if (apiKey === void 0) {
@@ -744,7 +746,7 @@ async function resolveModelHandover(ctx, override) {
     provider: override.provider,
     model: override.model,
     baseURL: profile.baseURL,
-    api: profile.api,
+    api: profile.api ?? SHIPPED_ROUTE_APIS[override.provider],
     apiKey
   };
 }
@@ -2333,15 +2335,15 @@ import { canonicalHeader as canonicalHeader2 } from "@deepseek-ai/dsh-session";
 var CODEX_DSH_PROVIDER = "dsh";
 var CODEX_DSH_API_KEY_ENV = "DSH_LOOP_ENGINE_API_KEY";
 var CODEX_WIRE_APIS = {
-  "openai-responses": "responses",
-  "openai-completions": "chat"
+  "openai-responses": "responses"
 };
 function tomlString(value) {
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 }
 function codexModelConfig(handover) {
-  const wire = CODEX_WIRE_APIS[handover.api];
+  const wire = handover.api === void 0 ? void 0 : CODEX_WIRE_APIS[handover.api];
   const profile = [
+    `name=${tomlString(CODEX_DSH_PROVIDER)}`,
     `base_url=${tomlString(handover.baseURL)}`,
     ...wire === void 0 ? [] : [`wire_api=${tomlString(wire)}`],
     `env_key=${tomlString(CODEX_DSH_API_KEY_ENV)}`
@@ -4325,10 +4327,11 @@ var PiAgent = class {
     }
     this.assertRequestHeader();
     signal.throwIfAborted();
-    const handover = await resolveModelHandover(
+    const resolved = await resolveModelHandover(
       this.loopCtx,
       sessionModelOverrideOf(this.loopCtx, this.session)
     );
+    const handover = resolved?.api === void 0 ? void 0 : resolved;
     const controller = new AbortController();
     const cancel = () => {
       if (!controller.signal.aborted) {
@@ -4685,7 +4688,7 @@ var KIMI_PROVIDER_TYPES = {
   "openai-responses": "openai"
 };
 function kimiModelEnv(handover) {
-  const type = KIMI_PROVIDER_TYPES[handover.api];
+  const type = handover.api === void 0 ? void 0 : KIMI_PROVIDER_TYPES[handover.api];
   return {
     KIMI_MODEL_NAME: handover.model,
     KIMI_MODEL_API_KEY: handover.apiKey,

package/lib/types/driver-core/model-handover.d.ts

@@ -32,6 +32,11 @@
  * and never a guess. The warning names the provider and the model, never a
  * credential.
  *
+ * What counts as "recognized" is deliberately narrow: a non-empty `baseURL` and
+ * a resolvable credential. The wire protocol is handed over when the deployment
+ * declares one, but its absence does NOT refuse the handover — see
+ * {@link resolveModelHandover} and {@link SHIPPED_ROUTE_APIS}.
+ *
  * @module dsh-loop-engine/driver-core/model-handover
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -54,8 +59,13 @@ export interface DshModelHandover {
     readonly model: string;
     /** Endpoint base as dsh configured it. */
     readonly baseURL: string;
-    /** dsh's wire protocol name for this endpoint. */
-    readonly api: string;
+    /**
+     * dsh's wire protocol name for this endpoint, when the deployment declares
+     * one (or {@link SHIPPED_ROUTE_APIS} knows it for a shipped route). `undefined`
+     * is a normal answer, not a failure: engines that need a protocol degrade the
+     * way each one documents, and engines that do not (`claude-code`) ignore it.
+     */
+    readonly api: string | undefined;
     /** The resolved credential value; never logged, never evented. */
     readonly apiKey: string;
 }
@@ -102,8 +112,16 @@ export interface CredentialsService {
  * `undefined` is the answer in exactly two situations: the selection names no
  * real dsh model ({@link SessionModelOverride} is already `undefined` for the
  * hosted seat), or a real model whose endpoint/credential dsh does not disclose
- * to this read. The second case warns once — it is a deployment-shape gap the
- * operator can see and fix, not a silent downgrade.
+ * to this read — no `baseURL`, or no credential. Both warn once: they are
+ * deployment-shape gaps the operator can see and fix, not a silent downgrade.
+ *
+ * The wire protocol is NOT such a gate. A profile that names no `api` still
+ * hands over its endpoint (with `api: undefined`), because refusing would let
+ * the engine send dsh's model id to the engine's OWN endpoint — a failure that
+ * reads like an auth or model problem while the real one is "wrong endpoint".
+ * Shipped routes whose adapter owns the wire are named in
+ * {@link SHIPPED_ROUTE_APIS} so they hand over a real protocol; anything still
+ * unknown degrades per engine, which is the engine's call to make.
  *
  * Called fresh on every step by each driver, so a model or provider picked
  * mid-conversation reaches the engine's next request rather than being frozen

package/lib/types/engine-codex/model-handover.d.ts

@@ -3,17 +3,28 @@
  * overrides and environment that point it at dsh's model.
  *
  * Codex resolves a custom endpoint through `model_providers.<id>` in its own
- * `config.toml` (`base_url`, `wire_api`, and an `env_key` naming the variable
- * the credential is read from), and `codex app-server` accepts those as `-c
- * key=value` overrides — so the handover needs no edit of `~/.codex`. The
+ * `config.toml` (`name`, `base_url`, `wire_api`, and an `env_key` naming the
+ * variable the credential is read from), and `codex app-server` accepts those as
+ * `-c key=value` overrides — so the handover needs no edit of `~/.codex`. The
  * credential travels in the child's environment under {@link CODEX_DSH_API_KEY_ENV},
  * which the `env_key` names.
  *
- * Codex speaks only OpenAI's wires (`responses` or `chat`). A dsh protocol with
- * no codex equivalent (Anthropic Messages) is NOT guessed: `wire_api` is
- * omitted, so codex uses its own default wire against dsh's base URL and fails
- * loud on the request — the honest outcome, since the plugin cannot make codex
- * speak a protocol it does not implement.
+ * `name` is not optional in practice even though the CLI's own docs describe it
+ * as display metadata: codex 0.149.1 (the version this plugin pins) refuses to
+ * load a provider whose `name` is empty — "provider name must not be empty in
+ * `model_providers`" — and that config error kills `app-server` on startup, which
+ * the driver can only report as "process exited unexpectedly". Omitting it looked
+ * correct and failed before any request was ever sent, so every override this
+ * module builds carries it (verified against the pinned binary).
+ *
+ * Codex speaks only OpenAI's `responses` wire as of the version this plugin pins
+ * (0.149.1 dropped `chat`). A dsh protocol with no codex equivalent (Anthropic
+ * Messages, and now OpenAI Chat Completions) is NOT guessed: `wire_api` is
+ * omitted, so codex falls back to its own default wire and fails loud on the
+ * request — the honest outcome, since the plugin cannot make codex speak a
+ * protocol it does not implement. That default is `responses` as of 0.149.1: the
+ * request lands on `<baseURL>/responses`, which an Anthropic Messages or Chat
+ * Completions endpoint does not serve.
  *
  * @module dsh-loop-engine/engine-codex/model-handover
  */
@@ -36,7 +47,8 @@ export interface CodexModelConfig {
  * The provider id ({@link CODEX_DSH_PROVIDER}) is a plugin-owned name: it exists
  * only in this child's command line, so it cannot collide with a provider the
  * user configured, and the model itself is still handed over as the thread's own
- * `model` param.
+ * `model` param. The provider's `name` repeats that id because codex rejects an
+ * empty one at config load, before any request is made.
  * @param handover - the resolved dsh endpoint for the session's selection.
  * @returns the argv entries and environment to spawn the app-server with.
  */

package/lib/types/engine-pi/model-handover.d.ts

@@ -17,6 +17,10 @@
  * user's own `~/.pi` skills/auth/theme. That is the trade the deployment makes
  * by selecting a real dsh model on pi.
  *
+ * pi's provider schema requires a wire protocol (`api`), so this is the one
+ * engine that cannot express a handover without one; the driver drops such a
+ * handover before it reaches here instead of writing a file pi rejects.
+ *
  * @module dsh-loop-engine/engine-pi/model-handover
  */
 import type { DshModelHandover } from '../driver-core/model-handover.ts';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-loop-engine",
   "description": "Web-switchable agent loop engine selection for the DeepSeek Harness - out-of-tree plugin (Claude Code / Codex / Pi / Kimi Code drivers) maintained by @kuun993, zero main-repo changes",
-  "version": "0.1.5-rc4",
+  "version": "0.1.5-rc5",
   "publishConfig": {
     "access": "public"
   },