<ApprovalGate>

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

import React from "react";
import { Branch } from "./Branch.js";
import { Approval } from "./Approval.js";
import { Task } from "./Task.js";
/**
 * Conditional approval gate. Requires human approval only when `when` is true;
 * otherwise auto-approves with a static `{ approved: true }` decision.
 *
 * Composes Branch + Approval + Task internally.
 * @param {ApprovalGateProps} props
 */
export function ApprovalGate(props) {
  if (props.skipIf) return null;
  return React.createElement(Branch, {
    if: props.when,
    then: React.createElement(Approval, {
      id: props.id,
      output: props.output,
      request: props.request,
      onDeny: props.onDeny,
      timeoutMs: props.timeoutMs,
      heartbeatTimeoutMs: props.heartbeatTimeoutMs,
      heartbeatTimeout: props.heartbeatTimeout,
      retries: props.retries,
      retryPolicy: props.retryPolicy,
      continueOnFail: props.continueOnFail,
    }),
    else: React.createElement(Task, {
      id: props.id,
      output: props.output,
      label: `${props.request.title} (auto-approved)`,
      children: {
        approved: true,
        note: "auto-approved",
        decidedBy: null,
        decidedAt: null,
      },
    }),
  });
}

import React from "react";
import { SmithersError } from "@smthrs/errors/SmithersError";
/** @typedef {import("./BranchProps.ts").BranchProps} BranchProps */

/**
 * @param {BranchProps} props
 */
export function Branch(props) {
  // <Branch> resolves its subtree from the `then`/`else` props; any JSX children
  // would be silently dropped, removing those tasks from the graph with no
  // feedback. Fail fast instead. (Checked before skipIf so a stray-children
  // mistake still surfaces even on a skipped branch.)
  if (props.children !== undefined && props.children !== null) {
    throw new SmithersError(
      "INVALID_INPUT",
      `<Branch> does not take children. Use the "then" and "else" props instead, e.g. ` +
        `<Branch if={cond} then={<Task .../>} else={<Task .../>} />. ` +
        `Children passed to <Branch> are silently ignored and would drop those tasks from the graph.`,
    );
  }
  if (props.skipIf) return null;
  const chosen = props.if ? props.then : (props.else ?? null);
  // The branch is resolved to `chosen` at render time, so the host element
  // carries no props of its own (align with the sanitizing structural components).
  return React.createElement("smithers:branch", {}, chosen);
}

// @smithers-type-exports-begin
/** @typedef {import("./ApprovalDecision.ts").ApprovalDecision} ApprovalDecision */
/** @typedef {import("./ApprovalRanking.ts").ApprovalRanking} ApprovalRanking */
/** @typedef {import("./ApprovalRequest.ts").ApprovalRequest} ApprovalRequest */
/** @typedef {import("./ApprovalSelection.ts").ApprovalSelection} ApprovalSelection */
// @smithers-type-exports-end

import React from "react";
import { z } from "zod";
import { SmithersContext } from "@smthrs/react-reconciler/context";
import { getTaskRuntime } from "@smthrs/driver/task-runtime";
import { SmithersDb } from "@smthrs/db/adapter";
import { SmithersError } from "@smthrs/errors/SmithersError";
/** @typedef {import("./ApprovalAutoApprove.ts").ApprovalAutoApprove} ApprovalAutoApprove */
/** @typedef {import("./ApprovalMode.ts").ApprovalMode} ApprovalMode */
/** @typedef {import("./ApprovalOption.ts").ApprovalOption} ApprovalOption */
/**
 * @template Row, Output
 * @typedef {import("./ApprovalProps.ts").ApprovalProps<Row, Output>} ApprovalProps
 */

export const approvalDecisionSchema = z.object({
  approved: z.boolean(),
  // `note` is omitted entirely when no note was provided, so the default
  // decision schema must accept an absent key (optional) as well as the
  // legacy null/string shapes.
  note: z.string().nullable().optional(),
  decidedBy: z.string().nullable(),
  decidedAt: z.string().datetime().nullable(),
});
export const approvalSelectionSchema = z.object({
  selected: z.string(),
  notes: z.string().nullable(),
});
export const approvalRankingSchema = z.object({
  ranked: z.array(z.string()),
  notes: z.string().nullable(),
});
/**
 * @param {unknown} value
 * @returns {value is import("zod").ZodObject<import("zod").ZodRawShape>}
 */
