lazyclaw 3.99.20 → 3.99.21

package/README.md

@@ -81,6 +81,36 @@ lazyclaw onboard --non-interactive --provider nim \
 
 Need a vendor that's **not** built-in? `+ Add a custom OpenAI-compatible endpoint…` inside the setup picker (or `lazyclaw providers add <name> --base-url <url>`) still works for vLLM / LM Studio / private gateways / anything else that speaks the OpenAI v1 wire format.
 
+### `orchestrator` — multi-agent dispatch as a provider
+
+`orchestrator` is a synthetic provider that composes the others. A chat message hitting `PROVIDERS.orchestrator` triggers a three-phase pipeline instead of a single 1:1 call:
+
+1. **PLAN** — the *planner* provider decomposes the request into 2–5 parallel subtasks (JSON-only system prompt; fences / prose tolerated).
+2. **EXECUTE** — each subtask is dispatched round-robin across the *workers*. Replies stream inline so you watch progress in real time.
+3. **SYNTHESIS** — the planner re-enters with every worker's output and writes the final user-facing answer.
+
+Configure in `~/.lazyclaw/config.json`:
+
+```json
+{
+  "provider": "orchestrator",
+  "orchestrator": {
+    "planner": "claude-cli:claude-opus-4-7",
+    "workers": [
+      "claude-cli:claude-sonnet-4-6",
+      "openai:gpt-4o",
+      "gemini:gemini-2.5-pro",
+      "nim:meta/llama-3.1-405b-instruct"
+    ],
+    "maxSubtasks": 5
+  }
+}
+```
+
+Then `lazyclaw chat` (or any other entry point that ends up calling a provider — `lazyclaw agent`, the daemon's `POST /agent` / `POST /chat`, the dashboard chat tab) routes through the orchestrator. Each worker's api-key is resolved through the same chain a direct chat would use (`authProfiles` → `customProviders` → built-in env var → legacy `cfg['api-key']`).
+
+Defaults fall back gracefully: `planner` defaults to `cfg.provider`/`cfg.model`, `workers` defaults to `[planner]` (single-agent chain, still benefits from plan + synthesis structure). Self-recursion (`planner: "orchestrator"`) is rejected up front.
+
 ## Launcher (no-arg `lazyclaw`)
 
 Running `lazyclaw` with no subcommand drops into an arrow-key launcher with every subcommand laid out as a menu. Navigation:

package/cli.mjs

@@ -707,6 +707,18 @@ async function ensureRegistry() {
       _registryMod.registerCustomProviders(readConfig());
     }
   } catch { /* never let a malformed cfg.customProviders block startup */ }
+  // Wire the orchestrator's live cfg + auth-key resolver. We do this on
+  // every ensureRegistry() call (cheap — just replaces the closure) so a
+  // mid-session config edit (custom provider added, env var exported)
+  // takes effect on the next orchestrator turn without a restart.
+  try {
+    if (typeof _registryMod.registerOrchestrator === 'function') {
+      _registryMod.registerOrchestrator({
+        cfgGetter: readConfig,
+        keyResolver: _resolveAuthKey,
+      });
+    }
+  } catch { /* defensive */ }
   return _registryMod;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "3.99.20",
+  "version": "3.99.21",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama and orchestrating multi-step LLM workflows. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/providers/orchestrator.mjs

