@rebon/cli-linux-x64 0.17.3 → 0.18.0

package/bin/compose-runtime/payload-manifests.json

@@ -0,0 +1,48 @@
+{
+  "version": 1,
+  "note": "What rebon declares on behalf of the packages it ships. Every plugin on the plane loads against a manifest — the ceiling on what it may register and reach — and a third-party package declares its own under `capabilities.kernelPlugins` in its `rebon-plugin.json`. These packages are vendored into rebon's payload, so rebon is the one that has to say what they do. `root` names which package the `entry` is relative to. It defaults to `package`, which in this table means the vendored JS tree an entry belongs to; `payload` says the same thing explicitly, and `runtime` names the composition runtime itself. `invokableTools: \"$rebon/tools\"` expands to every tool this build exposes to the plane — the honest declaration for a plugin that runs whatever tool a model picks.",
+  "packages": {
+    "cordis": { "entry": "vendor/cordis/index.js" },
+    "@deepseek-ai/cordis-plugin-timer": { "entry": "vendor/dsh/timer.js" },
+    "@deepseek-ai/cordis-plugin-logger-console": { "entry": "vendor/dsh/logger-console.js" },
+
+    "@deepseek-ai/dsh-llm-deepseek": {
+      "entry": "vendor/dsh/llm-deepseek.js",
+      "llmProviders": ["deepseek-official"],
+      "seats": ["credentials"]
+    },
+    "@deepseek-ai/dsh-tool-todo": {
+      "entry": "vendor/dsh/tool-todo.js",
+      "tools": ["todo_write"],
+      "publishedTopics": ["compose:session/append"]
+    },
+    "@deepseek-ai/dsh-tool-web": {
+      "entry": "vendor/dsh/tool-web.js",
+      "tools": ["web_search", "web_fetch"],
+      "invokableTools": ["WebSearch", "WebFetch"],
+      "publishedTopics": ["compose:session/append"]
+    },
+    "@deepseek-ai/dsh-web-search-exa": {
+      "entry": "vendor/dsh/web-search-exa.js",
+      "services": ["web:search:exa"],
+      "seats": ["credentials"]
+    },
+
+    "@deepseek-ai/dsh-session": { "entry": "vendor/dsh/session.js" },
+    "@deepseek-ai/dsh-agent": { "entry": "vendor/dsh/agent.js" },
+    "@deepseek-ai/dsh-system-prompt": { "entry": "vendor/dsh/system-prompt.js" },
+    "@deepseek-ai/dsh-agent-loop": {
+      "entry": "vendor/dsh/agent-loop.js",
+      "invokableTools": "$rebon/tools",
+      "seats": ["credentials"]
+    },
+
+    "rebon-loop-assembly": {
+      "root": "runtime",
+      "entry": "src/loop-assembly.mjs",
+      "services": ["loop:control"],
+      "publishedTopics": ["loop:event", "loop:agent-error", "loop:agent-created"],
+      "seats": ["logger"]
+    }
+  }
+}

package/bin/compose-runtime/src/bridge.mjs

