@rebon/cli-darwin-arm64 0.17.3 → 0.19.0

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

@@ -0,0 +1,228 @@
+// Minimal dsh-compatible `ctx.tools` seat for the composition host (P1.6,
+// docs/dsh-tools-assembly.md).
+//
+// API shape follows dsh packages/core/tools: plugins call
+// `ctx.tools.register(defineTool({...}))` and get back the exact disposer.
+// Definitions arrive with `parameters` already compiled to JSON Schema and
+// argument validation baked into `execute` (the vendored dsh-tools schema
+// layer does both). Each registration is mirrored into the kernel's
+// process-level `tool-registry` service — that call rides the bridge effect
+// ledger, so a hard-killed composition can never leave the kernel table
+// dirty — and execution requests come back over the shared serve pump
+// (serve-dispatch.js, target = the tool name), running the registered body
+// in this isolate.
+//
+// Deliberately NOT provided (v1 honesty boundary, see the assembly doc):
+// `restrict`/`guard` (dsh agent-scope concepts), code mode, output-schema
+// enforcement of the canonical value, presenter projections. `exec` carries
+// the identity fields plus an `agent.session.append` bridge that lands as
+// the kernel event `compose:session/append` — observable, but not a claim
+// of rebon transcript persistence (that is the P2.9 session seat).
+import { Service } from 'cordis';
+import { callService, emit, invokeTool } from 'rebon';
+import { TOOL_RUNTIME_SCHEDULER } from '@deepseek-ai/dsh-tools';
+import { ensureServePump, registerServeTarget } from './serve-dispatch.js';
+
+/** Extract a `[BRACKET_CODE]` prefix from a seat error message, if any. */
+function bracketCode(message) {
+  const match = /^\[([A-Z_]+)\]/.exec(message);
+  return match ? match[1] : undefined;
+}
+
+/** Per-run context/conclusion collection installed by scheduler.prepare. */
+const runStates = new WeakMap();
+
+export default class RebonToolsRuntime extends Service {
+  constructor(ctx) {
+    super(ctx, 'tools');
+    this.names = new Set();
+    // Local definition table for the scheduler's in-composition dispatch
+    // (register() below keeps it in step with the kernel mirror).
+    this.defs = new Map();
+    ensureServePump();
+
+    // ---- dsh scheduler contract (loop round) ----
+    //
+    // agent-loop's tool-calls scheduler drives tools through this
+    // symbol-keyed view (dsh's private loop↔tools seam, contract
+    // transcribed from packages/core/tools/src/index.ts:451). Dispatch
+    // resolution: a composition-registered definition runs in-isolate;
+    // anything else goes to the R5 core seat, whose refusals (stable
+    // bracketed codes) come back as error RESULTS for the model, not
+    // crashes. v1 honesty boundary: no pre/post-execute pipeline —
+    // prepare always dispatches, finalize/finish pass through.
+    const runtime = this;
+    this[TOOL_RUNTIME_SCHEDULER] = {
+      async prepare(exec) {
+        const state = { contexts: [], concluded: false };
+        const run = {
+          ...exec,
+          rootCallId: exec.rootCallId ?? exec.callId,
+          deferContext(message) {
+            state.contexts.push(message);
+          },
+          concludeTurn() {
+            state.concluded = true;
+          },
+        };
+        runStates.set(run, state);
+        return { kind: 'dispatch', exec: run };
+      },
+      async dispatch(exec) {
+        const state = runStates.get(exec) ?? { contexts: [], concluded: false };
+        try {
+          const def = runtime.defs.get(exec.name);
+          let content;
+          if (def !== undefined) {
+            const value = await def.execute(exec.arguments, exec);
+            content = def.output.render(exec.arguments, value);
+          } else {
+            const value = await invokeTool(exec.name, exec.arguments ?? {});
+            content = [{
+              type: 'text',
+              text: typeof value === 'string' ? value : JSON.stringify(value),
+            }];
+          }
+          return {
+            kind: 'final-result',
+            result: {
+              content,
+              isError: false,
+              ...(state.contexts.length > 0 ? { additionalContexts: state.contexts } : {}),
+              ...(state.concluded ? { concludesTurn: true } : {}),
+            },
+          };
+        } catch (error) {
+          const message = String(error?.message ?? error);
+          return {
+            kind: 'final-result',
+            result: {
+              content: [{ type: 'text', text: `Error: ${message}` }],
+              isError: true,
+              error: {
+                message,
+                info: {
+                  name: error?.name ?? 'Error',
+                  code: bracketCode(message) ?? 'TOOL_FAILED',
+                },
+              },
+            },
+          };
+        }
+      },
+      async finalize(_exec, result) {
+        return result;
+      },
+      finish(_exec, result) {
+        return result;
+      },
+    };
+  }
+
+  /**
+   * dsh concurrency classification. v1: everything is exclusive — strictly
+   * serial scheduling is always semantically correct, and it sidesteps the
+   * parallel pool until `isConcurrencySafe` mapping is wired.
+   */
+  executionMode(_exec) {
+    return { kind: 'exclusive' };
+  }
+
+  /**
+   * Register one dsh-shaped tool definition. Mirrors dsh
+   * `ToolRuntime.register` validation; returns the exact disposer.
+   */
+  register(definition) {
+    const name = definition?.name;
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new TypeError('tools.register: definition.name must be a non-empty string');
+    }
+    if (name.startsWith('web:')) {
+      throw new Error(`tool name "${name}" uses the reserved web-provider serve namespace`);
+    }
+    const output = definition.output;
+    if (
+      output === undefined || typeof output !== 'object'
+      || typeof output.render !== 'function'
+    ) {
+      throw new TypeError(`tool "${name}" must declare output { schema, render }`);
+    }
+    if (typeof definition.execute !== 'function') {
+      throw new TypeError(`tool "${name}" must declare execute()`);
+    }
+    const timeoutMs = definition.timeoutMs;
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+      throw new TypeError(`tool "${name}" timeoutMs must be a positive finite number`);
+    }
+    if (this.names.has(name)) {
+      throw new Error(`tool "${name}" is already registered in this scope`);
+    }
+    const runtime = this;
+    // `this.ctx` is the CALLER's context through the Service proxy, so the
+    // effect (and with it the kernel mirror) unwinds when the registering
+    // plugin disposes — cordis RAII, llm-runtime same pattern. ctx.effect
+    // returns the disposer, which dsh's register contract hands back.
+    // Ledger attribution: the composition-entry id, captured synchronously
+    // (never ambient — async interleavings must not mis-attribute).
+    const owner = this.ctx[Symbol.for('rebon.composeOwner')] ?? '';
+    return this.ctx.effect(() => {
+      const registered = callService('tool-registry', 'register', {
+        name,
+        description: String(definition.description ?? ''),
+        inputSchema: definition.parameters ?? { type: 'object' },
+      }, owner);
+      if (registered?.shadowed) {
+        // Same rule as R3: builtin always wins at dispatch; loud, not
+        // fatal — and best-effort, because the Rust registry already
+        // logged it and a missing logger seat must not fail registration.
+        const message = `composition tool "${name}" shares a builtin tool's name; the builtin wins`;
+        try {
+          callService('logger', 'warn', { message });
+        } catch {
+          console.warn(message);
+        }
+      }
+      runtime.names.add(name);
+      runtime.defs.set(name, definition);
+      const disposeServe = registerServeTarget(name, (input, signal, id) =>
+        runtime._execute(definition, input, signal, id),
+      );
+      const token = registered?.token;
+      return () => {
+        disposeServe();
+        runtime.names.delete(name);
+        runtime.defs.delete(name);
+        try {
+          callService('tool-registry', 'unregister', { name, token });
+        } catch {}
+      };
+    });
+  }
+
+  async _execute(definition, input, signal, id) {
+    const callId = `compose:${id}`;
+    const tool = definition.name;
+    const exec = {
+      callId,
+      rootCallId: callId,
+      name: tool,
+      arguments: input,
+      signal,
+      // v1 bridge: dsh tools write per-session facts through
+      // `exec.agent.session.append`; here that lands as a kernel event
+      // the embedder can observe. No persistence claim.
+      agent: {
+        session: {
+          append(type, data) {
+            emit('compose:session/append', { type, data, tool, callId });
+          },
+        },
+      },
+    };
+    // defineTool's execute validates arguments first (ToolArgsError with
+    // INVALID_ARGS semantics flows into the err envelope's message).
+    const value = await definition.execute(input, exec);
+    const content = definition.output.render(input, value);
+    return { content, isError: false };
+  }
+}

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