function isZodObject(value) {
  return Boolean(value && typeof value === "object" && "shape" in value);
}
/**
 * @template T
 * @param {unknown} value
 * @returns {T | null}
 */
function parseJson(value) {
  if (typeof value !== "string" || value.length === 0) {
    return null;
  }
  try {
    return JSON.parse(value);
  } catch {
    return null;
  }
}
/**
 * @param {ApprovalMode} mode
 * @returns {import("zod").ZodObject<import("zod").ZodRawShape>}
 */
function defaultSchemaForMode(mode) {
  switch (mode) {
    case "select":
      return approvalSelectionSchema;
    case "rank":
      return approvalRankingSchema;
    default:
      return approvalDecisionSchema;
  }
}
/**
 * @param {{ status?: string | null; note?: string | null; decidedBy?: string | null; decidedAtMs?: number | null } | undefined | null} approval
 * @param {import("zod").ZodObject<import("zod").ZodRawShape>} outputSchema
 * @returns {Record<string, unknown>}
 */
function buildDecisionPayload(approval, outputSchema) {
  const base = {
    approved: approval?.status === "approved",
    decidedBy: approval?.decidedBy ?? null,
    decidedAt: approval?.decidedAtMs != null ? new Date(approval.decidedAtMs).toISOString() : null,
  };
  if (typeof approval?.note === "string") {
    return { ...base, note: approval.note };
  }
  if (outputSchema.safeParse(base).success) {
    return base;
  }
  return { ...base, note: null };
}
/**
 * @param {ApprovalMode | undefined} mode
 * @returns {"select" | "rank" | "decision"}
 */
function normalizeMode(mode) {
  switch (mode) {
    case "select":
      return "select";
    case "rank":
      return "rank";
    default:
      return "decision";
  }
}
/**
 * @param {ApprovalOption[] | undefined} options
 * @returns {ApprovalOption[] | undefined}
 */
function normalizeOptions(options) {
  return options?.map((option) => ({
    key: option.key,
    label: option.label,
    ...(option.summary ? { summary: option.summary } : {}),
    ...(option.metadata ? { metadata: option.metadata } : {}),
  }));
}
/**
 * @param {unknown} value
 * @param {"allowedScopes" | "allowedUsers"} field
 * @param {string} id
 * @returns {string[] | undefined}
 */
function validateApprovalRestriction(value, field, id) {
  if (value === undefined) {
    return undefined;
  }
  if (
    !Array.isArray(value) ||
    Array.from(value).some((entry) => typeof entry !== "string" || entry.trim().length === 0)
  ) {
    throw new SmithersError("INVALID_INPUT", `Approval ${id} ${field} must be an array of non-empty strings.`);
  }
  return value;
}
/**
 * @param {ApprovalAutoApprove[keyof ApprovalAutoApprove]} callback
 * @param {import("@smthrs/driver").SmithersCtx<unknown> | null} ctx
 * @returns {boolean | undefined}
 */
function evaluateBooleanCallback(callback, ctx) {
  if (typeof callback !== "function") {
    return undefined;
  }
  return Boolean(/** @type {(ctx: import("@smthrs/driver").SmithersCtx<unknown> | null) => boolean} */ (callback)(ctx));
}
/**
 * @template Row
 * @param {ApprovalProps<Row>} props
 * @returns {React.ReactElement | null}
 */
