agentbnb 4.0.2 → 4.0.4

package/dist/conductor-mode-ESGFZ6T5.js

@@ -0,0 +1,739 @@
+import {
+  getBalance,
+  interpolateObject,
+  signEscrowReceipt
+} from "./chunk-JXEOE7HX.js";
+import "./chunk-EVBX22YU.js";
+import {
+  AgentBnBError
+} from "./chunk-UB2NPFC7.js";
+
+// src/conductor/task-decomposer.ts
+import { randomUUID } from "crypto";
+var TEMPLATES = {
+  "video-production": {
+    keywords: ["video", "demo", "clip", "animation"],
+    steps: [
+      {
+        description: "Generate script from task description",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: []
+      },
+      {
+        description: "Generate voiceover from script",
+        required_capability: "tts",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Generate video visuals from script",
+        required_capability: "video_gen",
+        estimated_credits: 5,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Composite voiceover and video into final output",
+        required_capability: "video_edit",
+        estimated_credits: 3,
+        depends_on_indices: [1, 2]
+      }
+    ]
+  },
+  "deep-analysis": {
+    keywords: ["analyze", "analysis", "research", "report", "evaluate"],
+    steps: [
+      {
+        description: "Research and gather relevant data",
+        required_capability: "web_search",
+        estimated_credits: 2,
+        depends_on_indices: []
+      },
+      {
+        description: "Analyze gathered data",
+        required_capability: "text_gen",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Summarize analysis findings",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: [1]
+      },
+      {
+        description: "Format into final report",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: [2]
+      }
+    ]
+  },
+  "content-generation": {
+    keywords: ["write", "blog", "article", "content", "post", "essay"],
+    steps: [
+      {
+        description: "Create content outline",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: []
+      },
+      {
+        description: "Draft content from outline",
+        required_capability: "text_gen",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Review and refine draft",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: [1]
+      },
+      {
+        description: "Finalize and polish content",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: [2]
+      }
+    ]
+  }
+};
+function decompose(task, _availableCapabilities) {
+  const lower = task.toLowerCase();
+  for (const template of Object.values(TEMPLATES)) {
+    const matched = template.keywords.some((kw) => lower.includes(kw));
+    if (!matched) continue;
+    const ids = template.steps.map(() => randomUUID());
+    return template.steps.map((step, i) => ({
+      id: ids[i],
+      description: step.description,
+      required_capability: step.required_capability,
+      params: {},
+      depends_on: step.depends_on_indices.map((idx) => ids[idx]),
+      estimated_credits: step.estimated_credits
+    }));
+  }
+  return [];
+}
+
+// src/registry/matcher.ts
+function searchCards(db, query, filters = {}) {
+  const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
+  if (words.length === 0) return [];
+  const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
+  const conditions = [];
+  const params = [ftsQuery];
+  if (filters.level !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.level') = ?`);
+    params.push(filters.level);
+  }
+  if (filters.online !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.availability.online') = ?`);
+    params.push(filters.online ? 1 : 0);
+  }
+  const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+  const sql = `
+    SELECT cc.data
+    FROM capability_cards cc
+    JOIN cards_fts ON cc.rowid = cards_fts.rowid
+    WHERE cards_fts MATCH ?
+      ${whereClause}
+    ORDER BY bm25(cards_fts)
+    LIMIT 50
+  `;
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params);
+  const results = rows.map((row) => JSON.parse(row.data));
+  if (filters.apis_used && filters.apis_used.length > 0) {
+    const requiredApis = filters.apis_used;
+    return results.filter((card) => {
+      const cardApis = card.metadata?.apis_used ?? [];
+      return requiredApis.every((api) => cardApis.includes(api));
+    });
+  }
+  return results;
+}
+
+// src/gateway/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
+  const id = randomUUID2();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
+    }
+  };
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(payload, identity.privateKey);
+    headers["X-Agent-Id"] = identity.agentId;
+    headers["X-Agent-Public-Key"] = identity.publicKey;
+    headers["X-Agent-Signature"] = signature;
+  } else if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  if (body.error) {
+    throw new AgentBnBError(body.error.message, `RPC_ERROR_${body.error.code}`);
+  }
+  return body.result;
+}
+
+// src/autonomy/pending-requests.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/cli/remote-registry.ts
+var RegistryTimeoutError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Registry at ${url} did not respond within 5s. Showing local results only.`,
+      "REGISTRY_TIMEOUT"
+    );
+    this.name = "RegistryTimeoutError";
+  }
+};
+var RegistryConnectionError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Cannot reach ${url}. Is the registry running? Showing local results only.`,
+      "REGISTRY_CONNECTION"
+    );
+    this.name = "RegistryConnectionError";
+  }
+};
+var RegistryAuthError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Authentication failed for ${url}. Run \`agentbnb config set token <your-token>\`.`,
+      "REGISTRY_AUTH"
+    );
+    this.name = "RegistryAuthError";
+  }
+};
+async function fetchRemoteCards(registryUrl, params, timeoutMs = 5e3) {
+  let cardsUrl;
+  try {
+    cardsUrl = new URL("/cards", registryUrl);
+  } catch {
+    throw new AgentBnBError(`Invalid registry URL: ${registryUrl}`, "INVALID_REGISTRY_URL");
+  }
+  const searchParams = new URLSearchParams();
+  if (params.q !== void 0) searchParams.set("q", params.q);
+  if (params.level !== void 0) searchParams.set("level", String(params.level));
+  if (params.online !== void 0) searchParams.set("online", String(params.online));
+  if (params.tag !== void 0) searchParams.set("tag", params.tag);
+  searchParams.set("limit", "100");
+  cardsUrl.search = searchParams.toString();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(cardsUrl.toString(), { signal: controller.signal });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    if (isTimeout) {
+      throw new RegistryTimeoutError(registryUrl);
+    }
+    throw new RegistryConnectionError(registryUrl);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new RegistryAuthError(registryUrl);
+  }
+  if (!response.ok) {
+    throw new RegistryConnectionError(registryUrl);
+  }
+  const body = await response.json();
+  return body.items;
+}
+
+// src/autonomy/auto-request.ts
+function minMaxNormalize(values) {
+  if (values.length === 0) return [];
+  if (values.length === 1) return [1];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) {
+    return values.map(() => 1);
+  }
+  return values.map((v) => (v - min) / (max - min));
+}
+function scorePeers(candidates, selfOwner) {
+  const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
+  if (eligible.length === 0) return [];
+  const successRates = eligible.map((c) => c.card.metadata?.success_rate ?? 0.5);
+  const costEfficiencies = eligible.map((c) => c.cost === 0 ? 1 : 1 / c.cost);
+  const idleRates = eligible.map((c) => {
+    const internal = c.card._internal;
+    const idleRate = internal?.idle_rate;
+    return typeof idleRate === "number" ? idleRate : 1;
+  });
+  const normSuccess = minMaxNormalize(successRates);
+  const normCost = minMaxNormalize(costEfficiencies);
+  const normIdle = minMaxNormalize(idleRates);
+  const scored = eligible.map((c, i) => ({
+    ...c,
+    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0)
+  }));
+  scored.sort((a, b) => b.rawScore - a.rawScore);
+  return scored;
+}
+
+// src/conductor/capability-matcher.ts
+var MAX_ALTERNATIVES = 2;
+async function matchSubTasks(opts) {
+  const { db, subtasks, conductorOwner, registryUrl } = opts;
+  return Promise.all(subtasks.map(async (subtask) => {
+    let cards = searchCards(db, subtask.required_capability, { online: true });
+    if (cards.length === 0 && registryUrl) {
+      try {
+        cards = await fetchRemoteCards(registryUrl, { q: subtask.required_capability, online: true });
+      } catch {
+        cards = [];
+      }
+    }
+    const candidates = [];
+    for (const card of cards) {
+      const cardAsV2 = card;
+      if (Array.isArray(cardAsV2.skills)) {
+        for (const skill of cardAsV2.skills) {
+          candidates.push({
+            card,
+            cost: skill.pricing.credits_per_call,
+            skillId: skill.id
+          });
+        }
+      } else {
+        candidates.push({
+          card,
+          cost: card.pricing.credits_per_call,
+          skillId: void 0
+        });
+      }
+    }
+    const scored = scorePeers(candidates, conductorOwner);
+    if (scored.length === 0) {
+      return {
+        subtask_id: subtask.id,
+        selected_agent: "",
+        selected_skill: "",
+        score: 0,
+        credits: 0,
+        alternatives: []
+      };
+    }
+    const top = scored[0];
+    const alternatives = scored.slice(1, 1 + MAX_ALTERNATIVES).map((s) => ({
+      agent: s.card.owner,
+      skill: s.skillId ?? "",
+      score: s.rawScore,
+      credits: s.cost
+    }));
+    return {
+      subtask_id: subtask.id,
+      selected_agent: top.card.owner,
+      selected_skill: top.skillId ?? "",
+      selected_card_id: top.card.id,
+      score: top.rawScore,
+      credits: top.cost,
+      alternatives
+    };
+  }));
+}
+
+// src/conductor/budget-controller.ts
+var ORCHESTRATION_FEE = 5;
+var BudgetController = class {
+  /**
+   * Creates a new BudgetController.
+   *
+   * @param budgetManager - Underlying BudgetManager for reserve floor enforcement.
+   * @param maxBudget - Hard ceiling for the orchestration run.
+   */
+  constructor(budgetManager, maxBudget) {
+    this.budgetManager = budgetManager;
+    this.maxBudget = maxBudget;
+  }
+  /**
+   * Pre-calculates the total budget for an orchestration run.
+   *
+   * Sums all matched sub-task credits, adds the orchestration fee,
+   * and determines whether approval is required (estimated > max).
+   *
+   * @param matches - MatchResult[] from the CapabilityMatcher.
+   * @returns An ExecutionBudget with cost breakdown and approval status.
+   */
+  calculateBudget(matches) {
+    const perTaskSpending = /* @__PURE__ */ new Map();
+    let subTotal = 0;
+    for (const match of matches) {
+      perTaskSpending.set(match.subtask_id, match.credits);
+      subTotal += match.credits;
+    }
+    const estimatedTotal = subTotal + ORCHESTRATION_FEE;
+    return {
+      estimated_total: estimatedTotal,
+      max_budget: this.maxBudget,
+      orchestration_fee: ORCHESTRATION_FEE,
+      per_task_spending: perTaskSpending,
+      requires_approval: estimatedTotal > this.maxBudget
+    };
+  }
+  /**
+   * Checks whether orchestration can proceed without explicit approval.
+   *
+   * Returns true only when:
+   * 1. The budget does NOT require approval (estimated_total <= max_budget)
+   * 2. The BudgetManager confirms sufficient credits (respecting reserve floor)
+   *
+   * @param budget - ExecutionBudget from calculateBudget().
+   * @returns true if execution can proceed autonomously.
+   */
+  canExecute(budget) {
+    if (budget.requires_approval) return false;
+    return this.budgetManager.canSpend(budget.estimated_total);
+  }
+  /**
+   * Checks budget after explicit user/agent approval.
+   *
+   * Ignores the requires_approval flag — used when the caller has already
+   * obtained explicit approval for the over-budget orchestration.
+   * Still enforces the reserve floor via BudgetManager.canSpend().
+   *
+   * @param budget - ExecutionBudget from calculateBudget().
+   * @returns true if the agent has sufficient credits (reserve floor check only).
+   */
+  approveAndCheck(budget) {
+    return this.budgetManager.canSpend(budget.estimated_total);
+  }
+};
+
+// src/credit/budget.ts
+var DEFAULT_BUDGET_CONFIG = {
+  reserve_credits: 20
+};
+var BudgetManager = class {
+  /**
+   * Creates a new BudgetManager.
+   *
+   * @param creditDb - The credit SQLite database instance.
+   * @param owner - Agent owner identifier.
+   * @param config - Budget configuration. Defaults to DEFAULT_BUDGET_CONFIG (20 credit reserve).
+   */
+  constructor(creditDb, owner, config = DEFAULT_BUDGET_CONFIG) {
+    this.creditDb = creditDb;
+    this.owner = owner;
+    this.config = config;
+  }
+  /**
+   * Returns the number of credits available for spending.
+   * Computed as: max(0, balance - reserve_credits).
+   * Always returns a non-negative number — never goes below zero.
+   *
+   * @returns Available credits (balance minus reserve, floored at 0).
+   */
+  availableCredits() {
+    const balance = getBalance(this.creditDb, this.owner);
+    return Math.max(0, balance - this.config.reserve_credits);
+  }
+  /**
+   * Returns true if spending `amount` credits is permitted by budget rules.
+   *
+   * Rules:
+   * - Zero-cost calls (amount <= 0) always return true.
+   * - Any positive amount requires availableCredits() >= amount.
+   * - If balance is at or below the reserve floor, all positive-cost calls return false.
+   *
+   * @param amount - Number of credits to spend.
+   * @returns true if the spend is allowed, false if it would breach the reserve floor.
+   */
+  canSpend(amount) {
+    if (amount <= 0) return true;
+    return this.availableCredits() >= amount;
+  }
+};
+
+// src/conductor/pipeline-orchestrator.ts
+function computeWaves(subtasks) {
+  const waves = [];
+  const completed = /* @__PURE__ */ new Set();
+  const remaining = new Map(subtasks.map((s) => [s.id, s]));
+  while (remaining.size > 0) {
+    const wave = [];
+    for (const [id, task] of remaining) {
+      const depsResolved = task.depends_on.every((dep) => completed.has(dep));
+      if (depsResolved) {
+        wave.push(id);
+      }
+    }
+    if (wave.length === 0) {
+      break;
+    }
+    for (const id of wave) {
+      remaining.delete(id);
+      completed.add(id);
+    }
+    waves.push(wave);
+  }
+  return waves;
+}
+async function orchestrate(opts) {
+  const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
+  const startTime = Date.now();
+  if (subtasks.length === 0) {
+    return {
+      success: true,
+      results: /* @__PURE__ */ new Map(),
+      total_credits: 0,
+      latency_ms: Date.now() - startTime
+    };
+  }
+  const results = /* @__PURE__ */ new Map();
+  const errors = [];
+  let totalCredits = 0;
+  const waves = computeWaves(subtasks);
+  const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
+  for (const wave of waves) {
+    if (maxBudget !== void 0 && totalCredits >= maxBudget) {
+      errors.push(`Budget exceeded: spent ${totalCredits} cr, max ${maxBudget} cr`);
+      break;
+    }
+    const executableIds = [];
+    for (const taskId of wave) {
+      const m = matches.get(taskId);
+      if (maxBudget !== void 0 && m && totalCredits + m.credits > maxBudget) {
+        errors.push(`Skipping task ${taskId}: would exceed budget (${totalCredits} + ${m.credits} > ${maxBudget})`);
+        continue;
+      }
+      executableIds.push(taskId);
+    }
+    const waveResults = await Promise.allSettled(
+      executableIds.map(async (taskId) => {
+        const subtask = subtaskMap.get(taskId);
+        const m = matches.get(taskId);
+        if (!m) {
+          throw new Error(`No match found for subtask ${taskId}`);
+        }
+        const stepsContext = {};
+        for (const [id, val] of results) {
+          stepsContext[id] = val;
+        }
+        const interpContext = { steps: stepsContext, prev: void 0 };
+        if (subtask.depends_on.length > 0) {
+          const lastDep = subtask.depends_on[subtask.depends_on.length - 1];
+          interpContext.prev = results.get(lastDep);
+        }
+        const interpolatedParams = interpolateObject(
+          subtask.params,
+          interpContext
+        );
+        const primary = resolveAgentUrl(m.selected_agent);
+        try {
+          let res;
+          if (primary.url.startsWith("relay://") && relayClient) {
+            const targetOwner = primary.url.replace("relay://", "");
+            res = await relayClient.request({
+              targetOwner,
+              cardId: primary.cardId,
+              params: interpolatedParams,
+              requester: requesterOwner,
+              timeoutMs
+            });
+          } else {
+            res = await requestCapability({
+              gatewayUrl: primary.url,
+              token: gatewayToken,
+              cardId: primary.cardId,
+              params: interpolatedParams,
+              timeoutMs
+            });
+          }
+          return { taskId, result: res, credits: m.credits };
+        } catch (primaryErr) {
+          if (m.alternatives.length > 0) {
+            const alt = m.alternatives[0];
+            const altAgent = resolveAgentUrl(alt.agent);
+            try {
+              let altRes;
+              if (altAgent.url.startsWith("relay://") && relayClient) {
+                const targetOwner = altAgent.url.replace("relay://", "");
+                altRes = await relayClient.request({
+                  targetOwner,
+                  cardId: altAgent.cardId,
+                  params: interpolatedParams,
+                  requester: requesterOwner,
+                  timeoutMs
+                });
+              } else {
+                altRes = await requestCapability({
+                  gatewayUrl: altAgent.url,
+                  token: gatewayToken,
+                  cardId: altAgent.cardId,
+                  params: interpolatedParams,
+                  timeoutMs
+                });
+              }
+              return { taskId, result: altRes, credits: alt.credits };
+            } catch (altErr) {
+              throw new Error(
+                `Task ${taskId}: primary (${m.selected_agent}) failed: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}; alternative (${alt.agent}) failed: ${altErr instanceof Error ? altErr.message : String(altErr)}`
+              );
+            }
+          }
+          throw new Error(
+            `Task ${taskId}: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`
+          );
+        }
+      })
+    );
+    for (const settlement of waveResults) {
+      if (settlement.status === "fulfilled") {
+        const { taskId, result, credits } = settlement.value;
+        results.set(taskId, result);
+        totalCredits += credits;
+      } else {
+        errors.push(settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason));
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    results,
+    total_credits: totalCredits,
+    latency_ms: Date.now() - startTime,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+
+// src/conductor/conductor-mode.ts
+var ConductorMode = class {
+  db;
+  creditDb;
+  conductorOwner;
+  gatewayToken;
+  resolveAgentUrl;
+  maxBudget;
+  constructor(opts) {
+    this.db = opts.db;
+    this.creditDb = opts.creditDb;
+    this.conductorOwner = opts.conductorOwner;
+    this.gatewayToken = opts.gatewayToken;
+    this.resolveAgentUrl = opts.resolveAgentUrl;
+    this.maxBudget = opts.maxBudget ?? 100;
+  }
+  /**
+   * Execute a conductor skill with the given config and params.
+   *
+   * @param config - SkillConfig with type 'conductor' and conductor_skill field.
+   * @param params - Must include `task` string.
+   * @returns Execution result without latency_ms (added by SkillExecutor).
+   */
+  async execute(config, params, onProgress) {
+    const conductorSkill = config.conductor_skill;
+    if (conductorSkill !== "orchestrate" && conductorSkill !== "plan") {
+      return {
+        success: false,
+        error: `Unknown conductor skill: "${conductorSkill}"`
+      };
+    }
+    const task = params.task;
+    if (typeof task !== "string" || task.length === 0) {
+      return {
+        success: false,
+        error: 'Missing or empty "task" parameter'
+      };
+    }
+    const subtasks = decompose(task);
+    if (subtasks.length === 0) {
+      return {
+        success: false,
+        error: "No template matches task"
+      };
+    }
+    onProgress?.({ step: 1, total: 5, message: `Decomposed into ${subtasks.length} sub-tasks` });
+    const matchResults = await matchSubTasks({
+      db: this.db,
+      subtasks,
+      conductorOwner: this.conductorOwner
+    });
+    onProgress?.({ step: 2, total: 5, message: `Matched ${matchResults.length} sub-tasks to agents` });
+    const budgetManager = new BudgetManager(this.creditDb, this.conductorOwner);
+    const budgetController = new BudgetController(budgetManager, this.maxBudget);
+    const executionBudget = budgetController.calculateBudget(matchResults);
+    if (!budgetController.canExecute(executionBudget)) {
+      return {
+        success: false,
+        error: `Budget exceeded: estimated ${executionBudget.estimated_total} cr, max ${this.maxBudget} cr`
+      };
+    }
+    onProgress?.({ step: 3, total: 5, message: `Budget approved: ${executionBudget.estimated_total} cr` });
+    if (conductorSkill === "plan") {
+      return {
+        success: true,
+        result: {
+          subtasks,
+          matches: matchResults,
+          budget: executionBudget
+        }
+      };
+    }
+    const matchMap = new Map(
+      matchResults.map((m) => [m.subtask_id, m])
+    );
+    const orchResult = await orchestrate({
+      subtasks,
+      matches: matchMap,
+      gatewayToken: this.gatewayToken,
+      resolveAgentUrl: this.resolveAgentUrl,
+      maxBudget: this.maxBudget
+    });
+    onProgress?.({ step: 4, total: 5, message: "Pipeline execution complete" });
+    const resultObj = {};
+    for (const [key, value] of orchResult.results) {
+      resultObj[key] = value;
+    }
+    return {
+      success: orchResult.success,
+      result: {
+        plan: subtasks,
+        execution: resultObj,
+        total_credits: orchResult.total_credits,
+        latency_ms: orchResult.latency_ms,
+        errors: orchResult.errors
+      },
+      error: orchResult.success ? void 0 : orchResult.errors?.join("; ")
+    };
+  }
+};
+export {
+  ConductorMode
+};