@arbidocs/blocks 0.3.184 → 0.4.0

package/dist/agents/tasks/TaskComposer.d.ts

@@ -0,0 +1,108 @@
+import { type ReactNode } from 'react';
+import { type AgentOption, type AgentSelectLabels } from '../workflows/AgentSelect';
+import { type SchemaFormLabels } from '../workflows/SchemaForm';
+import type { WorkflowDefinition, WorkflowInputs } from '../workflows/types';
+import { type RecurrenceBuilderProps } from './RecurrenceBuilder';
+/** When the task runs. `now` is on demand; the rest are scheduled. */
+export type TaskWhen = 'now' | 'once' | 'repeat' | 'event';
+export type TaskAccessMode = 'ask_each_run' | 'standing';
+/** Everything the composer collects. The host maps it onto its API. */
+export interface TaskComposerValues {
+    workflowId: string;
+    inputs: WorkflowInputs;
+    when: TaskWhen;
+    /** datetime-local value (`once`). */
+    runAt: string;
+    rrule: string;
+    timezone: string;
+    eventKind: string;
+    /** `''` = the user's own assistant. */
+    agentId: string;
+    /** Empty = derived from the workflow title by the host. */
+    name: string;
+    notifyOnComplete: boolean;
+    /** Draft the plan first and let the user approve it before anything is created. */
+    reviewPlan: boolean;
+    /** Only asked for scheduled tasks, folded under More options. */
+    access: TaskAccessMode;
+}
+export interface TaskComposerLabels {
+    titleNew: string;
+    titleEdit: string;
+    description: string;
+    what: string;
+    whatHint: string;
+    whatPlaceholder: string;
+    when: string;
+    whenOptions: Record<TaskWhen, string>;
+    runAt: string;
+    event: string;
+    eventPlaceholder: string;
+    eventHint: ReactNode;
+    who: string;
+    more: string;
+    goalAndPlan: string;
+    reviewPlan: string;
+    reviewPlanHint: string;
+    outputs: string;
+    outputChat: string;
+    outputChatHint: string;
+    outputArtifacts: string;
+    outputFileMetadata: string;
+    tools: string;
+    toolsFromAgent: string;
+    notSupportedYet: string;
+    name: string;
+    namePlaceholder: string;
+    timezone: string;
+    notify: string;
+    notifyHint: string;
+    access: string;
+    accessOptions: Record<TaskAccessMode, {
+        label: string;
+        hint: string;
+    }>;
+    accessNow: string;
+    lockedAfterCreation: string;
+    cancel: string;
+    runNow: string;
+    schedule: string;
+    save: string;
+    saving: string;
+}
+export declare const DEFAULT_TASK_COMPOSER_LABELS: TaskComposerLabels;
+export interface TaskComposerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Editing an existing task: the schedule kind and the agent are fixed. */
+    isEdit?: boolean;
+    /** Workflows a task can run. The host includes its "my own instruction" entry. */
+    workflows: WorkflowDefinition[];
+    agents: AgentOption[];
+    /** Controlled values; omit to let the composer hold them (seeded by `initialValues`). */
+    values?: TaskComposerValues;
+    initialValues?: Partial<TaskComposerValues>;
+    onValuesChange?: (values: TaskComposerValues) => void;
+    timezones?: string[];
+    /** The goal and success-criteria editor, in its own folded section. Omit when not applicable. */
+    goal?: ReactNode | ((values: TaskComposerValues) => ReactNode);
+    /** What "always allowed" means for this agent (e.g. the workspaces it will hold standing access to). */
+    standingAccess?: ReactNode | ((values: TaskComposerValues) => ReactNode);
+    /** Offer the "show me the plan first" switch (needs a host that can draft a plan). */
+    canReviewPlan?: boolean;
+    isPending?: boolean;
+    onSubmit: (values: TaskComposerValues) => void;
+    /** The task's workflow input forms: `renderIcon` maps a field option's icon key. */
+    renderIcon?: (key: string) => ReactNode;
+    labels?: Partial<TaskComposerLabels>;
+    formLabels?: Partial<SchemaFormLabels>;
+    agentLabels?: Partial<AgentSelectLabels>;
+    recurrence?: Pick<RecurrenceBuilderProps, 'testIds' | 'labels'>;
+    testId?: string;
+}
+export declare function defaultTaskComposerValues(workflows: WorkflowDefinition[], initial?: Partial<TaskComposerValues>): TaskComposerValues;
+/**
+ * One dialog to create or schedule a task: pick a workflow, fill its form, say when, say who.
+ * Name, notification, access mode and the goal checklist live folded under More options.
+ */
+export declare function TaskComposer({ open, onOpenChange, isEdit, workflows, agents, values: valuesProp, initialValues, onValuesChange, timezones, goal, canReviewPlan, standingAccess, isPending, onSubmit, renderIcon, labels, formLabels, agentLabels, recurrence, testId, }: TaskComposerProps): import("react").JSX.Element;

