@rebon/cli-darwin-arm64 0.17.3 → 0.19.0

package/bin/compose-runtime/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@rebon/compose-runtime",
+  "version": "0.0.0-private",
+  "private": true,
+  "type": "module",
+  "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=24.19.0 <25"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "exports": {
+    ".": "./src/index.mjs",
+    "./control": "./src/plugin.mjs"
+  }
+}

package/bin/compose-runtime/payload/compose/credentials-runtime.js

@@ -0,0 +1,38 @@
+// dsh-compatible `ctx.credentials` seat for the composition host.
+//
+// dsh configuration carries credential *references* (environment-variable
+// names); the provider owns the values. This provider resolves a reference
+// through the kernel's fail-closed `credentials` JSON service (`resolveEnv`
+// runs the `credentials/authorize` waterfall before touching the
+// environment), so an unauthorized or unset reference is simply "absent" —
+// the consumer's own missing-credential diagnosis then fires (dsh-llm's
+// `MISSING_CREDENTIAL`), instead of this seat inventing one.
+import { Service } from 'cordis';
+import { callService } from 'rebon';
+
+export default class RebonCredentials extends Service {
+  constructor(ctx) {
+    super(ctx, 'credentials');
+  }
+
+  /** dsh CredentialProvider.resolve: `{value, source}` or undefined. */
+  async resolve(ref) {
+    try {
+      const out = callService('credentials', 'resolveEnv', { ref: String(ref) });
+      const value = out?.value;
+      if (typeof value === 'string' && value.length > 0) {
+        return { value, source: 'env' };
+      }
+    } catch {
+      // Fail-closed kernel refusal (no authorizer, unset variable, bad ref)
+      // all read as "not configured here".
+    }
+    return undefined;
+  }
+
+  /** dsh CredentialProvider.describe: facts only, never the value. */
+  async describe(ref) {
+    const hit = await this.resolve(ref);
+    return { configured: hit !== undefined, ...(hit ? { source: hit.source } : {}), writable: false };
+  }
+}

package/bin/compose-runtime/payload/compose/llm-runtime.js

