@multiclawcli/core 0.3.2 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,720 @@
+type ToolName = "Read" | "Write" | "Edit" | "MultiEdit" | "Bash" | "Glob" | "Grep" | "WebFetch";
+interface AgentDefinition {
+    id: string;
+    name: string;
+    icon?: string;
+    runtime?: string;
+    /**
+     * Agent product (e.g. "claude", "opencode", "codex", "cursor").
+     * Distinct from `runtime` (the protocol, always "acp" today).
+     * When absent it is inferred from `command` or config defaults.
+     */
+    provider?: string;
+    /**
+     * Command to launch for this agent's runtime, when the runtime talks to an
+     * external process (e.g. ACP). Generic — "which binary to start", not a
+     * protocol detail — so a built-in runtime simply ignores it.
+     */
+    command?: string;
+    /** Arguments for {@link command}. */
+    args?: string[];
+    model?: string;
+    /**
+     * Map of provider ids (or the legacy alias "acp") to model names.
+     * Provider id is preferred; "acp" is kept for backward compatibility.
+     */
+    models?: Partial<Record<string, string>>;
+    /**
+     * Model tier preference. Used when `model` and `models` are absent.
+     * The catalog maps each tier to a provider-specific model id.
+     */
+    modelTier?: "strong" | "balanced" | "fast";
+    systemPrompt: string;
+    taskPrompt: string;
+    /**
+     * One-line role, for display. Every built-in agent declares one.
+     *
+     * Distinct from {@link taskTitle}, which the orchestrator fills in per turn
+     * from the leader's task plan — "what this agent was asked to do *this* run".
+     * A `description` is "what this agent is for", so it is the one that is still
+     * available before the first turn has been planned.
+     */
+    description?: string;
+    taskTitle?: string;
+    agentScope?: string;
+    agentPlan?: string;
+    tools?: ToolName[];
+    dependsOn?: string[];
+    timeout?: number;
+    retries?: number;
+    workDir?: string;
+}
+type AgentStatus = "pending" | "running" | "retrying" | "success" | "failed" | "skipped";
+interface AgentResult {
+    agentId: string;
+    agentName: string;
+    status: AgentStatus;
+    output: string;
+    duration: number;
+    attempts: number;
+    error?: string;
+    startTime: string;
+    endTime: string;
+}
+interface SubTask {
+    id: string;
+    title: string;
+    scope: string;
+    plan?: string[];
+    dependsOn?: string[];
+}
+interface TaskPlan {
+    projectName: string;
+    requirement: string;
+    tasks: SubTask[];
+}
+
+type Overrides$b = Partial<AgentDefinition>;
+declare function archDesignReviewer(overrides?: Overrides$b): AgentDefinition;
+
+type Overrides$a = Partial<AgentDefinition>;
+declare function architect(overrides?: Overrides$a): AgentDefinition;
+
+type Overrides$9 = Partial<AgentDefinition>;
+declare function backendDeveloper(overrides?: Overrides$9): AgentDefinition;
+
+type Overrides$8 = Partial<AgentDefinition>;
+declare function codeReviewer(overrides?: Overrides$8): AgentDefinition;
+
+type Overrides$7 = Partial<AgentDefinition>;
+declare function devops(overrides?: Overrides$7): AgentDefinition;
+
+type Overrides$6 = Partial<AgentDefinition>;
+declare function frontendDeveloper(overrides?: Overrides$6): AgentDefinition;
+
+type Overrides$5 = Partial<AgentDefinition>;
+declare function leader(overrides?: Overrides$5): AgentDefinition;
+
+type Overrides$4 = Partial<AgentDefinition>;
+declare function productManager(overrides?: Overrides$4): AgentDefinition;
+
+type Overrides$3 = Partial<AgentDefinition>;
+declare function reviewer(overrides?: Overrides$3): AgentDefinition;
+
+type Overrides$2 = Partial<AgentDefinition>;
+declare function tester(overrides?: Overrides$2): AgentDefinition;
+
+type Overrides$1 = Partial<AgentDefinition>;
+declare function uiDesignReviewer(overrides?: Overrides$1): AgentDefinition;
+
+type Overrides = Partial<AgentDefinition>;
+declare function uiDesigner(overrides?: Overrides): AgentDefinition;
+
+declare const agents: {
+    leader: typeof leader;
+    architect: typeof architect;
+    productManager: typeof productManager;
+    backendDeveloper: typeof backendDeveloper;
+    frontendDeveloper: typeof frontendDeveloper;
+    tester: typeof tester;
+    reviewer: typeof reviewer;
+    archDesignReviewer: typeof archDesignReviewer;
+    uiDesigner: typeof uiDesigner;
+    uiDesignReviewer: typeof uiDesignReviewer;
+    codeReviewer: typeof codeReviewer;
+    devops: typeof devops;
+};
+
+/**
+ * What the leader decided a request needs.
+ *
+ * The leader is the only agent that runs before the pipeline exists, which makes
+ * it the only place where "does this even need the team?" can be answered. `run`
+ * is the familiar case; the other two exist so that a greeting or a question is
+ * answered instead of spinning up every agent in the config.
+ */
+type LeaderMode = "run" | "reply" | "ask";
+type LeaderDecision = {
+    mode: "run";
+    run: string[];
+} | {
+    mode: "reply" | "ask";
+    message: string;
+};
+/**
+ * A turn that ended in words rather than in a pipeline.
+ *
+ * Carried on {@link OrchestratorResult} so a caller can tell "the team ran and
+ * succeeded" from "the leader answered you" — both of which are `success: true`
+ * with an empty `agentResults`.
+ */
+interface LeaderMessage {
+    mode: "reply" | "ask";
+    message: string;
+}
+
+/**
+ * One finished turn of a session, as dialogue the leader can read back.
+ *
+ * A requirement alone is not always interpretable: when the leader asked "which
+ * database?" and the user answered "Postgres", turn two's requirement is the
+ * bare word "Postgres". Paired with the turn that produced the question it is
+ * obvious; on its own it is not.
+ */
+interface TurnRecord {
+    /** What the user asked for. */
+    requirement: string;
+    /** How the turn ended in words, when it ended that way. */
+    reply?: LeaderMessage;
+}
+interface MultiClawConfig {
+    name: string;
+    workDir: string;
+    leader?: AgentDefinition;
+    agents: AgentDefinition[];
+    context?: Record<string, string>;
+    /**
+     * Earlier turns of this session, oldest first.
+     *
+     * Core has no notion of a session — the orchestrator is built fresh per turn —
+     * so whoever runs several turns in a row (the console) is the one that has to
+     * carry them. Rendered into the leader's prompt; a single-turn run leaves it
+     * unset and sees no conversation at all.
+     */
+    history?: TurnRecord[];
+    logDir?: string;
+    continueOnError?: boolean;
+    maxConcurrency?: number;
+    useLeader?: boolean;
+    /**
+     * Project-level defaults applied to every agent that does not override them.
+     * Keeps generated configs readable: one line instead of 12 repeated parameters.
+     */
+    defaults?: {
+        provider?: string;
+        model?: string;
+        command?: string;
+    };
+}
+interface OrchestratorResult {
+    name: string;
+    success: boolean;
+    totalDuration: number;
+    agentResults: AgentResult[];
+    startTime: string;
+    endTime: string;
+    /**
+     * Set when the run was stopped via its AbortSignal. Cancellation is a third
+     * outcome, not a flavour of failure: the team stopped because it was told to.
+     * It still reports `success: false` — a run that never finished must not exit
+     * 0 — but the console says "cancelled" rather than "failed", and the CLI can
+     * exit with the conventional 130.
+     */
+    cancelled?: boolean;
+    /**
+     * Set when the turn ended in words instead of a pipeline — the leader answered
+     * or asked a question, so no agent ran. Without it, "the team worked and
+     * succeeded" and "nobody worked" look identical: both are `success: true` with
+     * an empty `agentResults`.
+     */
+    reply?: LeaderMessage;
+}
+
+declare function defineConfig(config: MultiClawConfig): MultiClawConfig;
+
+/**
+ * Everything a runtime emits about a run carries the same envelope. `seq` is a
+ * per-run monotonic counter so a consumer can order events without trusting the
+ * clock; `runId` is fresh for every `execute()` call.
+ */
+interface RuntimeEventBase {
+    runId: string;
+    agentId: string;
+    seq: number;
+}
+/**
+ * The structured stream a runtime produces while an agent runs.
+ *
+ * This is deliberately wider than any single adapter implements: a runtime only
+ * emits the variants it can actually produce, and `RuntimeInfo.capabilities`
+ * tells the caller which those are. `raw` is the escape hatch for vendor output
+ * we recognise the shape of but have not modelled yet — it must never be the
+ * reason a run fails.
+ */
+type RuntimeEvent = (RuntimeEventBase & {
+    type: "run_started";
+    model?: string;
+}) | (RuntimeEventBase & {
+    type: "message_delta";
+    role: "agent" | "thought" | "user";
+    text: string;
+}) | (RuntimeEventBase & {
+    type: "message";
+    role: "agent" | "thought" | "user";
+    text: string;
+}) | (RuntimeEventBase & {
+    type: "tool_call";
+    id: string;
+    name: string;
+    input: unknown;
+}) | (RuntimeEventBase & {
+    type: "tool_result";
+    id: string;
+    output: string;
+    isError: boolean;
+}) | (RuntimeEventBase & {
+    type: "plan";
+    entries: string[];
+}) | (RuntimeEventBase & {
+    type: "usage";
+    inputTokens?: number;
+    outputTokens?: number;
+    contextTokens?: number;
+    contextSize?: number;
+}) | (RuntimeEventBase & {
+    type: "cost";
+    costUsd?: number;
+    modelBreakdown?: Record<string, unknown>;
+    amount?: number;
+    currency?: string;
+}) | (RuntimeEventBase & {
+    type: "raw";
+    vendor: string;
+    payload: unknown;
+}) | (RuntimeEventBase & {
+    type: "run_finished";
+    stopReason: "success" | "max_turns" | "cancelled" | "timeout" | "error";
+}) | (RuntimeEventBase & {
+    type: "run_error";
+    message: string;
+    code?: string;
+});
+/**
+ * What a *runtime adapter* implements — not what the upstream binary is capable
+ * of. A flag is only `true` when this adapter actually wires the behaviour; an
+ * unhonoured `true` would make callers pass options that are silently dropped.
+ */
+interface RuntimeCapabilities {
+    streaming: boolean;
+    sessions: boolean;
+    resume: boolean;
+    permissions: boolean;
+    tools: boolean;
+    models: boolean;
+    images: boolean;
+    usage: boolean;
+    cost: boolean;
+    sandbox: boolean;
+}
+/** The result of capability negotiation, returned by `AgentRuntime.describe()`. */
+interface RuntimeInfo {
+    name: string;
+    version?: string;
+    available: boolean;
+    capabilities: RuntimeCapabilities;
+}
+/** Caller-supplied context for {@link AgentRuntime.describe}. */
+interface RuntimeQuery {
+    /** Binary this runtime would launch, when the caller knows it. */
+    command?: string;
+}
+interface AgentTask {
+    agentId: string;
+    systemPrompt: string;
+    prompt: string;
+    tools: string[];
+    workDir: string;
+    timeout: number;
+    signal?: AbortSignal;
+    onEvent?: (event: RuntimeEvent) => void;
+    /** Ask the runtime to run under a specific session id, if it supports sessions. */
+    sessionId?: string;
+    /** How to treat an existing session: continue it in place, or fork a copy. */
+    resume?: "continue" | "fork";
+    model?: string;
+    /**
+     * Command to launch, for runtimes that drive an external process (e.g. ACP).
+     * Generic — it names a binary, not a protocol — so runtimes that do not spawn
+     * anything ignore it.
+     */
+    command?: string;
+    /** Arguments for {@link command}. */
+    args?: string[];
+}
+interface AgentOutput {
+    output: string;
+    exitCode: number;
+    sessionId?: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        contextTokens?: number;
+        contextSize?: number;
+    };
+    costUsd?: number;
+    stopReason?: string;
+}
+interface AgentRuntime {
+    readonly name: string;
+    describe(options?: RuntimeQuery): Promise<RuntimeInfo>;
+    execute(task: AgentTask): Promise<AgentOutput>;
+}
+
+interface StageInfo {
+    stageIndex: number;
+    agents: Array<{
+        id: string;
+        name: string;
+        icon?: string;
+        model?: string;
+        description?: string;
+        taskTitle?: string;
+    }>;
+}
+type MultiClawEvent = {
+    type: "orchestration:start";
+    timestamp: string;
+    payload: {
+        name: string;
+        requirement?: string;
+        totalAgents: number;
+        stages: StageInfo[];
+    };
+} | {
+    /**
+     * The stage list changed after the turn had already started.
+     *
+     * The leader plans first, so `orchestration:start` necessarily carries the
+     * *pre-plan* grouping. Once the architect's task plan is applied the team is
+     * regrouped, and consumers that drew the first grouping need to be told —
+     * otherwise the console shows a pipeline that never ran.
+     */
+    type: "orchestration:stages";
+    timestamp: string;
+    payload: {
+        totalAgents: number;
+        stages: StageInfo[];
+    };
+} | {
+    type: "orchestration:complete";
+    timestamp: string;
+    payload: OrchestratorResult;
+} | {
+    type: "orchestration:warning";
+    timestamp: string;
+    payload: {
+        message: string;
+    };
+} | {
+    type: "stage:start";
+    timestamp: string;
+    payload: {
+        stageIndex: number;
+        agentIds: string[];
+    };
+} | {
+    type: "stage:complete";
+    timestamp: string;
+    payload: {
+        stageIndex: number;
+    };
+} | {
+    type: "agent:start";
+    timestamp: string;
+    payload: {
+        agentId: string;
+        agentName: string;
+        icon?: string;
+        model?: string;
+        taskTitle?: string;
+    };
+} | {
+    type: "agent:output";
+    timestamp: string;
+    payload: {
+        agentId: string;
+        chunk: string;
+    };
+} | {
+    type: "agent:complete";
+    timestamp: string;
+    payload: AgentResult;
+} | {
+    type: "agent:failed";
+    timestamp: string;
+    payload: AgentResult;
+} | {
+    type: "agent:skipped";
+    timestamp: string;
+    payload: {
+        agentId: string;
+        agentName: string;
+        icon?: string;
+    };
+} | {
+    type: "agent:retrying";
+    timestamp: string;
+    payload: {
+        agentId: string;
+        agentName: string;
+        attempt: number;
+        maxAttempts: number;
+        error: string;
+    };
+};
+type EventListener = (event: MultiClawEvent) => void;
+
+declare class EventBus {
+    private listeners;
+    subscribe(listener: EventListener): () => void;
+    emit(event: MultiClawEvent): void;
+    clear(): void;
+}
+
+declare class Orchestrator {
+    private config;
+    readonly eventBus: EventBus;
+    private contextManager;
+    private runner;
+    private workDir;
+    constructor(config: MultiClawConfig);
+    run(options?: {
+        signal?: AbortSignal;
+    }): Promise<OrchestratorResult>;
+    /**
+     * Order the agents into stages, degrading to declaration order if the graph is
+     * broken.
+     *
+     * `buildStages` throws on a missing dependency and on a cycle. Letting that
+     * escape would reject `run()` before `orchestration:complete` is emitted, so
+     * the caller sees an unhandled rejection instead of a structured failure. A
+     * bad ordering is not a reason to run nothing.
+     */
+    private buildStagesOrFallback;
+    /**
+     * Drop last run's task plan before the architect gets a chance to write one.
+     *
+     * The console runs every turn against the same workspace, so the plan file
+     * survives between turns. If a turn's architect fails to write a new one,
+     * `applyTaskPlan` would silently re-apply the previous turn's titles, scopes
+     * and dependencies to a completely different requirement.
+     */
+    private clearStaleTaskPlan;
+    /**
+     * Decide what this turn is: a pipeline, an answer, or a question.
+     *
+     * Only the leader can answer that, so without one the configured team is the
+     * whole story. With one, its prose output is *not* a failure mode to be papered
+     * over by running everybody — a leader that answers a greeting has done its
+     * job, and that is what `message` records.
+     */
+    private resolveTurn;
+    /**
+     * The configured team, as copies.
+     *
+     * `applyTaskPlan` writes `taskTitle` / `dependsOn` / `agentScope` onto whatever
+     * objects it is handed. The console reuses a single config across turns, so
+     * returning the config's own objects would leak turn 1's dependency graph into
+     * turn 2 — the exact cross-turn contamination `clearStaleTaskPlan` exists to
+     * prevent, but for the in-memory fields rather than the file.
+     */
+    private configuredAgents;
+    /**
+     * Narrow the configured team to the ids the leader named.
+     *
+     * Always a subset: an id that is not in the config is reported and dropped
+     * rather than added, so a typo in a prompt cannot conjure an agent that has no
+     * definition behind it.
+     */
+    private selectAgents;
+    private runStage;
+    private applyTaskPlan;
+    /**
+     * Close out a turn the leader answered rather than planned.
+     *
+     * `success: true` on purpose: the user asked something and got an answer. What
+     * keeps that from reading as a completed pipeline is `reply`, which the console
+     * uses to say "answered" instead of "done".
+     */
+    private finishWithMessage;
+    private warn;
+    /**
+     * Close out a turn that scheduled no agents.
+     *
+     * Reported as a failure rather than a no-op: the user asked for work, and the
+     * only honest outcome is to say that none was done. Running the whole team
+     * instead would contradict the leader's explicit choice.
+     */
+    private finishEmpty;
+}
+
+declare function buildStages(agents: AgentDefinition[]): AgentDefinition[][];
+
+/**
+ * ACP bridges that multiclaw bundles and resolves from its own `node_modules`
+ * rather than requiring the user to install them globally.
+ *
+ * Key = the binary name used in an agent's `command`; value = the npm package
+ * that provides it. `opencode` is deliberately absent: it speaks ACP natively,
+ * so it *is* the user's agent and is installed by the user.
+ */
+declare const BRIDGE_PACKAGES: Record<string, string>;
+/** True when `command` names an executable file on PATH. */
+declare function resolvesOnPath(command: string): boolean;
+/**
+ * Resolve a bundled bridge binary to an absolute path inside multiclaw's
+ * installed `node_modules`. Returns null when `command` is not a bridge we
+ * bundle (e.g. a user-supplied binary such as `opencode`).
+ *
+ * This lets multiclaw drive the ACP bridge without it being on the user's PATH:
+ * the user only installs their own agent (`claude` / `codex` / `opencode`), and
+ * multiclaw supplies the thin bridge in front of it.
+ */
+declare function resolveBridgeBinary(command: string): string | null;
+/**
+ * Resolve the executable multiclaw should spawn for `command`.
+ *
+ * Prefers the user's own install on PATH (this is also what the test suite
+ * relies on — fake binaries are placed on PATH), and falls back to a bridge
+ * multiclaw bundles. Returns null when neither is available.
+ */
+declare function resolveExecutable(command: string): string | null;
+
+type ProviderId = "claude" | "opencode" | "codex" | "cursor" | (string & {});
+type ModelTier = "strong" | "balanced" | "fast";
+interface ProviderModel {
+    id: string;
+    label: string;
+    tier?: ModelTier;
+    /** True when this model is the default for its tier within this provider. */
+    defaultForTier?: boolean;
+}
+type ModelSelectionMode = "config-option" | "arg" | "none";
+interface ProviderSpec {
+    id: ProviderId;
+    label: string;
+    /** Binary to spawn. */
+    command: string;
+    /** Arguments after the binary. */
+    args: string[];
+    /** Additional binary names that resolve to this provider (for detection). */
+    aliases?: string[];
+    /**
+     * Build the `_meta` payload for a session-defining request.
+     * Returns `undefined` when there is nothing to say — the role prompt
+     * then falls back to a prompt prefix.
+     */
+    meta?: (task: AgentTask) => Record<string, unknown> | undefined;
+    /** Whether this provider honours a tool allowlist at all. */
+    tools: boolean;
+    /** How model selection is communicated to the agent. */
+    modelSelection: ModelSelectionMode;
+    /** Models offered by this provider. */
+    models: ProviderModel[];
+    /** Fallback when no tier or explicit model is configured. */
+    defaultModel: string;
+    install: {
+        hint: string;
+        url?: string;
+    };
+    /** Auth prerequisite — shown as a hint, not a hard gate (v1). */
+    auth: {
+        kind: "ambient" | "login" | "api-key" | "none";
+        hint: string;
+    };
+    /**
+     * When the binary name is ambiguous (e.g. cursor's `agent`),
+     * use `--version` output to confirm identity. Mandatory for generic names.
+     */
+    confirm?: (versionOutput: string) => boolean;
+}
+declare const PROVIDERS: readonly ProviderSpec[];
+/** Lookup a provider by its id. */
+declare function specForProvider(id: string): ProviderSpec | undefined;
+/**
+ * Lookup a provider by the binary name it is launched with.
+ * Keys on basename (strips paths and Windows suffixes) so
+ * `/opt/bin/claude-agent-acp` and `claude-agent-acp.exe` both hit.
+ */
+declare function specForCommand(command: string): ProviderSpec | undefined;
+/** All provider ids known to the catalog. */
+declare function providerIds(): string[];
+/** All commands (primary + aliases) that map to a provider. */
+declare function providerCommands(): string[];
+/** Resolve a tier to a concrete model id for a given provider. */
+declare function tierModel(spec: ProviderSpec, tier: ModelTier): string | undefined;
+
+type ProviderStatus = "present" | "missing";
+interface DetectedProvider {
+    id: string;
+    label: string;
+    command: string;
+    status: ProviderStatus;
+    version?: string;
+    note?: string;
+}
+/**
+ * Discover which providers are installed on this machine.
+ *
+ * Availability comes from PATH lookups (fast, no spawn). When
+ * `withVersion` is true, ambiguous binary names (e.g. cursor's `agent`)
+ * are confirmed via `--version` output.
+ */
+declare function detectProviders(opts?: {
+    withVersion?: boolean;
+}): Promise<DetectedProvider[]>;
+/** Just the ids of providers that are present. */
+declare function presentProviders(detected: DetectedProvider[]): string[];
+
+/** Resolve the provider id for an agent, falling back through config defaults. */
+declare function resolveProvider(agent: AgentDefinition, config: MultiClawConfig): string;
+/** Resolve the launch command for an agent. */
+declare function resolveCommand(agent: AgentDefinition, config: MultiClawConfig): string;
+/**
+ * Resolve the launch arguments for an agent.
+ *
+ * Paired with {@link resolveCommand}: the catalog carries per-provider args
+ * (`opencode acp` needs `["acp"]`, the bundled bridges need `[]`), so leaving
+ * `args` undefined would let the runtime fall back to its `["acp"]` default and
+ * launch e.g. `claude-agent-acp acp`. Returns undefined for a truly custom
+ * command so the runtime's default still applies.
+ */
+declare function resolveArgs(agent: AgentDefinition, config: MultiClawConfig): string[] | undefined;
+/** Resolve the model id an agent will actually run with. */
+declare function resolveModel(agent: AgentDefinition, config: MultiClawConfig): string | undefined;
+/** Convenience: full resolution in one call. */
+declare function resolveAgentRuntime(agent: AgentDefinition, config: MultiClawConfig): {
+    provider: string;
+    command: string;
+    model: string | undefined;
+    spec: ProviderSpec | undefined;
+};
+
+declare abstract class RuntimeBase implements AgentRuntime {
+    abstract readonly name: string;
+    abstract describe(options?: RuntimeQuery): Promise<RuntimeInfo>;
+    abstract execute(task: AgentTask): Promise<AgentOutput>;
+}
+
+declare class AcpRuntime extends RuntimeBase {
+    readonly name = "acp";
+    describe(options?: RuntimeQuery): Promise<RuntimeInfo>;
+    execute(task: AgentTask): Promise<AgentOutput>;
+}
+
+declare class RuntimeRegistry {
+    private runtimes;
+    constructor();
+    register(r: AgentRuntime): void;
+    get(name: string): AgentRuntime;
+    has(name: string): boolean;
+    list(): string[];
+}
+declare const runtimeRegistry: RuntimeRegistry;
+
+/** Error name used for cooperative cancellation across the orchestrator. */
+declare const ABORT_ERROR_NAME = "AbortError";
+declare function abortError(message?: string): Error;
+declare function isAbortError(err: unknown): boolean;
+
+export { ABORT_ERROR_NAME, AcpRuntime, type AgentDefinition, type AgentOutput, type AgentResult, type AgentRuntime, type AgentStatus, type AgentTask, BRIDGE_PACKAGES, type DetectedProvider, EventBus, type EventListener, type LeaderDecision, type LeaderMessage, type LeaderMode, type ModelSelectionMode, type ModelTier, type MultiClawConfig, type MultiClawEvent, Orchestrator, type OrchestratorResult, PROVIDERS, type ProviderId, type ProviderModel, type ProviderSpec, type ProviderStatus, RuntimeBase, type RuntimeCapabilities, type RuntimeEvent, type RuntimeEventBase, type RuntimeInfo, type RuntimeQuery, type StageInfo, type SubTask, type TaskPlan, type ToolName, type TurnRecord, abortError, agents, buildStages, defineConfig, detectProviders, isAbortError, presentProviders, providerCommands, providerIds, resolveAgentRuntime, resolveArgs, resolveBridgeBinary, resolveCommand, resolveExecutable, resolveModel, resolveProvider, resolvesOnPath, runtimeRegistry, specForCommand, specForProvider, tierModel };