@@ -0,0 +1,142 @@
+// The composition's doorway to rebon, on the plugin plane.
+//
+// On deno_core this was `js/bridge.js`: seven synchronous ops reaching a
+// kernel that lived in the same process. Across a process boundary none of
+// that survives unchanged, and the differences are the protocol's, not this
+// module's:
+//
+//   * **Everything is async.** `callService` returned a value from an op; a
+//     `seat/call` is a request that has to be answered. The one place this
+//     bites is a cordis disposer, which is synchronous and cannot await — see
+//     the note on `seat()` below.
+//   * **There is no ambient kernel.** A call is only meaningful inside the
+//     scope incarnation it was made for, so the doorway exists only inside a
+//     handler. `AsyncLocalStorage` is what carries the handler's context down
+//     to code that has no way to be handed it — a dsh credential provider is
+//     called by an adapter that knows nothing about rebon.
+//   * **Registration is not a call.** `op_rebon_call_service('model-router',
+//     'register', …)` and its compensating `unregister` are gone. What a
+//     composition provides is reported once, in the `plugin/load` ready
+//     report, and revoked by `plugin/unload` draining. That is the only shape
+//     that works: the unregisters lived in cordis disposers.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { sessionOf } from './registry.mjs';
+
+const calls = new AsyncLocalStorage();
+
+/// Runs `fn` with `ctx` as the call everything underneath reaches through.
+///
+/// Every handler the composition serves — service, tool, llm adapter, event
+/// delivery — is wrapped in this, so anything it calls can find its way back
+/// to rebon without the call context being threaded through dsh code that has
+/// no parameter for it.
+export function withCall(ctx, fn) {
+  return calls.run(ctx, fn);
+}
+
+/// The call this code is running inside.
+export function currentCall() {
+  return calls.getStore();
+}
+
+/// The call this code is running inside, or a refusal that says why not.
+///
+/// The refusal is worth its own code: "cannot read properties of undefined" at
+/// the bottom of a dsh stack says nothing, whereas this names the actual rule —
+/// rebon is reachable from inside a call, and a disposer or a module top level
+/// is not inside one.
+function require(what, via) {
+  const ctx = calls.getStore();
+  if (ctx !== undefined) return ctx;
+  // Nothing is being answered, so this is a plugin acting on its own schedule.
+  // `via` is the Cordis context of the plugin whose code is running, and the
+  // session it is attached to is the honest identity for what it does — the
+  // work is still that plugin's, in that session. Without a session there is
+  // no identity to use, and inventing one would make the ledger a guess.
+  const session = sessionOf(via);
+  if (session !== undefined) return session;
+  throw new Error(
+    `[NO_CALL_CONTEXT] ${what} is not reachable from here: no call rebon made is in flight, `
+      + 'and this plugin is not attached to a session. Teardown paths must rely on unload draining instead',
+  );
+}
+
+/// Calls a kernel seat: the composition's `credentials`, `settings`, `web` and
+/// the rest of what rebon installs a plugin to use.
+///
+/// A request, therefore answerable, therefore **not** usable from a cordis
+/// disposer: `dispose()` is synchronous and a cross-process call cannot be.
+/// Nothing in the composition needs it to be — the calls that used to happen
+/// on the way out were unregistrations, and those are the protocol's job now.
+export function seat(name, method, params = null, options = {}) {
+  const { via, ...call } = options;
+  return require(`seat ${JSON.stringify(name)}`, via).seat(name, method, params, call);
+}
+
+/// Invokes one rebon core tool on the session this call belongs to.
+///
+/// Three gates stand in front of it and only the first is here: the plugin's
+/// manifest must declare the tool, rebon's build must expose it, and the
+/// embedder's broker decides whether this run is permitted.
+export function invokeTool(tool, input = null, options = {}) {
+  const { via, ...call } = options;
+  return require(`tool ${JSON.stringify(tool)}`, via).invoke(tool, input, call);
+}
+
+/// Publishes one event onto rebon's event plane.
+///
+/// Not the same thing as `emit` below, and the difference is the audience: a
+/// chunk is a piece of the answer the caller of *this* call is reading, an
+/// event is a fact anyone listening may act on. The composition's runtime
+/// events — a dsh tool body appending to the session log — are the second kind.
+///
+/// Declared as `publishedTopics` in the manifest, separately from what the
+/// composition listens to.
+export function publish(topic, event = null, options = {}) {
+  const { via, ...call } = options;
+  return require(`topic ${JSON.stringify(topic)}`, via).publish(topic, event, call);
+}
+
+/// Emits one piece of a streamed answer on the call this code is serving.
+///
+/// This is the transport `op_llm_emit` and `op_tool_serve_emit` used to be,
+/// with the pumps gone: a chunk belongs to a call, and the call is the one the
+/// handler was entered with rather than an id looked up in a table.
+export function emit(piece) {
+  return require('emit').emit(piece);
+}
+
+/// The workspace root of the session this call belongs to, or undefined
+/// outside a call.
+export function workspaceRoot() {
+  return calls.getStore()?.workspaceRoot;
+}
+
+/// The abort signal rebon raises when it asks this call to stop.
+export function callSignal() {
+  return calls.getStore()?.signal;
+}
+
+/// Diagnostics.
+///
+/// Best-effort on purpose, and never a reason for a call to fail: a log line
+/// that cannot be delivered is not worth failing the work that produced it.
+/// Inside a call it goes to the kernel's `logger` seat, so the line is
+/// attributed to a scope; outside one it goes to stderr, which the supervisor
+/// already collects as the host's diagnostic tail. stdout is never touched —
+/// that is the protocol's channel.
+const LEVELS = ['trace', 'debug', 'info', 'warn', 'error'];
+export const logger = Object.freeze(Object.fromEntries(LEVELS.map((level) => [
+  level,
+  (message) => {
+    const line = String(message);
+    const ctx = calls.getStore();
+    if (ctx === undefined) {
+      process.stderr.write(`[compose:${level}] ${line}\n`);
+      return;
+    }
+    void ctx.seat('logger', level, { message: line }).catch(() => {
+      process.stderr.write(`[compose:${level}] ${line}\n`);
+    });
+  },
+])));

package/bin/compose-runtime/src/credentials-runtime.mjs