@@ -0,0 +1,330 @@
+// Minimal dsh-compatible `ctx.llm` seat for the composition host.
+//
+// API shape follows dsh packages/llm: adapters extend `LlmAdapter` (only
+// `stream(options)` is required) and register with
+// `ctx.llm.registerAdapter(providers, adapter)`. Each registered route is
+// mirrored into the kernel's model-router table (catalog fetched via the
+// adapter's advisory `listModels`), and `llm/adapter-registered` /
+// `llm/adapter-unregistered` kernel events let the Rust side bind this
+// composition as the route's stream host. Model requests arrive over the
+// host's llm ops (`op_llm_next`) and are dispatched to the owning adapter;
+// cancellation aborts the per-request AbortController.
+import { Service } from 'cordis';
+import { callService, emit } from 'rebon';
+import {
+  LlmError,
+  deepFreeze,
+  callConfigEquals,
+  errorChain,
+  resolveRetryPolicy,
+} from './shims/dsh-llm.js';
+// The base class every provider plugin extends. Re-exported here because
+// that is where dsh consumers have always imported it from; it is defined
+// apart from this module so importing it does not drag a host's transport in.
+export { LlmAdapter } from './shims/llm-adapter.js';
+
+const core = globalThis.Deno.core;
+
+/**
+ * Normalize an adapter throw into dsh's terminal finish chunk
+ * (`adapterFailureChunk`, transcribed lean: LlmError keeps its facts,
+ * anything else flattens under UNKNOWN — the same rule the loop itself
+ * applies at its turn boundary).
+ */
+function failureChunk(error, signal) {
+  const failure = error instanceof LlmError
+    ? error.failure
+    : { message: errorChain(error), code: 'UNKNOWN' };
+  return {
+    type: 'finish',
+    reason: signal?.aborted || failure.code === 'ABORTED'
+      ? { kind: 'aborted', failure }
+      : { kind: 'error', failure },
+  };
+}
+
+
+export default class RebonLlmRuntime extends Service {
+  constructor(ctx, config) {
+    super(ctx, 'llm');
+    this.routes = new Map(); // provider -> adapter
+    this.aborts = new Map(); // stream id -> AbortController
+    // Per-loop hosts serve only in-composition consumers: no process-plane
+    // mirror, no adapter events (a process binding acting on them would
+    // tear down routes the shared composition still serves).
+    this.announce = config?.announce !== false;
+    void this._pump();
+  }
+
+  registerAdapter(providers, adapter) {
+    if (!providers?.length) {
+      throw new Error('an adapter must register at least one provider');
+    }
+    for (const provider of providers) {
+      if (this.routes.has(provider)) {
+        throw new Error(`an adapter for provider "${provider}" is already registered`);
+      }
+    }
+    const runtime = this;
+    // Owner captured in the synchronous half: _announce runs async, and
+    // by then the registering context must already be pinned down.
+    const owner = this.ctx[Symbol.for('rebon.composeOwner')] ?? '';
+    this.ctx.effect(() => {
+      for (const provider of providers) {
+        runtime.routes.set(provider, adapter);
+        if (runtime.announce) void runtime._announce(provider, adapter, owner);
+      }
+      return () => {
+        for (const provider of providers) {
+          runtime.routes.delete(provider);
+          if (!runtime.announce) continue;
+          try {
+            callService('model-router', 'unregister', { provider });
+          } catch {}
+          emit('llm/adapter-unregistered', { provider });
+        }
+      };
+    });
+    // dsh handle shape: route replacement exists on it, but a static
+    // composition never re-reads registration facts, so a call here is a
+    // consumer bug — refuse loudly instead of silently diverging from dsh.
+    return {
+      providers: [...providers],
+      replace() {
+        throw new Error('adapter route replacement is not supported in a static composition');
+      },
+    };
+  }
+
+  /**
+   * dsh surfaces these entries to its settings UI. The embedded runtime has
+   * no such surface; record them so diagnostics can list what a composition
+   * declared, and accept the call so unmodified dsh plugins load.
+   */
+  registerConfigurableProviders(entries) {
+    this.configurableProviders ??= [];
+    for (const entry of entries ?? []) {
+      if (entry?.provider) {
+        this.configurableProviders.push({
+          provider: String(entry.provider),
+          displayName: entry.displayName === undefined ? undefined : String(entry.displayName),
+        });
+      }
+    }
+  }
+
+  // ---- JS consumer face (loop round) ----
+  //
+  // The pump below serves REQUESTS FROM RUST; the two methods here serve
+  // consumers INSIDE the composition (the agent loop). Routing is the same
+  // in-JS adapter table. v1 honesty boundary: no `llm/stream` middleware
+  // waterfall — dispatch goes straight to the owning adapter.
+
+  /** Resolve the owning adapter or refuse with dsh's NO_ADAPTER code. */
+  _registration(provider) {
+    const adapter = this.routes.get(provider);
+    if (!adapter) {
+      throw new LlmError(`no adapter registered for provider "${provider}"`, 'NO_ADAPTER');
+    }
+    return adapter;
+  }
+
+  /**
+   * dsh `LlmRuntime.prepareCall`, transcribed: resolve the route's exact
+   * model, materialize adapter defaults (recorded in `adapterDefaults` so
+   * the loop's request header can re-resolve them later), and hand back a
+   * one-shot stream bound to this registration.
+   */
+  async prepareCall(config, signal) {
+    const adapter = this._registration(config.provider);
+    const info = (await adapter.resolveModel(config.provider, config.model)) ?? {};
+    signal?.throwIfAborted?.();
+    const defaulted = config.maxTokens === undefined && info.defaultMaxTokens !== undefined
+      ? { ...config, maxTokens: info.defaultMaxTokens }
+      : config;
+    const reasoning = info.reasoning;
+    const requested = defaulted.reasoningEffort;
+    let resolvedConfig = defaulted;
+    if (reasoning === undefined) {
+      if (requested !== undefined) {
+        throw new LlmError(
+          `provider "${config.provider}" model "${config.model}" does not support reasoning effort "${requested}"`,
+          'UNSUPPORTED_REASONING_EFFORT',
+        );
+      }
+    } else {
+      const effective = requested ?? reasoning.defaultEffort;
+      if (effective !== undefined) {
+        if (!(reasoning.efforts ?? []).some((effort) => effort.id === effective)) {
+          throw new LlmError(
+            `provider "${config.provider}" model "${config.model}" does not support reasoning effort "${effective}"`,
+            'UNSUPPORTED_REASONING_EFFORT',
+          );
+        }
+        if (requested !== effective) resolvedConfig = { ...defaulted, reasoningEffort: effective };
+      }
+    }
+    const frozen = deepFreeze(structuredClone(resolvedConfig));
+    const context = info.context === undefined
+      ? undefined
+      : deepFreeze(structuredClone(info.context));
+    const adapterDefaults = deepFreeze({
+      ...(config.reasoningEffort === undefined && frozen.reasoningEffort !== undefined
+        ? { reasoningEffort: true }
+        : {}),
+      ...(config.maxTokens === undefined && frozen.maxTokens !== undefined
+        ? { maxTokens: true }
+        : {}),
+    });
+    const runtime = this;
+    let dispatched = false;
+    return Object.freeze({
+      config: frozen,
+      // dsh contract: providerRetryPolicy returns an ALREADY-RESOLVED
+      // policy (or undefined for the normal defaults) — never re-resolve.
+      retryPolicy: adapter.providerRetryPolicy(config.provider)
+        ?? resolveRetryPolicy(undefined, `llm: provider "${config.provider}" retryPolicy`),
+      adapterDefaults,
+      ...(context === undefined ? {} : { context }),
+      stream(options) {
+        if (dispatched) {
+          throw new LlmError('a prepared LLM call can only be dispatched once', 'INVALID_PREPARED_CALL');
+        }
+        if (!callConfigEquals(options, frozen)) {
+          throw new LlmError('prepared LLM call config changed before adapter dispatch', 'INVALID_PREPARED_CALL');
+        }
+        dispatched = true;
+        return runtime._consumerStream(options);
+      },
+    });
+  }
+
+  /** Consumer fallback entry (the loop's NO_ADAPTER path): direct dispatch. */
+  stream(options) {
+    return this._consumerStream(options);
+  }
+
+  /**
+   * Adapter boundary for in-composition consumers: selection, dispatch, and
+   * iteration failures become one terminal failure chunk (dsh
+   * `adapterStream` semantics) so the loop's assembler/request-error path
+   * sees them instead of a raw throw.
+   */
+  async *_consumerStream(options) {
+    let iterator;
+    try {
+      const adapter = this._registration(options.provider);
+      iterator = adapter.stream(options)[Symbol.asyncIterator]();
+    } catch (error) {
+      yield failureChunk(error, options.signal);
+      return;
+    }
+    while (true) {
+      let item;
+      try {
+        item = await iterator.next();
+      } catch (error) {
+        yield failureChunk(error, options.signal);
+        return;
+      }
+      if (item.done) return;
+      yield item.value;
+    }
+  }
+
+  /**
+   * Mirror one route into the kernel table, catalog included (advisory).
+   *
+   * `listModels` is an adapter call that can take as long as a network
+   * round-trip, and an unload may complete inside that await — the effect's
+   * disposer having already issued the compensating `unregister`. Announcing
+   * afterwards would resurrect the route of a plugin that is gone, with
+   * nothing left to tear it down. The route table is the liveness witness:
+   * the disposer deletes this provider's entry, so anything but our own
+   * adapter still sitting there means the registration we are announcing is
+   * no longer the live one.
+   */
+  async _announce(provider, adapter, owner = '') {
+    let models = [];
+    try {
+      models = (await adapter.listModels(provider)) ?? [];
+    } catch {}
+    if (this.routes.get(provider) !== adapter) return;
+    const entries = models
+      .filter((m) => m?.id)
+      .map((m) => ({ id: m.id, contextWindow: m.context?.window ?? m.contextWindow }));
+    try {
+      callService('model-router', 'register', {
+        provider,
+        models: entries,
+        // The catalog is advisory (dsh semantics): with an empty one the
+        // route still exists and callers name models explicitly; "default"
+        // is only the resolve fallback for bare `{provider}` lookups.
+        defaultModel: entries[0]?.id ?? 'default',
+      }, owner);
+    } catch (e) {
+      emit('llm/adapter-error', { provider, error: String(e?.message ?? e) });
+      return;
+    }
+    emit('llm/adapter-registered', { provider });
+  }
+
+  /** Host instruction loop: dispatch requests, abort on cancel. */
+  async _pump() {
+    while (true) {
+      const instr = JSON.parse(await core.ops.op_llm_next());
+      if (instr.closed) break;
+      if (instr.kind === 'cancel') {
+        this.aborts.get(instr.id)?.abort();
+        continue;
+      }
+      void this._dispatch(instr.id, instr.request);
+    }
+  }
+
+  async _dispatch(id, request) {
+    const send = (obj) => core.ops.op_llm_emit(id, JSON.stringify(obj));
+    const adapter = this.routes.get(request.provider);
+    if (!adapter) {
+      send({ err: `no adapter registered for provider route "${request.provider}"` });
+      return;
+    }
+    const controller = new AbortController();
+    this.aborts.set(id, controller);
+    try {
+      const options = {
+        provider: request.provider,
+        model: request.model,
+        messages: request.messages ?? [],
+        system: request.system ?? undefined,
+        tools: request.tools ?? undefined,
+        maxTokens: request.maxTokens ?? undefined,
+        temperature: request.temperature ?? undefined,
+        stop: request.stop ?? undefined,
+        reasoningEffort: request.reasoningEffort ?? undefined,
+        sessionId: request.sessionId ?? undefined,
+        purpose: request.purpose ?? undefined,
+        signal: controller.signal,
+      };
+      for await (const chunk of adapter.stream(options)) {
+        send({ chunk });
+      }
+      send({ done: true });
+    } catch (e) {
+      // dsh contract: an adapter may throw on abort; normalize either way.
+      if (controller.signal.aborted) {
+        send({ chunk: { type: 'finish', reason: 'aborted' } });
+        send({ done: true });
+      } else {
+        // LlmError carries a stable machine code beside the message —
+        // surface it so the Rust side can route/report on it.
+        send({
+          err: String(e?.message ?? e),
+          ...(typeof e?.code === 'string' && e.code.length > 0 ? { code: e.code } : {}),
+        });
+      }
+    } finally {
+      this.aborts.delete(id);
+    }
+  }
+}