package/dist/agents/tasks/TaskPlan.d.ts

@@ -0,0 +1,78 @@
+export interface TaskPlanCriterionView {
+    id: string;
+    text: string;
+}
+/** Reviewable definition-of-done for a goal task. Extra fields on the caller's type are preserved. */
+export interface TaskPlanView {
+    goal: string;
+    criteria: TaskPlanCriterionView[];
+    max_passes: number;
+    documents: string[];
+}
+/** Fixed strings of the goal-plan editor. */
+export interface TaskPlanLabels {
+    emptyTitle: string;
+    emptyBody: string;
+    drafting: string;
+    generate: string;
+    needWorkspace: string;
+    needObjective: string;
+    goalTask: string;
+    /** "scoped to {workspace}" prefix. */
+    scopedTo: string;
+    redraft: string;
+    removePlan: string;
+    goal: string;
+    goalPlaceholder: string;
+    checklist: string;
+    /** e.g. "3 criteria". */
+    criteriaCount: (count: number) => string;
+    add: string;
+    noCriteria: string;
+    criterionPlaceholder: string;
+    removeCriterion: (id: string) => string;
+    retryBudget: string;
+    /** e.g. "up to 3 passes". */
+    passes: (count: number) => string;
+    passesHelp: string;
+    workingDocuments: string;
+    workingDocumentsHelp: string;
+}
+export declare const DEFAULT_TASK_PLAN_LABELS: TaskPlanLabels;
+export interface TaskPlanTestIds {
+    generate: string;
+    editor: string;
+    regenerate: string;
+    remove: string;
+    goal: string;
+    addCriterion: string;
+    criteria: string;
+    passes: string;
+    documents: string;
+    /** Per criterion index (default `task-plan-criterion-{idx}`). */
+    criterion: (idx: number) => string;
+    /** Per criterion index (default `task-plan-remove-criterion-{idx}`). */
+    removeCriterionButton: (idx: number) => string;
+}
+export interface TaskPlanProps<P extends TaskPlanView> {
+    /** The current plan, or null when the task has no plan yet. */
+    plan: P | null;
+    /** Called with the edited plan, or null when the plan is removed. */
+    onChange: (plan: P | null) => void;
+    /** Draft a plan from the objective. */
+    onGenerate: () => void;
+    isGenerating: boolean;
+    /** The active workspace the plan is scoped to (null: none open, so generating is disabled). */
+    workspaceName: string | null;
+    /** The objective the planner drafts from (the task's prompt). */
+    objective: string;
+    testIds?: Partial<TaskPlanTestIds>;
+    labels?: Partial<TaskPlanLabels>;
+}
+/** Stable, collision-free criterion ids (c1, c2, ...) by high-water mark, independent of order. */
+export declare function nextCriterionId(criteria: TaskPlanCriterionView[]): string;
+/**
+ * Goal-plan editor: empty-state pitch with a single Generate action, or (with a plan) goal,
+ * acceptance checklist, retry budget and working documents.
+ */
+export declare function TaskPlan<P extends TaskPlanView>({ plan, onChange, onGenerate, isGenerating, workspaceName, objective, testIds, labels, }: TaskPlanProps<P>): import("react").JSX.Element;

package/dist/agents/tasks/TaskRowActions.d.ts

