@rebon/cli-linux-x64 1.2.0 → 1.4.0

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

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

@@ -1,82 +0,0 @@
-// 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/systemprompt-runtime.js

@@ -1,74 +0,0 @@
-// Minimal dsh-compatible `ctx.systemPrompt` seat for the composition host
-// (P2.8-JS, docs/dsh-tools-assembly.md / todo-atomization P2.8).
-//
-// API shape follows dsh packages/core/system-prompt: plugins call
-// `ctx.systemPrompt.section({name, order, text})` and get back the exact
-// disposer. Faithful validation subset: duplicate names throw the dsh
-// message, non-finite orders throw the dsh TypeError. Registrations mirror
-// into the kernel's process-level `system-prompt` service — riding the F1
-// effect ledger, so a hard-killed composition never leaves stale sections —
-// and rebon's own prompt assembly (P2.8 registry) renders them inside its
-// stable runtime-context plane, sorted by (order, name).
-//
-// Deliberately NOT provided (v1 honesty boundary): provider-function
-// `text` (dsh resolves it per assembly with an AssembleContext we do not
-// have — a static composition registers static text), `complete` sections
-// (replacing rebon's own prompt belongs to the P3.12 loop seat, not a
-// side door), `context()` / variables / tool-order surfaces. All fail
-// loudly rather than silently degrade.
-import { Service } from 'cordis';
-import { callService } from 'rebon';
-
-export default class RebonSystemPromptRuntime extends Service {
-  constructor(ctx) {
-    super(ctx, 'systemPrompt');
-    this.names = new Set();
-  }
-
-  /** Register one ordered prompt section; returns the exact disposer. */
-  section(entry) {
-    const name = entry?.name;
-    if (typeof name !== 'string' || name.trim().length === 0) {
-      throw new TypeError('systemPrompt.section: section.name must be a non-empty string');
-    }
-    if (!Number.isFinite(entry.order)) {
-      throw new TypeError(`prompt section "${name}" order must be a finite number`);
-    }
-    if (typeof entry.text === 'function') {
-      throw new Error(
-        `prompt section "${name}": provider-function text is not supported in the embedded runtime (register static text)`,
-      );
-    }
-    if (typeof entry.text !== 'string') {
-      throw new TypeError(`prompt section "${name}" text must be a string`);
-    }
-    if (entry.complete) {
-      throw new Error(
-        `prompt section "${name}": complete-section replacement is not supported in the embedded runtime`,
-      );
-    }
-    if (this.names.has(name)) {
-      throw new Error(`prompt section "${name}" is already registered in this scope`);
-    }
-    const runtime = this;
-    // Caller-fork RAII through the Service proxy (llm/tools/web same
-    // pattern): plugin disposal unwinds the kernel mirror. Owner captured
-    // synchronously for ledger attribution (single-plugin unload sweep).
-    const owner = this.ctx[Symbol.for('rebon.composeOwner')] ?? '';
-    return this.ctx.effect(() => {
-      const registered = callService('system-prompt', 'register', {
-        name,
-        order: entry.order,
-        text: entry.text,
-      }, owner);
-      runtime.names.add(name);
-      const token = registered?.token;
-      return () => {
-        runtime.names.delete(name);
-        try {
-          callService('system-prompt', 'unregister', { name, token });
-        } catch {}
-      };
-    });
-  }
-}

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

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