@@ -0,0 +1,50 @@
+// The composition's `ctx.credentials` seat, on the plugin plane.
+//
+// dsh configuration carries credential *references* (environment-variable
+// names); the provider owns the values. This resolves a reference through
+// rebon's `credentials` seat, whose `resolveEnv` runs the fail-closed
+// authorize waterfall before touching the environment — so an unauthorized or
+// unset reference is simply "absent", and the consumer's own missing-credential
+// diagnosis fires (dsh-llm's `MISSING_CREDENTIAL`) instead of this seat
+// inventing one.
+//
+// Ported from `js/compose/credentials-runtime.js`. The one change is that the
+// seat call is now a request across a process boundary, which means it is
+// awaited — and that it can only be made from inside a call rebon is waiting
+// on, or by the plugin being attached to a session. Both hold where a
+// credential is actually wanted: inside a model turn rebon asked for, or inside
+// one an agent loop is running in a session of its own. `bridge.mjs` names the
+// refusal if anything ever tries from a disposer or a module top level.
+import { Service } from 'cordis';
+import { seat } from './bridge.mjs';
+
+export default class RebonCredentials extends Service {
+  constructor(ctx) {
+    super(ctx, 'credentials');
+  }
+
+  /** dsh CredentialProvider.resolve: `{value, source}` or undefined. */
+  async resolve(ref) {
+    try {
+      // `via` is this seat's caller — the plugin whose code wants the
+      // credential. Inside a call that changes nothing; outside one it is what
+      // lets an agent loop's own model turn resolve a key at all, attributed to
+      // the plugin and session it belongs to.
+      const out = await seat('credentials', 'resolveEnv', { ref: String(ref) }, { via: this.ctx });
+      const value = out?.value;
+      if (typeof value === 'string' && value.length > 0) {
+        return { value, source: 'env' };
+      }
+    } catch {
+      // A refusal from the seat (no authorizer, unset variable, bad ref) and
+      // an absent value are the same fact to a consumer: 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/src/eventsource-stream.mjs

@@ -0,0 +1,48 @@
+// `eventsource-parser/stream` for real Node — the published package's shape.
+//
+// The vendored build under `js/vendor/eventsource-parser/stream.js` is not the
+// published module: it was rewritten so that `EventSourceParserStream` is a
+// "Mini streams" transform (an object with `transformIterable`), because bare
+// deno_core has no WHATWG `TransformStream` for the real one to extend. The
+// dsh DeepSeek adapter consumes it as a platform stream —
+// `response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new
+// EventSourceParserStream())` — which on real Node throws
+// `ERR_INVALID_ARG_TYPE: transform.readable must be an instance of
+// ReadableStream` against the rewritten class.
+//
+// So on Node the upstream shape comes back. Parsing itself is still the
+// vendored upstream `createParser`, so framing semantics — chunk reassembly,
+// CRLF/BOM, comment skipping, multi-`data:` joining — stay byte-identical to
+// the published package on both runtimes; only the plumbing differs.
+import { createParser } from 'eventsource-parser';
+
+export { ParseError } from 'eventsource-parser';
+
+export class EventSourceParserStream extends TransformStream {
+  constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => controller.enqueue(event),
+          onError(error) {
+            // Upstream's rule, kept: a callback observes, the string
+            // `'terminate'` aborts, and a buffer overflow aborts regardless of
+            // what the consumer asked for — there is no way to keep parsing
+            // past it.
+            if (typeof onError === 'function') onError(error);
+            if (onError === 'terminate' || error.type === 'max-buffer-size-exceeded') {
+              controller.error(error);
+            }
+          },
+          onRetry,
+          onComment,
+          maxBufferSize,
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      },
+    });
+  }
+}

package/bin/compose-runtime/src/index.mjs

@@ -0,0 +1,7 @@
+// The package's root export: the loader seam the plugin host runs with.
+//
+// `rebon-plugin-host --loader <this file>` is what turns a generic plugin host
+// into one that can mount a Cordis composition. Everything else in this package
+// hangs off that.
+export { createLoader, cordisPluginOf } from './loader.mjs';
+export { activate as composeControl } from './plugin.mjs';

package/bin/compose-runtime/src/llm-runtime.mjs