@@ -0,0 +1,43 @@
+export interface TaskRowActionsLabels {
+    grantAccess: string;
+    watch: string;
+    runNow: string;
+    pause: string;
+    resume: string;
+    history: string;
+    edit: string;
+    delete: string;
+}
+export declare const DEFAULT_TASK_ROW_ACTIONS_LABELS: TaskRowActionsLabels;
+/** Per-row test ids derived from the task id (defaults `task-run-{id}`, ...). */
+export interface TaskRowActionsTestIds {
+    grant: (id: string) => string;
+    watch: (id: string) => string;
+    run: (id: string) => string;
+    pause: (id: string) => string;
+    history: (id: string) => string;
+    edit: (id: string) => string;
+    delete: (id: string) => string;
+}
+export interface TaskRowActionsProps {
+    /** Task id: keys the test ids (`task-run-{id}`, ...). */
+    id: string;
+    /** active | paused | completed | failed. Pause/Resume is hidden once terminal. */
+    status: string;
+    inProgress?: boolean;
+    /** Disables run/pause/delete while a mutation is in flight. */
+    busy?: boolean;
+    /** When set (a run waits for access), a one-click "allow access and continue" appears. */
+    onGrantAccess?: () => void;
+    /** When set (a run exposes its live conversation), a Watch action appears. */
+    onWatch?: () => void;
+    onRunNow: () => void;
+    onTogglePause: () => void;
+    onEdit: () => void;
+    onDelete: () => void;
+    onViewHistory: () => void;
+    testIds?: Partial<TaskRowActionsTestIds>;
+    labels?: Partial<TaskRowActionsLabels>;
+}
+/** Row actions for the Tasks grid: watch live, run now, pause/resume, history, edit, delete. */
+export declare function TaskRowActions({ id, status, inProgress, busy, onWatch, onGrantAccess, onRunNow, onTogglePause, onEdit, onDelete, onViewHistory, testIds, labels, }: TaskRowActionsProps): import("react").JSX.Element;

package/dist/agents/tasks/TaskRunsDialog.d.ts

@@ -0,0 +1,45 @@
+export interface TaskRunView {
+    id: string;
+    /** running | success | failed (others get a neutral pill). */
+    status: string;
+    /** Formatted finish (or start) time; empty for none. */
+    when?: string;
+    error?: string | null;
+    /** The conversation the run's messages landed in; enables Open. */
+    conversationId?: string | null;
+}
+/** Fixed strings of the run-history dialog. */
+export interface TaskRunsDialogLabels {
+    /** Dialog title; receives the task name. */
+    title: (taskName: string | undefined) => string;
+    description: string;
+    loading: string;
+    empty: string;
+    open: string;
+}
+export declare const DEFAULT_TASK_RUNS_DIALOG_LABELS: TaskRunsDialogLabels;
+export interface TaskRunsDialogTestIds {
+    modal: string;
+    empty: string;
+    list: string;
+    row: string;
+    open: string;
+}
+export interface TaskRunsDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    taskName?: string;
+    runs: TaskRunView[];
+    isLoading: boolean;
+    /** Jump into a run's conversation (the dialog closes afterwards). */
+    onOpenRun: (conversationId: string) => void;
+    /** Destination of a run's conversation; makes Open a real link. */
+    getRunHref?: (run: TaskRunView) => string | undefined;
+    testIds?: Partial<TaskRunsDialogTestIds>;
+    labels?: Partial<TaskRunsDialogLabels>;
+}
+/**
+ * A task's run history. History is derived server-side from the run bookend notifications; each
+ * run links to the conversation where its steps / goal / answer stream in the Message timeline.
+ */
+export declare function TaskRunsDialog({ open, onOpenChange, taskName, runs, isLoading, onOpenRun, getRunHref, testIds, labels, }: TaskRunsDialogProps): import("react").JSX.Element;

package/dist/agents/tasks/TasksChrome.d.ts