@@ -0,0 +1,273 @@
+// Orchestrator provider — "openclaw-style" multi-agent dispatch.
+//
+// A user message arriving at PROVIDERS.orchestrator is NOT forwarded
+// 1:1 to a single backend. Instead the provider performs three phases:
+//
+//   1. PLAN     — the configured planner provider decomposes the task
+//                 into 2–5 self-contained subtasks (JSON shape).
+//   2. EXECUTE  — each subtask is dispatched to a worker provider
+//                 (round-robin over cfg.orchestrator.workers). Workers
+//                 stream their replies; the orchestrator surfaces them
+//                 inline so the user can watch progress.
+//   3. SYNTHESIS — the planner re-enters with all subtask outputs and
+//                 produces the final answer.
+//
+// Provider/model spec is "<provider>:<model>" (same shape as the chat
+// REPL's `/model anthropic/claude-opus-4-7` after normalisation). When
+// the model part is omitted, the worker's defaultModel from
+// PROVIDER_INFO is used.
+//
+// Config (~/.lazyclaw/config.json):
+//   {
+//     "orchestrator": {
+//       "planner": "claude-cli:claude-opus-4-7",
+//       "workers": [
+//         "claude-cli:claude-sonnet-4-6",
+//         "openai:gpt-4o",
+//         "gemini:gemini-2.5-pro"
+//       ],
+//       "maxSubtasks": 5,       // optional, default 5
+//       "concurrency": 0        // optional, 0 = sequential (visible streaming)
+//     }
+//   }
+//
+// Defaults: planner = the user's currently configured `cfg.provider`
+// (so `lazyclaw onboard --provider claude-cli` works without any extra
+// step), workers = [planner] (degenerates to a single-agent chain that
+// still benefits from plan + synthesis structure).
+
+import { PROVIDERS, PROVIDER_INFO } from './registry.mjs';
+
+function _parseSpec(spec) {
+  if (!spec || typeof spec !== 'string') return { provider: '', model: '' };
+  const colon = spec.indexOf(':');
+  if (colon < 0) return { provider: spec.trim(), model: '' };
+  return { provider: spec.slice(0, colon).trim(), model: spec.slice(colon + 1).trim() };
+}
+
+function _lookupProvider(spec) {
+  const { provider, model } = _parseSpec(spec);
+  const prov = PROVIDERS[provider];
+  if (!prov) return null;
+  const info = PROVIDER_INFO[provider] || {};
+  return {
+    name: provider,
+    model: model || info.defaultModel || '',
+    prov,
+    info,
+  };
+}
+
+function _bestPlanArray(text) {
+  // Planners sometimes wrap the JSON in prose / code fences. Try the
+  // raw response first, then the largest [...] / [...]-shaped span.
+  const tryParse = (s) => {
+    try { return JSON.parse(s); } catch { return null; }
+  };
+  let arr = tryParse(text);
+  if (Array.isArray(arr)) return arr;
+  // Strip ```json fences
+  const fence = text.match(/```(?:json)?\s*([\s\S]+?)```/);
+  if (fence) {
+    arr = tryParse(fence[1].trim());
+    if (Array.isArray(arr)) return arr;
+  }
+  // Largest [...] substring
+  const start = text.indexOf('[');
+  const end = text.lastIndexOf(']');
+  if (start >= 0 && end > start) {
+    arr = tryParse(text.slice(start, end + 1));
+    if (Array.isArray(arr)) return arr;
+  }
+  return null;
+}
+
+const PLANNER_SYSTEM = `You are an orchestrator that decomposes a user request into independent subtasks for parallel worker agents.
+
+Rules:
+- Output ONLY a JSON array. No prose, no markdown, no code fences.
+- Each entry has shape { "id": <int>, "task": "<one-sentence imperative>", "rationale": "<why this is a useful slice>" }.
+- 2 to 5 subtasks. Each must be doable WITHOUT seeing the others' outputs (parallel-safe).
+- If the request is genuinely atomic (e.g. "say hi"), return a single-element array.
+- Do not add a synthesis / merge step — that runs separately after workers complete.
+- Subtasks must be self-contained: include any context a worker needs to act on the task alone.`;
+
+const SYNTHESIS_SYSTEM = `You are an orchestrator producing the final answer for the user.
+
+You receive: (1) the user's original request, (2) the subtask plan you produced, (3) each worker's response.
+
+Rules:
+- Synthesize a single coherent answer. Distill — do not echo each worker verbatim.
+- Cite worker findings briefly when they meaningfully diverge ("Worker A found …, Worker B confirmed").
+- If a worker failed, acknowledge it but do not let it block the rest of the answer.
+- Match the tone and length the user implied (one-line question → one-line answer; deep dive → deep dive).
+- No JSON; this is the human-facing reply.`;
+
+/**
+ * Build an orchestrator provider. The chat REPL / agent / daemon path
+ * treats it like any other provider — the `sendMessage` async iterable
+ * yields markdown chunks describing plan + subtasks + synthesis.
+ *
+ * @param {Object} [opts]
+ * @param {() => Record<string, unknown>} [opts.cfgGetter] reads ~/.lazyclaw/config.json
+ * @param {(cfg, provider) => string} [opts.keyResolver] returns api-key for a worker provider (mirrors cli.mjs::_resolveAuthKey)
+ */
+export function makeOrchestratorProvider(opts = {}) {
+  const cfgGetter = typeof opts.cfgGetter === 'function' ? opts.cfgGetter : () => ({});
+  const keyResolver = typeof opts.keyResolver === 'function' ? opts.keyResolver : () => '';
+
+  return {
+    name: 'orchestrator',
+    async *sendMessage(messages, callerOpts = {}) {
+      const cfg = cfgGetter() || {};
+      const o = cfg.orchestrator && typeof cfg.orchestrator === 'object' ? cfg.orchestrator : {};
+      const fallbackSpec = cfg.provider && cfg.provider !== 'orchestrator'
+        ? `${cfg.provider}${cfg.model ? ':' + cfg.model : ''}`
+        : 'claude-cli';
+      const plannerSpec = String(o.planner || fallbackSpec);
+      const workerSpecs = Array.isArray(o.workers) && o.workers.length
+        ? o.workers.map(String)
+        : [plannerSpec];
+      const maxSubtasks = Number.isFinite(o.maxSubtasks) && o.maxSubtasks > 0 ? Math.min(10, o.maxSubtasks) : 5;
+
+      const planner = _lookupProvider(plannerSpec);
+      if (!planner) {
+        yield `⚠ orchestrator: planner provider "${plannerSpec}" is not registered. ` +
+          `Set cfg.orchestrator.planner to a valid "provider:model" (e.g. "claude-cli:claude-opus-4-7").\n`;
+        return;
+      }
+      // Self-recursion guard: a misconfigured cfg.orchestrator.planner =
+      // "orchestrator" would otherwise spin forever, with each call
+      // dispatching back to itself.
+      if (planner.name === 'orchestrator') {
+        yield `⚠ orchestrator: planner cannot be "orchestrator" — set cfg.orchestrator.planner to a real provider (e.g. "claude-cli:claude-opus-4-7").\n`;
+        return;
+      }
+      const workers = workerSpecs.map(_lookupProvider).filter(Boolean).filter(w => w.name !== 'orchestrator');
+      if (workers.length === 0) {
+        yield `⚠ orchestrator: no usable workers (cfg.orchestrator.workers is empty, all unknown, or only references "orchestrator" itself).\n`;
+        return;
+      }
+
+      const userText = (() => {
+        // Most recent user message becomes the orchestration target. We
+        // pass earlier turns as context to the planner only — workers
+        // see a self-contained subtask string, not chat history.
+        for (let i = messages.length - 1; i >= 0; i--) {
+          if (messages[i].role === 'user') return String(messages[i].content || '');
+        }
+        return '';
+      })();
+
+      // ── Phase 1: PLAN ───────────────────────────────────────────────
+      yield `## 🦞 Orchestrator\n\n`;
+      yield `Planner: \`${planner.name}${planner.model ? ':' + planner.model : ''}\`  ·  Workers: ${workers.map(w => `\`${w.name}${w.model ? ':' + w.model : ''}\``).join(', ')}\n\n`;
+      yield `### 1. Planning\n\n`;
+
+      const plannerMessages = [
+        { role: 'system', content: PLANNER_SYSTEM },
+        ...messages.filter(m => m.role === 'user' || m.role === 'assistant'),
+      ];
+      let planRaw = '';
+      try {
+        for await (const chunk of planner.prov.sendMessage(plannerMessages, {
+          apiKey: keyResolver(cfg, planner.name),
+          model: planner.model || undefined,
+          signal: callerOpts.signal,
+          maxTokens: 1024,
+        })) {
+          planRaw += String(chunk);
+        }
+      } catch (e) {
+        yield `⚠ planner error: ${e?.message || String(e)}\n\n`;
+        // Fallback: hand the user message to the first worker directly.
+        const w = workers[0];
+        yield `Falling back to direct call on \`${w.name}${w.model ? ':' + w.model : ''}\`:\n\n`;
+        for await (const chunk of w.prov.sendMessage(messages, {
+          apiKey: keyResolver(cfg, w.name),
+          model: w.model || undefined,
+          signal: callerOpts.signal,
+        })) yield String(chunk);
+        return;
+      }
+
+      const plan = _bestPlanArray(planRaw);
+      if (!plan || plan.length === 0) {
+        yield `⚠ planner returned no parseable JSON plan. Raw output:\n\n\`\`\`\n${planRaw.trim().slice(0, 800)}\n\`\`\`\n\nFalling back to single-shot on \`${planner.name}${planner.model ? ':' + planner.model : ''}\`:\n\n`;
+        for await (const chunk of planner.prov.sendMessage(messages, {
+          apiKey: keyResolver(cfg, planner.name),
+          model: planner.model || undefined,
+          signal: callerOpts.signal,
+        })) yield String(chunk);
+        return;
+      }
+      const trimmed = plan.slice(0, maxSubtasks).map((p, i) => ({
+        id: Number.isFinite(p?.id) ? p.id : i + 1,
+        task: String(p?.task || '').trim(),
+        rationale: String(p?.rationale || '').trim(),
+      })).filter(p => p.task);
+      if (trimmed.length === 0) {
+        yield `⚠ plan parsed but contained no usable subtasks. Falling back.\n\n`;
+        for await (const chunk of planner.prov.sendMessage(messages, {
+          apiKey: keyResolver(cfg, planner.name),
+          model: planner.model || undefined,
+          signal: callerOpts.signal,
+        })) yield String(chunk);
+        return;
+      }
+
+      for (const p of trimmed) {
+        yield `${p.id}. **${p.task}**${p.rationale ? ` _— ${p.rationale}_` : ''}\n`;
+      }
+      yield `\n`;
+
+      // ── Phase 2: EXECUTE ────────────────────────────────────────────
+      yield `### 2. Executing ${trimmed.length} subtask${trimmed.length === 1 ? '' : 's'}\n\n`;
+      const results = [];
+      for (let i = 0; i < trimmed.length; i++) {
+        const sub = trimmed[i];
+        const worker = workers[i % workers.length];
+        yield `**Subtask ${sub.id}** \`${worker.name}${worker.model ? ':' + worker.model : ''}\` — ${sub.task}\n\n`;
+        let res = '';
+        try {
+          for await (const chunk of worker.prov.sendMessage([{ role: 'user', content: sub.task }], {
+            apiKey: keyResolver(cfg, worker.name),
+            model: worker.model || undefined,
+            signal: callerOpts.signal,
+          })) {
+            const s = String(chunk);
+            res += s;
+            yield s;
+          }
+          results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: res, error: null });
+        } catch (e) {
+          const msg = e?.message || String(e);
+          yield `\n⚠ worker error: ${msg}\n`;
+          results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: '', error: msg });
+        }
+        yield `\n\n---\n\n`;
+      }
+
+      // ── Phase 3: SYNTHESIS ──────────────────────────────────────────
+      yield `### 3. Synthesis\n\n`;
+      const synthUser = [
+        `Original request:\n${userText}`,
+        `\nSubtask plan and worker outputs:`,
+        ...results.map(r => `\n#### Subtask ${r.id} — ${r.task}\nWorker: ${r.worker}\n${r.error ? `Error: ${r.error}` : r.result.trim()}`),
+        `\nNow write the final answer for the user.`,
+      ].join('\n');
+      try {
+        for await (const chunk of planner.prov.sendMessage([
+          { role: 'system', content: SYNTHESIS_SYSTEM },
+          { role: 'user', content: synthUser },
+        ], {
+          apiKey: keyResolver(cfg, planner.name),
+          model: planner.model || undefined,
+          signal: callerOpts.signal,
+        })) yield String(chunk);
+      } catch (e) {
+        yield `⚠ synthesis error: ${e?.message || String(e)}. Worker outputs above are the final material — please review them directly.\n`;
+      }
+    },
+  };
+}