@@ -0,0 +1,326 @@
+// The composition's `ctx.llm` seat, on the plugin plane.
+//
+// Ported from `js/compose/llm-runtime.js`. The dsh-facing surface is
+// unchanged — adapters extend `LlmAdapter`, register with
+// `ctx.llm.registerAdapter(providers, adapter)`, and in-composition consumers
+// (the agent loop) still go through `prepareCall` / `stream` — because that
+// surface is dsh's contract and the transport underneath it is not dsh's
+// business.
+//
+// What changed is everything that was transport:
+//
+//   * **The pump is gone.** `_pump` parked on `op_llm_next` and `_dispatch`
+//     wrote chunks back with `op_llm_emit`. On the plugin plane a model turn
+//     arrives as an `llm/stream` request routed by provider, and its chunks go
+//     out on that call. What `registerAdapter` hands the registration sink is
+//     the handler for that method; there is nothing left to pump.
+//   * **Announcing is not a call.** `_announce` used to push each route into
+//     the kernel's `model-router` with `callService('model-router',
+//     'register', …)`. Registration is a protocol declaration now: the route
+//     is reported by `plugin/load`, and its model catalog by the composition's
+//     own `compose` service.
+//   * **The disposer only forgets locally.** It used to issue the
+//     compensating `callService('model-router', 'unregister', …)`. A Cordis
+//     disposer is synchronous and a cross-process call is not, so that call
+//     could not survive the move — and does not need to. Revocation is what
+//     `plugin/unload` draining is for.
+import { Service } from 'cordis';
+import {
+  LlmError,
+  deepFreeze,
+  callConfigEquals,
+  errorChain,
+  resolveRetryPolicy,
+} from '@deepseek-ai/dsh-llm';
+import { withCall } from './bridge.mjs';
+import { sinkOf } from './registry.mjs';
+
+// Re-exported from the payload so a plugin extending `LlmAdapter` from
+// `@deepseek-ai/dsh-llm` and the runtime checking one share a single class.
+export { LlmAdapter } from '@deepseek-ai/dsh-llm';
+
+/**
+ * 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) {
+    super(ctx, 'llm');
+    this.routes = new Map(); // provider -> adapter
+    /** Catalog reads still in flight; `settle()` is what waits for them. */
+    this.pending = new Set();
+  }
+
+  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;
+    // Read synchronously, before any await can interleave: which plugin is
+    // registering is a fact about *now*, not about whenever this resolves.
+    const sink = sinkOf(this.ctx);
+    for (const provider of providers) {
+      sink?.llm(provider, (request, callCtx) =>
+        withCall(callCtx, () => runtime.serve(provider, request, callCtx)));
+    }
+    this.ctx.effect(() => {
+      for (const provider of providers) {
+        runtime.routes.set(provider, adapter);
+        runtime._read(provider, adapter, sink);
+      }
+      return () => {
+        // Local only. What rebon knows about these routes was reported at
+        // load and is withdrawn by unload; a disposer cannot tell it anything
+        // because a disposer cannot await an answer.
+        for (const provider of providers) runtime.routes.delete(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 composition 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 ----
+  //
+  // These serve consumers INSIDE the composition (the agent loop); `serve()`
+  // serves requests from rebon. 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;
+    }
+  }
+
+  // ---- what rebon is told, and what rebon asks for ----
+
+  /**
+   * Read one route's catalog for the load report.
+   *
+   * `listModels` is advisory in dsh and can take a network round trip, so a
+   * failure is recorded rather than raised: a provider with no catalog is
+   * still a working route whose callers name models explicitly. The route
+   * table is the liveness witness — an adapter disposed while its catalog was
+   * being read is no longer the live one, and its answer is dropped.
+   */
+  _read(provider, adapter, sink) {
+    if (sink === undefined) return;
+    const task = (async () => {
+      let models = [];
+      try {
+        models = (await adapter.listModels(provider)) ?? [];
+      } catch (error) {
+        if (this.routes.get(provider) !== adapter) return;
+        sink.catalog(provider, { models: [], defaultModel: 'default', catalogError: String(error?.message ?? error) });
+        return;
+      }
+      if (this.routes.get(provider) !== adapter) return;
+      // A key whose value is `undefined` is not JSON, and this report crosses
+      // the wire: an unknown context window is an absent field, not a present
+      // one holding nothing.
+      const entries = models
+        .filter((m) => m?.id)
+        .map((m) => {
+          const window = m.context?.window ?? m.contextWindow;
+          return { id: m.id, ...(window === undefined ? {} : { contextWindow: window }) };
+        });
+      sink.catalog(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',
+      });
+    })();
+    this.pending.add(task);
+    void task.finally(() => this.pending.delete(task));
+  }
+
+  /** Waits for every catalog read in flight, so the load report is complete. */
+  async settle() {
+    while (this.pending.size > 0) await Promise.all([...this.pending]);
+  }
+
+  /**
+   * Serves one `llm/stream` call: chunks out on the call, adapter throws left
+   * to become its terminal.
+   *
+   * Deliberately the raw adapter rather than `_consumerStream`: an in-JS
+   * consumer wants a failure flattened into a finish chunk it can assemble,
+   * whereas rebon wants the call to end as an error carrying the adapter's own
+   * machine code. Flattening here would report every failed turn as a
+   * successful one whose last chunk happens to say otherwise.
+   */
+  async serve(provider, request, ctx) {
+    const adapter = this._registration(provider);
+    const options = {
+      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: ctx.signal,
+    };
+    let count = 0;
+    for await (const chunk of adapter.stream(options)) {
+      await ctx.emit(chunk);
+      count += 1;
+    }
+    return { chunks: count };
+  }
+}