@@ -0,0 +1,36 @@
+/** Fixed strings of the Tasks page chrome. */
+export interface TasksChromeLabels {
+    tasksTab: string;
+    newTask: string;
+    delete: string;
+}
+export declare const DEFAULT_TASKS_CHROME_LABELS: TasksChromeLabels;
+export interface TasksToolbarProps {
+    /** Number of tasks (shown on the single "Tasks" tab). */
+    count: number;
+    onNewTask: () => void;
+    /** The list is empty: its empty state carries the one filled button, so this one goes tonal. */
+    isEmpty?: boolean;
+    testIds?: Partial<{
+        tab: string;
+        newTask: string;
+    }>;
+    labels?: Partial<TasksChromeLabels>;
+}
+/** The Tasks page header: one "Tasks" tab with a count, and New task (the page's primary action). */
+export declare function TasksToolbar({ count, onNewTask, isEmpty, testIds, labels }: TasksToolbarProps): import("react").JSX.Element;
+/** Empty-state action for the Tasks grid. */
+export declare function NewTaskEmptyAction({ onNewTask, testId, labels, }: {
+    onNewTask: () => void;
+    testId?: string;
+    labels?: Partial<TasksChromeLabels>;
+}): import("react").JSX.Element;
+export interface TasksBulkBarProps {
+    count: number;
+    onClear: () => void;
+    onDelete: () => void;
+    testId?: string;
+    labels?: Partial<TasksChromeLabels>;
+}
+/** Bulk bar for selected tasks (Delete). */
+export declare function TasksBulkBar({ count, onClear, onDelete, testId, labels }: TasksBulkBarProps): import("react").JSX.Element;

package/dist/agents/tasks/UploadTaskItem.d.ts

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+export interface UploadTaskItemLabels {
+    /** Delete action text (failed rows). */
+    delete: string;
+    /** Delete action tooltip. */
+    deleteTitle: string;
+    /** aria-label of the progress bar. */
+    progress: (fileName: string) => string;
+    /** Status line text; the default capitalises the raw status. */
+    status: (status: string, percent: number) => string;
+}
+export declare const DEFAULT_UPLOAD_TASK_ITEM_LABELS: UploadTaskItemLabels;
+/** Per-row test ids derived from the task id (defaults `task-item-{id}`, ...). */
+export interface UploadTaskItemTestIds {
+    item: (taskId: string) => string;
+    fileName: (taskId: string) => string;
+    progressBar: (taskId: string) => string;
+    status: (taskId: string) => string;
+    delete: (taskId: string) => string;
+}
+export interface UploadTaskItemProps {
+    taskId: string;
+    fileName: string;
+    /** queued | parsing | encrypting | indexing | analysing | completed | failed | skipped | empty | low-content */
+    status: string;
+    /** 0-1 fraction or 0-100 percentage. */
+    progress: number;
+    startTime?: number;
+    endTime?: number;
+    /** File-type icon for the row (the app maps the extension). */
+    fileIcon?: ReactNode;
+    /** Shown as a Delete action on failed tasks. */
+    onDelete?: (taskId: string) => void;
+    testIds?: Partial<UploadTaskItemTestIds>;
+    labels?: Partial<UploadTaskItemLabels>;
+    className?: string;
+}
+/** One document-processing row: status icon, file, progress bar, status text + elapsed time. */
+export declare function UploadTaskItem({ taskId, fileName, status, progress, startTime, endTime, fileIcon, onDelete, testIds, labels, className, }: UploadTaskItemProps): import("react").JSX.Element;

package/dist/agents/tasks/UploadTaskList.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+import { type UploadTaskItemLabels } from './UploadTaskItem';
+export interface UploadTaskView {
+    fileName: string;
+    status: string;
+    progress: number;
+    startTime?: number;
+    endTime?: number;
+}
+export interface UploadTaskListProps {
+    tasks: Record<string, UploadTaskView>;
+    /** Include only matching tasks. */
+    filter?: (taskId: string, task: UploadTaskView) => boolean;
+    title?: string;
+    onDelete?: (taskId: string) => void;
+    /** File-type icon per file name. */
+    renderFileIcon?: (fileName: string) => ReactNode;
+    /** Render the "No documents in this category" message when empty (default true). */
+    showEmptyState?: boolean;
+    testIds?: Partial<{
+        root: string;
+        empty: string;
+        title: string;
+    }>;
+    labels?: Partial<UploadTaskListLabels>;
+    /** Labels forwarded to every row. */
+    itemLabels?: Partial<UploadTaskItemLabels>;
+    className?: string;
+}
+export interface UploadTaskListLabels {
+    title: string;
+    empty: string;
+}
+export declare const DEFAULT_UPLOAD_TASK_LIST_LABELS: UploadTaskListLabels;
+export declare function UploadTaskList({ tasks, filter, title, onDelete, renderFileIcon, showEmptyState, testIds, labels, itemLabels, className, }: UploadTaskListProps): import("react").JSX.Element | null;