package/providers/registry.mjs

@@ -13,6 +13,7 @@ import { ollamaProvider } from './ollama.mjs';
 import { geminiProvider } from './gemini.mjs';
 import { claudeCliProvider } from './claude_cli.mjs';
 import { makeOpenAICompatProvider, fetchOpenAICompatModels } from './openai_compat.mjs';
+import { makeOrchestratorProvider } from './orchestrator.mjs';
 
 /**
  * @typedef {{ role: 'user'|'assistant'|'system', content: string }} ChatMessage
@@ -51,6 +52,7 @@ export const mockProvider = {
 
 export { anthropicProvider, openaiProvider, ollamaProvider, geminiProvider, claudeCliProvider };
 export { makeOpenAICompatProvider, fetchOpenAICompatModels };
+export { makeOrchestratorProvider };
 
 // Built-in OpenAI-compatible vendors. Same wire format → one factory call
 // each. The picker treats these like first-class providers so users don't
@@ -229,6 +231,13 @@ export const PROVIDERS = {
   mock: mockProvider,
 };
 
+// Orchestrator — multi-agent dispatcher that composes other providers.
+// Registered upfront with no cfg/keyResolver so a bare process can list
+// it via `lazyclaw providers list`; `registerOrchestrator(...)` from
+// cli.mjs::ensureRegistry wires in the live cfg + auth-key resolver so
+// sendMessage can reach env vars / authProfiles / customProviders.
+PROVIDERS.orchestrator = makeOrchestratorProvider();
+
 // Wire each OpenAI-compat builtin into PROVIDERS as a callable provider.
 // Insertion is between Tier 2 (anthropic) and Tier 4 (ollama) by reordering
 // the keys after the loop runs — JS objects honour insertion order and
@@ -348,6 +357,21 @@ export const PROVIDER_INFO = {
   },
 };
 
+// Orchestrator metadata. Composes other providers; the planner/workers
+// each carry their own keys (or none for claude-cli / ollama / mock),
+// so the orchestrator itself reports requiresApiKey: false. The setup
+// picker treats it as a CLI/Local-family entry — no api-key prompt.
+PROVIDER_INFO.orchestrator = {
+  name: 'orchestrator',
+  label: 'Orchestrator (multi-agent)',
+  requiresApiKey: false,
+  docs: 'Orchestrator — decomposes the user message into 2-5 parallel subtasks, dispatches each to a worker provider, then synthesizes the answers. Configure cfg.orchestrator = { planner: "provider:model", workers: ["provider:model", ...], maxSubtasks?: 5 }. Composes any registered provider — Claude / OpenAI / Gemini / NIM / Groq / local Ollama / custom OpenAI-compat endpoints.',
+  endpoint: '(composes other providers)',
+  defaultModel: 'orchestrator',
+  suggestedModels: ['orchestrator'],
+  composite: true,
+};
+
 // Mirror the OpenAI-compat builtins into PROVIDER_INFO so picker / docs /
 // `lazyclaw providers info` see them with the same shape as the hand-written
 // entries above.
@@ -370,6 +394,16 @@ for (const [name, def] of Object.entries(OPENAI_COMPAT_BUILTINS)) {
   };
 }
 
+/**
+ * Re-register PROVIDERS.orchestrator with a live config getter + auth-key
+ * resolver, so each phase's worker call can pick up env vars / authProfiles
+ * / customProviders. Called from cli.mjs::ensureRegistry on every entry
+ * — idempotent (overwrites the previous registration in place).
+ */
+export function registerOrchestrator({ cfgGetter, keyResolver } = {}) {
+  PROVIDERS.orchestrator = makeOrchestratorProvider({ cfgGetter, keyResolver });
+}
+
 /**
  * Resolve an api-key for a built-in OpenAI-compatible provider from the
  * environment, scanning {envKey} then any {altEnvKeys}. Returns '' when
@@ -422,6 +456,7 @@ export function parseProviderModel(s) {
 // `makeOpenAICompatProvider` — overriding is well-defined.
 const RESERVED_PROVIDER_NAMES = new Set([
   'mock', 'claude-cli', 'anthropic', 'openai', 'gemini', 'ollama',
+  'orchestrator',
   '__add_custom__', '__custom_model__', '__fetch_models__',
 ]);