@rebon/cli-linux-arm64 1.2.0 → 1.4.0

package/bin/compose-runtime/payload/compose/shims/zod-lite.js

@@ -8,8 +8,8 @@
 //
 // Honesty boundary: NO validation semantics are provided. Any attempt to
 // actually validate through a shimmed schema (`parse`/`safeParse`) throws
-// loudly instead of silently accepting — if a projection consumer ever lands
-// (P2.9 session seat), replace this shim with a real vendored zod.
+// loudly instead of silently accepting — if a projection consumer ever lands,
+// replace this shim with a real vendored zod.
 
 function inert(kind) {
   return {

package/bin/compose-runtime/payload/vendor/cordis/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/compose-runtime/payload/vendor/dsh/LICENSE-turndown

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Dom Christie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/compose-runtime/payload/vendor/dsh/LICENSE-turndown-plugin-gfm

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Dom Christie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/compose-runtime/payload/vendor/schemastery/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,9 +1,8 @@
 // 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:
+// The plane is across a process boundary, so there are no synchronous ops
+// into an in-process kernel here. Three consequences follow, and they are the
+// protocol's rather than 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
@@ -14,11 +13,11 @@
 //     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.
+//   * **Registration is not a call.** What a composition provides is
+//     reported once, in the `plugin/load` ready report, and revoked by
+//     `plugin/unload` draining. It has to be that shape: a compensating
+//     `unregister` would have to run from a cordis disposer, and a disposer
+//     cannot await the answer.
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { sessionOf } from './registry.mjs';
 
@@ -172,10 +171,9 @@ export const logger = Object.freeze(Object.fromEntries(LEVELS.map((level) => [
     // session it is attached to is the handle that can still reach the seat.
     //
     // This is the same ladder `require()` climbs, with one difference that
-    // matters: it does not throw. A log line is not worth failing a plugin
-    // over, and a refusal here would be the very silence this is fixing.
-    // T19/T19b lost three rounds to lines that went to stderr and were only
-    // ever read when the host died.
+    // matters: it does not throw. A log line is not worth failing a plugin over,
+    // and a line that goes to stderr is only ever read when the host dies — the
+    // very silence this is fixing.
     const ctx = calls.getStore() ?? sessionOf(options.via);
     if (ctx === undefined) {
       process.stderr.write(`[compose:${level}] ${line}\n`);

package/bin/compose-runtime/src/loop-assembly.mjs

@@ -14,13 +14,13 @@
 //  3. **Drive** — `loop:control` is the embedder's inbound face
 //     (followup / steer / cancel / status).
 //
-// Two things moved with the transport:
+// Two consequences of the transport:
 //
-//   * **The catalog is configuration, not a call.** It used to be
-//     `describeTools()`, an op straight into rebon. There is no such method on
-//     the plane, and there should not be: what rebon offers a model is settled
-//     when the composition is built, so rebon hands it over at load. A snapshot
-//     either way — the old op was read once during `apply` too.
+//   * **The catalog is configuration, not a call.** There is no `describeTools`
+//     method on the plane, and there should not be: what rebon offers a model
+//     is settled when the composition is built, so rebon hands it over at
+//     load. It is a snapshot either way; asking would only make the moment it
+//     was taken harder to see.
 //   * **Events publish through a scope handle.** A loop produces turn events on
 //     its own schedule, with no inbound call to hang them on, so the assembly
 //     takes a handle on each open session and fans its events to whichever are

package/bin/plugin-host/package.json

@@ -3,7 +3,7 @@
   "version": "0.0.0-private",
   "private": true,
   "type": "module",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "engines": { "node": ">=24.19.0 <25" },
   "scripts": { "test": "node --test test/*.test.mjs" },
   "bin": { "rebon-plugin-host": "./src/cli.mjs" },

package/bin/plugin-host/src/cli.mjs

@@ -88,16 +88,16 @@ export async function runHost({ input, output, error, loader }) {
 /// A rejection nobody handled, said out loud instead of swallowed, and
 /// attributed where the async chain reaches back to an entry.
 ///
-/// Node does not stop this process for one, and before T20 nothing else looked
-/// either: a plugin could start an async task, have it fail, and leave no trace
-/// anywhere rebon reads. Three rounds of T19 were spent on exactly that.
+/// Node does not stop this process for one, and nothing else looks either: a
+/// plugin could start an async task, have it fail, and leave no trace anywhere
+/// rebon reads.
 ///
-/// T20 recorded these as unattributed, believing a failed promise cannot say
-/// who created it. It can: `plugin/load` runs inside a store that survives
-/// timers, microtasks and awaits, so this handler reads the owner straight out
-/// of it. What escapes the chain — through an `EventEmitter`, a native callback
-/// or a third-party library — is still `unattributed`, which is the truthful
-/// answer and is kept distinct from a wrong one.
+/// A failed promise does not carry who created it, but `plugin/load` runs
+/// inside a store that survives timers, microtasks and awaits, so this handler
+/// reads the owner straight out of it. What escapes the chain — through an
+/// `EventEmitter`, a native callback or a third-party library — is still
+/// `unattributed`, which is the truthful answer and is kept distinct from a
+/// wrong one.
 ///
 /// It never exits. A stray rejection in one plugin must not take down a host
 /// other plugins are being served from; a load still in flight is failed by its

package/bin/plugin-host/src/ownership.mjs

@@ -1,11 +1,11 @@
 // Which entry a stray promise belonged to.
 //
-// Node does not stop this process for an unhandled rejection, and before T20
-// nothing looked either: a plugin could start an async task, have it fail, and
-// leave no trace anywhere rebon reads. T20 made it visible but unattributed,
-// on the belief that a failed promise cannot say who created it.
+// Node does not stop this process for an unhandled rejection, and nothing else
+// looks either: a plugin could start an async task, have it fail, and leave no
+// trace anywhere rebon reads. Making it visible is not the same as attributing
+// it — a failed promise does not carry who created it.
 //
-// Measured on Node 24.19.0, it can. An `AsyncLocalStorage` store survives
+// Measured on Node 24.19.0, an `AsyncLocalStorage` store survives
 // `setTimeout`, `queueMicrotask` and `await`, and the `unhandledRejection`
 // handler reads it directly — so wrapping each `plugin/load` is enough, with no
 // per-promise `async_hooks` and therefore no standing cost.

package/bin/rebon

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/rebon
-size: 49921720 bytes
-sha256: 87ef69e48e53404998f00070cc47f9cc640627910f07a2e96bf5be44bee079e3
+size: 51172672 bytes
+sha256: d4f68d58548ab511df02f7300ddbfb84cf0e3686ca60235f35274c8bb1d260e2

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@rebon/cli-linux-arm64",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Agent cli for coding and more.",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RebonAI/Rebon-Code.git"
+  },
+  "homepage": "https://reboncode.ai",
   "engines": {
     "node": ">=20"
   },
@@ -12,6 +17,8 @@
   "files": [
     "bin",
     "README.md",
+    "LICENSE",
+    "NOTICE",
     "THIRD_PARTY_NOTICES.txt",
     "scripts"
   ],

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

@@ -1,38 +0,0 @@
-// 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

@@ -1,330 +0,0 @@
-// 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);
-    }
-  }
-}