package/dist/agents/tasks/elapsed.d.ts

@@ -0,0 +1,2 @@
+/** Compact elapsed time: 123ms, 5s, 2m 30s, 1h 15m. */
+export declare function formatElapsed(startTime: number, endTime?: number): string;

package/dist/agents/tasks/index.d.ts

@@ -0,0 +1,13 @@
+export { TaskPlan, DEFAULT_TASK_PLAN_LABELS, nextCriterionId, type TaskPlanLabels, type TaskPlanTestIds, type TaskPlanProps, type TaskPlanView, type TaskPlanCriterionView, } from './TaskPlan';
+export { UploadTaskItem, DEFAULT_UPLOAD_TASK_ITEM_LABELS, type UploadTaskItemProps, type UploadTaskItemLabels, type UploadTaskItemTestIds, } from './UploadTaskItem';
+export { formatElapsed } from './elapsed';
+export { UploadTaskList, DEFAULT_UPLOAD_TASK_LIST_LABELS, type UploadTaskListProps, type UploadTaskListLabels, type UploadTaskView, } from './UploadTaskList';
+export { LiveRunsBanner, DEFAULT_LIVE_RUNS_BANNER_LABELS, type LiveRun, type LiveRunsBannerProps, type LiveRunsBannerLabels, } from './LiveRunsBanner';
+export { RecurrenceBuilder, DEFAULT_RECURRENCE_BUILDER_LABELS, type RecurrenceBuilderProps, type RecurrenceBuilderLabels, type RecurrenceBuilderTestIds, } from './RecurrenceBuilder';
+export * from './rrule';
+export { ACTION_LABELS, STATUS_LABELS, TRIGGER_LABELS, goalProgress, statusBadgeVariant, type TaskActionType, type TaskBadgeVariant, type TaskGoalState, type TaskStatusKey, type TaskTriggerType, } from './taskLabels';
+export { TaskRowActions, DEFAULT_TASK_ROW_ACTIONS_LABELS, type TaskRowActionsProps, type TaskRowActionsLabels, type TaskRowActionsTestIds, } from './TaskRowActions';
+export { createTaskColumns, DEFAULT_TASK_COLUMN_LABELS, type TaskColumnSlots, type TaskColumnLabels, type TaskColumnTestIds, type TaskRowView, } from './taskColumns';
+export { TaskRunsDialog, DEFAULT_TASK_RUNS_DIALOG_LABELS, type TaskRunsDialogProps, type TaskRunsDialogLabels, type TaskRunsDialogTestIds, type TaskRunView, } from './TaskRunsDialog';
+export { TasksToolbar, NewTaskEmptyAction, TasksBulkBar, DEFAULT_TASKS_CHROME_LABELS, type TasksChromeLabels, type TasksToolbarProps, type TasksBulkBarProps, } from './TasksChrome';
+export { TaskComposer, DEFAULT_TASK_COMPOSER_LABELS, defaultTaskComposerValues, type TaskComposerProps, type TaskComposerLabels, type TaskComposerValues, type TaskWhen, type TaskAccessMode, } from './TaskComposer';