package/bin/compose-runtime/payload/compose/loop-assembly.js

@@ -0,0 +1,149 @@
+// rebon-loop-assembly: the composition-side glue that lets the REAL
+// dsh-agent-loop drive a turn inside this isolate (assembly doc:
+// docs/dsh-agent-loop-assembly.md §4).
+//
+// Three duties, all rebon-owned (the dsh packages stay unmodified):
+//  1. Tool-schema supply: registers a dsh systemPrompt tool provider that
+//     merges the composition's own registered definitions with the R5 core
+//     seat catalog (describeTools) — the same two sources the tools seat's
+//     scheduler dispatches into, so model-visible and dispatchable stay in
+//     step (local definition shadows a seat name in BOTH places).
+//  2. Observability: relays every dsh `session/event` (chunks included —
+//     the embedder's session face streams from them) and `agent/error`
+//     onto the kernel event plane (`loop:event` / `loop:agent-error`),
+//     stamped with the embedder's `tag` so co-resident loop hosts stay
+//     distinguishable.
+//  3. Drive: `loop:control` serve target (followup/steer/cancel/status)
+//     is the embedder's inbound face; config `{kickoff: "..."}` remains as
+//     an e2e self-drive convenience.
+import { emit, describeTools, logger } from 'rebon';
+import { createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
+import { registerServeTarget } from './serve-dispatch.js';
+
+/** Best-effort warn: the kernel logger seat is optional (tools-runtime rule). */
+function warn(message) {
+  try {
+    logger.warn(message);
+  } catch {
+    console.warn(message);
+  }
+}
+
+export const name = 'rebon-loop-assembly';
+export const inject = ['systemPrompt', 'tools'];
+
+export async function apply(ctx, config = {}) {
+  // Embedder-chosen discriminator: with several loop hosts in one process,
+  // every relayed event carries the owning host's tag so kernel-plane
+  // subscribers can tell their loop apart.
+  const tag = typeof config.tag === 'string' && config.tag.length > 0 ? config.tag : undefined;
+  const stamp = (payload) => (tag === undefined ? payload : { tag, ...payload });
+  // Optional prompt contribution into the loop realm's REAL dsh
+  // systemPrompt (this is the loop's own prompt plane, not rebon's P2.8
+  // seat — the isolate keeps them apart).
+  if (config.section !== undefined && config.section !== null && typeof config.section === 'object') {
+    ctx.systemPrompt.section(config.section);
+  }
+
+  let seatSchemas = [];
+  try {
+    const catalog = await describeTools();
+    seatSchemas = (Array.isArray(catalog) ? catalog : []).map((tool) => ({
+      name: tool.name,
+      description: String(tool.description ?? ''),
+      parameters: tool.inputSchema ?? { type: 'object' },
+    }));
+  } catch (error) {
+    // An unbound tool plane is a legal composition (prompt-only loop); the
+    // schemas face is then just the composition's own registrations.
+    warn(`loop-assembly: R5 seat catalog unavailable: ${String(error?.message ?? error)}`);
+  }
+
+  ctx.systemPrompt.tools(() => {
+    const merged = new Map();
+    for (const schema of seatSchemas) merged.set(schema.name, schema);
+    for (const [toolName, def] of ctx.tools.defs) {
+      merged.set(toolName, {
+        name: toolName,
+        description: String(def.description ?? ''),
+        parameters: def.parameters ?? { type: 'object' },
+      });
+    }
+    return { schemas: [...merged.values()] };
+  });
+
+  // Full-fidelity relay: the dsh session log IS the loop's truth, and the
+  // embedder's session face (streaming UI, transcript projection) needs
+  // every event — chunks included.
+  ctx.on('session/event', (session, event) => {
+    emit('loop:event', stamp({
+      sessionId: String(session.id),
+      seq: event.seq,
+      type: event.type,
+      data: event.data ?? null,
+    }));
+  });
+
+  ctx.on('agent/error', (payload) => {
+    emit('loop:agent-error', stamp({
+      agentId: String(payload.agent?.id ?? ''),
+      turn: payload.turn,
+      step: payload.step,
+      error: errorChain(payload.error),
+    }));
+  });
+
+  const live = new Map();
+  const kicked = new Set();
+  ctx.on('agent/created', ({ agent }) => {
+    live.set(String(agent.id), agent);
+    emit('loop:agent-created', stamp({ agentId: String(agent.id) }));
+    const kickoff = config.kickoff;
+    if (typeof kickoff !== 'string' || kickoff.length === 0) return;
+    if (kicked.has(agent.id)) return;
+    kicked.add(agent.id);
+    agent.followup(createUserMessage({
+      content: [{ type: 'text', text: kickoff }],
+      source: { kind: 'user' },
+    }));
+  });
+  ctx.on('agent/disposed', ({ agent }) => {
+    live.delete(String(agent.id));
+  });
+
+  // Inbound control face: the embedder drives the loop over the serve
+  // plane (request/response — the same plane rebon uses to call
+  // composition tools). Commands address the single configured agent by
+  // default, or a specific one via `agentId`.
+  const resolveAgent = (input) => {
+    if (typeof input?.agentId === 'string') return live.get(input.agentId);
+    if (live.size === 1) return live.values().next().value;
+    return undefined;
+  };
+  const userMessage = (text) => createUserMessage({
+    content: [{ type: 'text', text: String(text) }],
+    source: { kind: 'user' },
+  });
+  registerServeTarget('loop:control', (input) => {
+    const agent = resolveAgent(input);
+    if (agent === undefined) {
+      const known = [...live.keys()];
+      throw new Error(`loop:control: no live agent${input?.agentId ? ` "${input.agentId}"` : ''} (live: ${known.join(', ') || '(none)'})`);
+    }
+    switch (input?.kind) {
+      case 'followup':
+        agent.followup(userMessage(input.text ?? ''));
+        return { accepted: true, agentId: String(agent.id) };
+      case 'steer':
+        agent.steer(userMessage(input.text ?? ''));
+        return { accepted: true, agentId: String(agent.id) };
+      case 'cancel':
+        agent.cancel({ kind: 'user' });
+        return { accepted: true, agentId: String(agent.id) };
+      case 'status':
+        return { agentId: String(agent.id), status: agent.status };
+      default:
+        throw new Error(`loop:control: unknown command kind ${JSON.stringify(input?.kind)}`);
+    }
+  });
+}

package/bin/compose-runtime/payload/compose/serve-dispatch.js

@@ -0,0 +1,82 @@
+// Shared serve pump over the tool-serve ops (P1.6/P2.7): one pump per
+// composition isolate, exact-name target dispatch. The tools seat registers
+// each tool under its own name; the web seat registers providers under the
+// reserved `web:<kind>:<id>` namespace. Handlers run concurrently (one slow
+// call never head-of-line blocks the pump); `cancel` aborts the per-call
+// AbortController.
+//
+// Envelope contract with the Rust side: `{ok: <handler return>}` on
+// success; `{err: message, code?}` on throw (a thrown `code` property —
+// dsh WebError/HarnessError — rides along for machine routing).
+
+const core = globalThis.Deno.core;
+
+const targets = new Map(); // target name -> async (input, signal, id) => value
+const aborts = new Map(); // serve call id -> AbortController
+let pumping = false;
+
+/**
+ * Register one serve target. Exact-name dispatch; duplicates throw. Returns
+ * the disposer.
+ */
+export function registerServeTarget(name, handler) {
+  if (targets.has(name)) {
+    throw new Error(`serve target "${name}" is already registered`);
+  }
+  targets.set(name, handler);
+  return () => targets.delete(name);
+}
+
+/** Start the pump once; later calls are no-ops. */
+export function ensureServePump() {
+  if (pumping) return;
+  pumping = true;
+  void pump();
+}
+
+async function pump() {
+  while (true) {
+    const instr = JSON.parse(await core.ops.op_tool_serve_next());
+    if (instr.closed) break;
+    if (instr.kind === 'cancel') {
+      aborts.get(instr.id)?.abort();
+      continue;
+    }
+    if (instr.kind !== 'request') continue;
+    void serve(instr.id, instr.tool, instr.input);
+  }
+}
+
+async function serve(id, target, input) {
+  const handler = targets.get(target);
+  if (!handler) {
+    emitEnvelope(id, {
+      err: `[UNKNOWN_TOOL] target "${target}" is not registered in the composition`,
+    });
+    return;
+  }
+  const abort = new AbortController();
+  aborts.set(id, abort);
+  try {
+    const value = await handler(input, abort.signal, id);
+    emitEnvelope(id, { ok: value });
+  } catch (e) {
+    emitEnvelope(id, {
+      err: String(e?.message ?? e),
+      ...(typeof e?.code === 'string' ? { code: e.code } : {}),
+    });
+  } finally {
+    aborts.delete(id);
+  }
+}
+
+function emitEnvelope(id, envelope) {
+  try {
+    core.ops.op_tool_serve_emit(id, JSON.stringify(envelope));
+  } catch (e) {
+    core.ops.op_tool_serve_emit(
+      id,
+      JSON.stringify({ err: `serve result not serializable: ${String(e?.message ?? e)}` }),
+    );
+  }
+}

package/bin/compose-runtime/payload/compose/shims/dsh-anonymous-user-id.js

@@ -0,0 +1,10 @@
+// Embedded-runtime shim of `@deepseek-ai/dsh-anonymous-user-id`.
+//
+// The real package persists a random id under the dsh home for telemetry
+// correlation. The embedded runtime is not a dsh install and keeps no dsh
+// home; a fixed marker keeps the (harmless, non-secret) telemetry header
+// shape intact while identifying the traffic as rebon-embedded.
+
+export function getOrCreateAnonymousUserId() {
+  return 'rebon-embedded';
+}

package/bin/compose-runtime/payload/compose/shims/dsh-credentials.js

@@ -0,0 +1,13 @@
+// Embedded-runtime shim of `@deepseek-ai/dsh-credentials` (runtime surface
+// only). The credentials *service* itself is the composition host's
+// credentials-runtime.js seat; consumers reach it via `ctx.get('credentials')`.
+
+const REF_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/** Brand a raw string as a CredentialRef (a POSIX environment-variable name). */
+export function credentialRef(value) {
+  if (!REF_PATTERN.test(value)) {
+    throw new TypeError(`credential ref "${value}" must match ${String(REF_PATTERN)}`);
+  }
+  return value;
+}

package/bin/compose-runtime/payload/compose/shims/dsh-launch-environment.js

@@ -0,0 +1,21 @@
+// Embedded-runtime shim of `@deepseek-ai/dsh-launch-environment`.
+//
+// The embedded composition deliberately exposes NO ambient environment to
+// plugins: every credential goes through the fail-closed credentials seat,
+// and connection facts come from plugin config. An always-empty snapshot
+// makes each consumer take its documented fallback (dsh-llm-deepseek's
+// baseURL falls to the public API; its ambient-key branch never wins because
+// the credentials seat is mounted).
+
+const EMPTY_SNAPSHOT = Object.freeze({
+  get: (_name) => undefined,
+  getFrom: (_name, _sources) => undefined,
+});
+
+/** The launcher snapshot for this run: embedded hosts provide none. */
+export function launchEnvironmentOf(_ctx) {
+  return EMPTY_SNAPSHOT;
+}
+
+/** Context slot name the real launcher fills; exported for API parity. */
+export const DSH_LAUNCH_ENVIRONMENT_KEY = 'launchEnvironment';