export function Approval(props) {
  if (props.skipIf) return null;
  const smithersContext = props.smithersContext ?? SmithersContext;
  const ctx = React.useContext(smithersContext);
  const mode = props.mode ?? "approve";
  const approvalMode = normalizeMode(mode);
  const options = normalizeOptions(props.options);
  const allowedScopes = validateApprovalRestriction(props.allowedScopes, "allowedScopes", props.id);
  const allowedUsers = validateApprovalRestriction(props.allowedUsers, "allowedUsers", props.id);
  const outputSchema = props.outputSchema ?? (isZodObject(props.output) ? props.output : defaultSchemaForMode(mode));
  if ((mode === "select" || mode === "rank") && (!options || options.length === 0)) {
    throw new SmithersError("APPROVAL_OPTIONS_REQUIRED", `Approval ${props.id} requires options when mode="${mode}".`);
  }
  const conditionMet = props.autoApprove ? evaluateBooleanCallback(props.autoApprove.condition, ctx) : undefined;
  const revertOnMet = props.autoApprove ? evaluateBooleanCallback(props.autoApprove.revertOn, ctx) : undefined;
  const autoApprove = props.autoApprove
    ? {
        ...(typeof props.autoApprove.after === "number" ? { after: props.autoApprove.after } : {}),
        audit: props.autoApprove.audit !== false,
        ...(conditionMet !== undefined ? { conditionMet } : {}),
        ...(revertOnMet !== undefined ? { revertOnMet } : {}),
      }
    : undefined;
  const requestMeta = {
    requestTitle: props.request.title,
    ...(props.request.summary ? { requestSummary: props.request.summary } : {}),
    ...(options ? { approvalOptions: options } : {}),
    ...(allowedScopes?.length ? { approvalAllowedScopes: allowedScopes } : {}),
    ...(allowedUsers?.length ? { approvalAllowedUsers: allowedUsers } : {}),
    ...(autoApprove ? { approvalAutoApprove: autoApprove } : {}),
    ...props.request.metadata,
    ...props.meta,
  };
  /**
   * @returns {Promise<Row>}
   */
  const computeDecision = async () => {
    const runtime = getTaskRuntime();
    if (!runtime) {
      throw new SmithersError(
        "APPROVAL_OUTSIDE_TASK",
        "Approval decisions can only be resolved while a Smithers task is executing.",
      );
    }
    const adapter = new SmithersDb(runtime.db);
    const approval = await adapter.getApproval(runtime.runId, props.id, runtime.iteration);
    const decision = parseJson(approval?.decisionJson);
    if (approvalMode === "select") {
      return {
        selected: typeof decision?.selected === "string" ? decision.selected : "",
        notes: typeof decision?.notes === "string" ? decision.notes : (approval?.note ?? null),
      };
    }
    if (approvalMode === "rank") {
      return {
        ranked: Array.isArray(decision?.ranked) ? decision.ranked.filter((value) => typeof value === "string") : [],
        notes: typeof decision?.notes === "string" ? decision.notes : (approval?.note ?? null),
      };
    }
    return buildDecisionPayload(approval, outputSchema);
  };
  return React.createElement("smithers:task", {
    id: props.id,
    output: props.output,
    outputSchema,
    dependsOn: props.dependsOn,
    needs: props.needs,
    ...(Object.hasOwn(props, "bind") ? { bind: props.bind } : {}),
    needsApproval: true,
    waitAsync: props.async === true,
    approvalMode,
    approvalOnDeny: props.onDeny ?? "fail",
    approvalOptions: options,
    approvalAllowedScopes: allowedScopes,
    approvalAllowedUsers: allowedUsers,
    approvalAutoApprove: autoApprove,
    timeoutMs: props.timeoutMs,
    heartbeatTimeoutMs: props.heartbeatTimeoutMs,
    heartbeatTimeout: props.heartbeatTimeout,
    retries: props.retries,
    retryPolicy: props.retryPolicy,
    continueOnFail: props.continueOnFail,
    cache: props.cache,
    label: props.label ?? props.request.title,
    meta: Object.keys(requestMeta).length > 0 ? requestMeta : undefined,
    __smithersKind: "compute",
    __smithersComputeFn: computeDecision,
  });
}

// @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 { ApprovalRequest } from "./ApprovalRequest.ts";
import type { RetryPolicy } from "@smthrs/scheduler/RetryPolicy";
import type { OutputTarget } from "./OutputTarget.ts";

export type ApprovalGateProps = {
  id: string;
  /** Where to persist the approval decision. */
  output: OutputTarget;
  /** Human-facing approval request. */
  request: ApprovalRequest;
  /** When `true`, approval is required. When `false`, auto-approves. */
  when: boolean;
  /** Behavior after denial. */
  onDeny?: "fail" | "continue" | "skip";
  skipIf?: boolean;
  timeoutMs?: number;
  heartbeatTimeoutMs?: number;
  heartbeatTimeout?: number;
  retries?: number;
  retryPolicy?: RetryPolicy;
  continueOnFail?: boolean;
};