package/dist/agents/tasks/rrule.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Minimal RRULE helpers for the Tasks recurrence builder.
+ *
+ * We only generate the constrained subset the friendly builder needs
+ * (FREQ=DAILY|WEEKLY|MONTHLY with BYDAY / BYMONTHDAY + BYHOUR/BYMINUTE). The
+ * backend (dateutil) is the source of truth for validation — these strings are
+ * a valid subset of iCal RRULE. Power users can still hand-write any RRULE in
+ * the advanced field; `describeRRule` falls back to the raw string for rules
+ * outside the builder's subset.
+ */
+export type RecurrenceFrequency = 'daily' | 'weekly' | 'monthly';
+/** iCal two-letter weekday codes, in display order (Mon-first). */
+export declare const WEEKDAYS: readonly ["MO", "TU", "WE", "TH", "FR", "SA", "SU"];
+export type Weekday = (typeof WEEKDAYS)[number];
+export interface RecurrencePreset {
+    frequency: RecurrenceFrequency;
+    /** Selected weekdays (weekly only). */
+    weekdays: Weekday[];
+    /** Day of month 1-31 (monthly only). */
+    monthDay: number;
+    /** Hour 0-23. */
+    hour: number;
+    /** Minute 0-59. */
+    minute: number;
+}
+export declare const DEFAULT_RECURRENCE: RecurrencePreset;
+/** Build an RRULE string from the friendly preset. */
+export declare function buildRRule(preset: RecurrencePreset): string;
+/**
+ * Best-effort parse of an RRULE back into the builder's preset. Returns null
+ * for rules outside the supported subset (so the editor shows the advanced
+ * raw field instead).
+ */
+export declare function parseRRule(rrule: string | null | undefined): RecurrencePreset | null;
+/** Human-readable summary of an RRULE; falls back to the raw rule when unknown. */
+export declare function describeRRule(rrule: string | null | undefined): string;

package/dist/agents/tasks/taskColumns.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Column definitions for the Tasks grid. Every column has an explicit `colId` (AG Grid persists
+ * column state by id: see CLAUDE.md). The app supplies the row actions and formatters as slots.
+ */
+import type { ReactNode } from 'react';
+import type { ColDef } from 'ag-grid-community';
+/** The fields of a task the grid reads. Callers' richer types are accepted as-is. */
+export interface TaskRowView {
+    external_id: string;
+    name: string;
+    trigger_type: string;
+    action_type: string;
+    skill_ref?: string | null;
+    is_goal_task?: boolean | null;
+    goal_state?: unknown;
+    workspace_ext_id?: string | null;
+    agent_ext_id?: string | null;
+    status: string;
+    in_progress?: boolean | null;
+    next_run_at?: string | null;
+    last_run_at?: string | null;
+    last_error?: string | null;
+    /** Set while a run waits for the owner to grant access. */
+    pending_auth_request_id?: string | null;
+}
+/** Fixed strings of the Tasks grid. */
+export interface TaskColumnLabels {
+    name: string;
+    trigger: string;
+    action: string;
+    target: string;
+    status: string;
+    nextRun: string;
+    lastRun: string;
+    untitled: string;
+    goal: string;
+    workspace: string;
+    defaultAgent: string;
+    running: string;
+    /** A run is waiting for the owner to allow access. */
+    waitingForAccess: string;
+    never: string;
+    /** Goal progress, e.g. "2/3 met". */
+    goalMet: (met: number, total: number) => string;
+}
+export declare const DEFAULT_TASK_COLUMN_LABELS: TaskColumnLabels;
+/** Per-task test ids derived from the task id (defaults `task-name-{id}`, ...). */
+export interface TaskColumnTestIds {
+    name: (id: string) => string;
+    goalBadge: (id: string) => string;
+    goalProgress: (id: string) => string;
+    error: (id: string) => string;
+}
+export interface TaskColumnSlots<T extends TaskRowView> {
+    /** Human summary of when the task fires. */
+    describeTrigger: (task: T) => string;
+    /** Friendly display of an ISO timestamp. */
+    formatDate: (iso: string) => string;
+    /** The row actions cell (`TaskRowActions` bound to the app's mutations). */
+    renderActions: (task: T) => ReactNode;
+    /** Destination of a task's name; makes it a real link (modified clicks go to the browser). */
+    getHref?: (task: T) => string | undefined;
+    /** Plain click on the linked name (owns navigation); without `getHref` the name is plain text. */
+    onOpen?: (task: T) => void;
+    testIds?: Partial<TaskColumnTestIds>;
+    labels?: Partial<TaskColumnLabels>;
+}
+export declare function createTaskColumns<T extends TaskRowView>(slots: TaskColumnSlots<T>): ColDef<T>[];

package/dist/agents/tasks/taskLabels.d.ts

