mesh-tools — the tool runtime and AMQP broker binding

The per-node process that makes a module's tools serve on the mesh:
- broker-amqp.ts: a concrete AMQP implementation of the sdk's Broker
  contract (request/reply over a reply queue + correlation id, publish/
  subscribe over a topic exchange). Kept here, not in the sdk, so a
  broker-client change never rebuilds a module (ADR 0044).
- runtime.ts: bind the broker, import the assigned modules' tool
  entrypoints (each registers as it loads), serveTools. The thin wrapper.
- main.ts: the entrypoint, configured by MESH_BROKER_URL + MESH_TOOL_MODULES.
- Dockerfile: the container a node runs it as.

Verified over a REAL broker: the test spins LavinMQ (the mesh's broker),
the runtime serves a registered tool, a separate connection invokes it by
name over AMQP and gets the result, and an unknown tool is refused over
the wire. So 'modules can serve' is now running-on-the-mesh, not just
proven in a mock.

Claude-Session: https://claude.ai/code/session_01LrgweAeERJYBg88c5cKDzF

src/runtime.ts

@@ -0,0 +1,32 @@
+// The tool runtime — the thin per-node process that makes a module's tools actually serve. It
+// binds the mesh broker, loads the assigned modules' tool entrypoints (each of which calls
+// registerModuleTools as it imports), and hands them to the sdk's serving harness. Everything hard
+// — dispatch, collection, duplicate-name safety — is the sdk's; this is the wrapper.
+
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { useBroker } from "@novox/mesh-sdk/messaging";
+import { serveTools, listTools } from "@novox/mesh-sdk/tools";
+import type { Broker } from "@novox/mesh-sdk/messaging";
+
+export interface RuntimeOptions {
+  /** The mesh broker to serve over. */
+  broker: Broker;
+  /** Absolute paths to the assigned modules' compiled tool entrypoints (e.g. .../umami/tools/index.js). */
+  moduleEntrypoints: string[];
+}
+
+/** Load the modules, bind the broker, and serve. Returns a stop function that unhooks serving. */
+export async function runTools(opts: RuntimeOptions): Promise<() => void> {
+  useBroker(() => opts.broker);
+
+  for (const entry of opts.moduleEntrypoints) {
+    // Importing the entrypoint runs its registerModuleTools(...) — that is the whole handshake.
+    await import(pathToFileURL(resolve(entry)).href);
+  }
+
+  const stop = await serveTools(opts.broker);
+  const tools = listTools();
+  console.log(`[mesh-tools] serving ${tools.length} tool(s): ${tools.map((t) => t.name).join(", ") || "(none)"}`);
+  return stop;
+}