@@ -0,0 +1,204 @@
+// Minimal dsh-compatible `ctx.web` seat for the composition host (P2.7,
+// docs/dsh-web-assembly.md).
+//
+// API shape follows dsh packages/web/web verbatim: providers register with
+// `ctx.web.registerSearchProvider/registerFetchProvider` (duplicate ids
+// throw WEB_DUPLICATE_PROVIDER; the exact disposer comes back), and
+// `search`/`fetch` resolve their provider at EXECUTION time with dsh's
+// five-state rules — a configured id wins or fails loudly (never falls
+// back), otherwise exactly one usable provider auto-selects. The seat
+// enforces `maxResults` truncation on search results (capSources).
+//
+// Deployment default: the `rebon` builtin provider (backed by the R5
+// invokeTool bridge onto rebon's own WebSearch/WebFetch) is always
+// registered, and the configured id DEFAULTS to `"rebon"` — feeding the
+// same config field dsh uses (`bootConfig().web.searchProvider` /
+// `.fetchProvider`, i.e. config.json's `web` section), never a hidden
+// priority chain. So plugin providers take over only when configured, and
+// the multi-provider AMBIGUOUS state is unreachable unless the default is
+// explicitly cleared.
+//
+// Registrations are mirrored to the Rust seat via
+// `web/provider-registered` / `web/provider-unregistered` kernel events
+// (`available` is a registration-time snapshot — a static composition's
+// config does not change under it; documented v1 semantics), and each
+// plugin provider is served back to Rust dispatch through the shared serve
+// pump under the reserved target `web:<kind>:<id>`.
+import { Service } from 'cordis';
+import { bootConfig, emit, invokeTool } from 'rebon';
+import { WebError } from './shims/dsh-web.js';
+import { ensureServePump, registerServeTarget } from './serve-dispatch.js';
+
+/** dsh WebRuntime.resolveProvider, transcribed. */
+function resolveProvider(configuredId, providers) {
+  if (configuredId !== undefined) {
+    const provider = providers.get(configuredId);
+    if (!provider) {
+      throw new WebError(
+        `configured web provider "${configuredId}" is not registered`,
+        'WEB_PROVIDER_CONFIGURED_MISSING',
+      );
+    }
+    if (!provider.available()) {
+      throw new WebError(
+        `configured web provider "${configuredId}" is registered but unavailable`,
+        'WEB_PROVIDER_CONFIGURED_UNAVAILABLE',
+      );
+    }
+    return provider;
+  }
+  const usable = [...providers.values()].filter((provider) => {
+    try {
+      return !!provider.available();
+    } catch {
+      return false;
+    }
+  });
+  if (usable.length === 0) {
+    throw new WebError('no usable web provider is registered', 'WEB_PROVIDER_UNAVAILABLE');
+  }
+  if (usable.length > 1) {
+    const ids = usable.map((provider) => provider.id).join(', ');
+    throw new WebError(
+      `multiple usable web providers are registered (${ids}); configure one explicitly`,
+      'WEB_PROVIDER_AMBIGUOUS',
+    );
+  }
+  return usable[0];
+}
+
+/** dsh capSources: enforce `maxResults` on the way back. */
+function capSources(result, maxResults) {
+  if (maxResults === undefined || (result.sources?.length ?? 0) <= maxResults) return result;
+  return { ...result, sources: result.sources.slice(0, maxResults), truncated: true };
+}
+
+/**
+ * The rebon builtin search provider: rides the R5 invokeTool bridge onto
+ * rebon's WebSearch tool (read-only, so no grant is needed) and maps the
+ * `{query, answer, results}` contract into dsh's result vocabulary.
+ */
+const rebonBuiltinSearch = {
+  id: 'rebon',
+  available: () => true,
+  async search(request, _signal) {
+    const out = await invokeTool('WebSearch', { query: String(request?.query ?? '') });
+    const sources = (out?.results ?? [])
+      .map((entry) => ({
+        url: String(entry?.url ?? ''),
+        ...(entry?.title ? { title: String(entry.title) } : {}),
+        ...(entry?.snippet ? { snippet: String(entry.snippet) } : {}),
+      }))
+      .filter((source) => source.url.length > 0);
+    return {
+      ...(out?.answer ? { content: String(out.answer) } : {}),
+      sources,
+      truncated: false,
+    };
+  },
+};
+
+/**
+ * The rebon builtin fetch provider over rebon's WebFetch tool. The tool
+ * returns extracted text, not raw transport facts, so `statusCode` is the
+ * 200 the extraction implies and the body is `text` — a documented v1
+ * approximation, not a transport claim.
+ */
+const rebonBuiltinFetch = {
+  id: 'rebon',
+  available: () => true,
+  async fetch(request, _signal) {
+    const out = await invokeTool('WebFetch', { url: String(request?.url ?? '') });
+    const content =
+      typeof out === 'string' ? out : String(out?.content ?? out?.text ?? JSON.stringify(out));
+    return {
+      url: String(request?.url ?? ''),
+      statusCode: 200,
+      body: { kind: 'text', content },
+      truncated: false,
+    };
+  },
+};
+
+export default class RebonWebRuntime extends Service {
+  constructor(ctx, options) {
+    super(ctx, 'web');
+    // Per-loop hosts keep provider registrations off the process event
+    // plane (llm-runtime same rule).
+    this.announce = options?.announce !== false;
+    const config = bootConfig()?.web ?? {};
+    const configured = (value) =>
+      typeof value === 'string' && value.trim().length > 0 ? value.trim() : 'rebon';
+    this.searchProviderId = configured(config.searchProvider);
+    this.fetchProviderId = configured(config.fetchProvider);
+    this.searchProviders = new Map([['rebon', rebonBuiltinSearch]]);
+    this.fetchProviders = new Map([['rebon', rebonBuiltinFetch]]);
+    ensureServePump();
+  }
+
+  registerSearchProvider(provider) {
+    return this._register(this.searchProviders, 'search', provider);
+  }
+
+  registerFetchProvider(provider) {
+    return this._register(this.fetchProviders, 'fetch', provider);
+  }
+
+  _register(store, kind, provider) {
+    if (typeof provider?.id !== 'string' || provider.id.length === 0) {
+      throw new TypeError('a web provider must declare a non-empty string `id`');
+    }
+    if (store.has(provider.id)) {
+      throw new WebError(
+        `a web provider with id "${provider.id}" is already registered`,
+        'WEB_DUPLICATE_PROVIDER',
+      );
+    }
+    const runtime = this;
+    // Caller-fork RAII (Service proxy binds this.ctx to the registrant):
+    // plugin disposal removes the provider, the kernel mirror, and the
+    // serve target together.
+    return this.ctx.effect(() => {
+      store.set(provider.id, provider);
+      let available = false;
+      try {
+        available = !!provider.available();
+      } catch {}
+      const disposeServe = registerServeTarget(
+        `web:${kind}:${provider.id}`,
+        (input, signal) => runtime._serve(kind, provider, input, signal),
+      );
+      if (runtime.announce) emit('web/provider-registered', { kind, id: provider.id, available });
+      return () => {
+        disposeServe();
+        store.delete(provider.id);
+        if (runtime.announce) emit('web/provider-unregistered', { kind, id: provider.id });
+      };
+    });
+  }
+
+  /** Rust-dispatched execution of one plugin provider (seat rules applied). */
+  async _serve(kind, provider, input, signal) {
+    if (kind === 'search') {
+      const request = {
+        query: String(input?.query ?? ''),
+        ...(input?.maxResults !== undefined ? { maxResults: input.maxResults } : {}),
+      };
+      return capSources(await provider.search(request, signal), request.maxResults);
+    }
+    return provider.fetch({ url: String(input?.url ?? '') }, signal);
+  }
+
+  /** dsh consumer API: run one search through the selected provider. */
+  async search(request, signal) {
+    const provider = resolveProvider(this.searchProviderId, this.searchProviders);
+    const result = await provider.search(request, signal);
+    return capSources(result, request?.maxResults);
+  }
+
+  /** dsh consumer API: retrieve one URL through the selected provider. */
+  async fetch(request, signal) {
+    const provider = resolveProvider(this.fetchProviderId, this.fetchProviders);
+    return provider.fetch(request, signal);
+  }
+}