@@ -0,0 +1,26 @@
+export type TaskTriggerType = 'one_time' | 'recurring' | 'event';
+export type TaskActionType = 'notify' | 'agent_prompt' | 'run_skill';
+export type TaskStatusKey = 'active' | 'paused' | 'completed' | 'failed';
+export declare const TRIGGER_LABELS: Record<TaskTriggerType, string>;
+export declare const ACTION_LABELS: Record<TaskActionType, string>;
+export declare const STATUS_LABELS: Record<TaskStatusKey, string>;
+export type TaskBadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline';
+export declare function statusBadgeVariant(status: string): TaskBadgeVariant;
+/** The goal-state fields the grid reads from a goal task's last run. */
+export interface TaskGoalState {
+    done?: boolean;
+    criteria_met?: number;
+    criteria_total?: number;
+}
+/**
+ * Goal progress from a goal task's last run (its `/goal` gate verdict), or null when the task
+ * isn't a goal task or hasn't run yet.
+ */
+export declare function goalProgress(task: {
+    is_goal_task?: boolean | null;
+    goal_state?: unknown;
+}): {
+    met: number;
+    total: number;
+    done: boolean;
+} | null;

package/dist/agents/workflows/AgentSelect.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+export interface AgentOption {
+    id: string;
+    label: string;
+    /** Small line under the label in the list (e.g. what the agent is for). */
+    description?: string;
+    /** Avatar or mark shown before the name. */
+    avatar?: ReactNode;
+}
+export interface AgentSelectLabels {
+    /** The field label. */
+    label: string;
+    /** The entry that means "no specific agent": the user's own assistant. */
+    myAssistant: string;
+}
+export declare const DEFAULT_AGENT_SELECT_LABELS: AgentSelectLabels;
+export interface AgentSelectProps {
+    agents: AgentOption[];
+    /** Controlled agent id; `''` = my assistant. Omit to let the select hold its own state. */
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (agentId: string) => void;
+    /** Hide the visible label (still the accessible name). */
+    hideLabel?: boolean;
+    disabled?: boolean;
+    className?: string;
+    labels?: Partial<AgentSelectLabels>;
+    testId?: string;
+    /** Prefix of option ids (`<prefix>-<agent id>`); default `agent-select-option`. */
+    optionTestId?: string;
+}
+/** Pick which agent runs something: the user's own assistant (default) or one of their agents. */
+export declare function AgentSelect({ agents, value, defaultValue, onValueChange, hideLabel, disabled, className, labels, testId, optionTestId, }: AgentSelectProps): import("react").JSX.Element;

package/dist/agents/workflows/SchemaForm.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+import type { WorkflowErrors, WorkflowField, WorkflowFieldError, WorkflowInputs, WorkflowInputValue, WorkflowScope } from './types';
+export interface SchemaFormLabels {
+    /** Appended to the label of an optional field. */
+    optional: string;
+    /** Heading of the folded block that holds `advanced` fields. */
+    advanced: string;
+    errors: Record<WorkflowFieldError, string>;
+}
+export declare const DEFAULT_SCHEMA_FORM_LABELS: SchemaFormLabels;
+export interface SchemaFormProps {
+    fields: WorkflowField[];
+    values: WorkflowInputs;
+    onChange: (name: string, value: WorkflowInputValue) => void;
+    /** Per-field problems to show (the dialog passes them once a launch was attempted). */
+    errors?: WorkflowErrors;
+    /** Renders a `scope` field: the host owns the file data behind the picker. */
+    renderScope?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    /** Renders a `documents` field (an explicit file pick): the host owns the file list. */
+    renderDocuments?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    /** Maps an option's `icon` key to a mark. */
+    renderIcon?: (key: string) => ReactNode;
+    /**
+     * Plain Enter in a multi-line field submits the form (Shift+Enter inserts the newline), the
+     * chat's own convention. Single-line fields submit natively.
+     */
+    onEnterSubmit?: () => void;
+    /** Prefix of field ids: `<prefix>-<field name>`; default `workflow-field`. */
+    testIdPrefix?: string;
+    labels?: Partial<SchemaFormLabels>;
+    className?: string;
+}
+/**
+ * Renders a workflow's declared inputs as a form. Controlled: the caller owns `values` (see
+ * `defaultInputs`) and decides when to validate (`validateInputs`) and show `errors`.
+ */
+export declare function SchemaForm({ fields, values, onChange, errors, renderScope, renderDocuments, renderIcon, onEnterSubmit, testIdPrefix, labels, className, }: SchemaFormProps): import("react").JSX.Element;