<Sidecar>

// @smithers-type-exports-begin
/** @typedef {import("./SidecarProps.ts").SidecarProps} SidecarProps */
// @smithers-type-exports-end

import React from "react";
import { Parallel } from "./Parallel.js";
import { Task } from "./Task.js";

/**
 * Runs a primary task and a cheap shadow task over the same prompt.
 *
 * The primary task keeps the component id so downstream `needs` can consume it.
 * The sidecar task is continue-on-fail and writes its own scorer rows.
 *
 * @param {SidecarProps} props
 */
export function Sidecar(props) {
  if (props.skipIf) return null;
  const {
    id = "sidecar",
    agent,
    sidecar,
    output,
    sidecarOutput,
    scorers,
    prompt,
    input,
    maxConcurrency,
    groundTruth,
    context,
    primaryLabel,
    sidecarLabel,
    children,
  } = props;
  const promptNode = prompt ?? input ?? children;
  const shadowId = `${id}-sidecar`;
  return React.createElement(
    Parallel,
    { id: `${id}-parallel`, maxConcurrency },
    React.createElement(
      Task,
      {
        id,
        output,
        agent,
        scorers,
        groundTruth,
        context,
        label: primaryLabel,
      },
      promptNode,
    ),
    React.createElement(
      Task,
      {
        id: shadowId,
        output: sidecarOutput ?? output,
        agent: sidecar,
        continueOnFail: true,
        scorers,
        groundTruth,
        context,
        label: sidecarLabel,
      },
      promptNode,
    ),
  );
}

import React from "react";
/** @typedef {import("./ParallelProps.ts").ParallelProps} ParallelProps */

/**
 * @param {ParallelProps} props
 */
export function Parallel(props) {
  if (props.skipIf) return null;
  // Align prop sanitization with other structural components. `label` names
  // the phase group in run views (graph, the Claude /workflows mirror).
  const next = {
    maxConcurrency: props.maxConcurrency,
    subtreeConcurrency: props.subtreeConcurrency,
    id: props.id,
    ...(props.label === undefined ? {} : { label: props.label }),
    ...(props.priority === undefined ? {} : { priority: props.priority }),
    ...(props.failurePolicy === undefined ? {} : { failurePolicy: props.failurePolicy }),
  };
  return React.createElement("smithers:parallel", next, props.children);
}

// @smithers-type-exports-begin
/**
 * @template D
 * @typedef {import("./InferDeps.ts").InferDeps<D>} InferDeps
 */
/** @typedef {import("./OutputTarget.ts").OutputTarget} OutputTarget */
// @smithers-type-exports-end

import { applyCliToolAllowlist } from "./cliToolAllowlist.js";
import { createTaskComponent } from "./taskCore.js";

export { renderPromptToText } from "./taskCore.js";

/**
 * The Node/CLI-agent-aware `Task`. Every render-path behavior (deps
 * resolution, agent-chain assembly, MDX prompt rendering, static/compute/agent
 * branching) lives in `taskCore.js`; this file only supplies the CLI-agent
 * tool-allowlist enforcement step (`applyCliToolAllowlist`, which statically
 * imports `ClaudeCodeAgent`/`PiAgent`/`GeminiAgent`/`AntigravityAgent` — see
 * `cliToolAllowlist.js`). `Task.browser.js` builds the same component with a
 * no-op allowlist step instead, so it never pulls those Node-only
 * (`node:child_process`-backed) classes into a browser bundle.
 */
export const Task = createTaskComponent({ applyCliToolAllowlist });

import type React from "react";
import type { AgentLike } from "@smthrs/agents/AgentLike";
import type { ScorersMap } from "@smthrs/graph/types";
import type { OutputTarget } from "./OutputTarget.ts";

export type SidecarProps = {
  id?: string;
  agent: AgentLike | AgentLike[];
  sidecar: AgentLike | AgentLike[];
  output: OutputTarget;
  sidecarOutput?: OutputTarget;
  scorers?: ScorersMap;
  prompt?: string | React.ReactNode;
  input?: string | React.ReactNode;
  maxConcurrency?: number;
  groundTruth?: unknown;
  context?: unknown;
  primaryLabel?: string;
  sidecarLabel?: string;
  skipIf?: boolean;
  children?: string | React.ReactNode;
};