@arbidocs/blocks 0.4.72 → 0.4.73

package/dist/agents/index.js

@@ -1,19 +1,22 @@
 "use client";
-export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, EMPTY_WORKFLOW_SCOPE, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SchemaForm, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskActivityTimeline, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadNotifyDialog, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildLaunch, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composeWorkflowPrompt, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultInputs, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, inputsFromContext, isAgenticWorkflow, isEmptyWorkflowScope, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isWorkflowScope, isoToLocalInput, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, promptFieldName, resolveScopeInputs, skillToWorkflow, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, validateInputs, workflowAccepts, workflowFromFrontmatter, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowTriggerType, workflowWhen, workflowsAccepting, workflowsForHost } from '../chunk-IMC2Z32C.js';
+export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskActivityTimeline, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadNotifyDialog, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowThreadStrip, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, groupThreadActivity, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, isAgenticWorkflow, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isoToLocalInput, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, resolveScopeInputs, skillSlug, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, useWorkflowPreview, workflowFromSkillMarkdown, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowToSkillMarkdown, workflowTriggerType, workflowWhen } from '../chunk-QDNXEB3T.js';
 import '../chunk-CKB64Z4R.js';
 import '../chunk-P6GHJSLR.js';
+export { DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, SchemaForm, WorkflowRunner, buildLaunch, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, fromPlanSteps, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, layoutFromPlanSteps, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runThreadTitle, skillToWorkflow, stepDependencies, stepLevels, stepPhase, stepStatesFromActivity, toPlanSteps, useWorkflowView, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost } from '../chunk-2P3T23C7.js';
 import '../chunk-4WWM3GQ5.js';
 import '../chunk-RFXJYIDV.js';
 import '../chunk-DPLRHEJZ.js';
+import '../chunk-EVUEIBNU.js';
 import '../chunk-BUHKUKKB.js';
 import '../chunk-YU2KUMGE.js';
-import '../chunk-LFGJAZ5H.js';
+import '../chunk-DDF5GPIJ.js';
+import '../chunk-XD2M6LIG.js';
 import '../chunk-S7PSMMRG.js';
-import '../chunk-76JDDMSP.js';
 import '../chunk-3VQYJBOI.js';
 import '../chunk-AA3PT6KR.js';
 import '../chunk-SLSBJRWW.js';
 import '../chunk-NPLYHR2E.js';
+import '../chunk-76JDDMSP.js';
 import '../chunk-OXF2IFXG.js';
 import '../chunk-TX2ZICS7.js';
 import '../chunk-7F6CBP3Z.js';

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

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-export type TaskActivityKind = 'created' | 'run_started' | 'awaiting_access' | 'access_granted' | 'done' | 'reopened' | 'failed' | 'participant_joined' | 'assistant_responded' | 'assistant_stopped' | 'artifact_created' | 'artifact_edited' | 'document_added' | 'document_removed' | 'notified';
+export type TaskActivityKind = 'created' | 'run_started' | 'awaiting_access' | 'access_granted' | 'done' | 'reopened' | 'failed' | 'participant_joined' | 'assistant_responded' | 'assistant_stopped' | 'artifact_created' | 'artifact_edited' | 'document_added' | 'document_removed' | 'notified' | 'step_started' | 'step_done' | 'step_skipped' | 'step_failed';
 /** One event of a task's history, as the backend returns it (oldest first). */
 export interface TaskActivityEvent {
     external_id: string;

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

@@ -0,0 +1,58 @@
+/**
+ * The top bar of a thread that runs a workflow: the workflow's named steps (done, under way, still
+ * to come), with everything that actually happened in the thread attached to the step it happened
+ * during — the assistant's turns, a draft sent back, people's messages and edits, notifications.
+ * What happened before the first step or after the last stays as ordinary entries at either end.
+ * A thread without a workflow shows `TaskFlow` instead.
+ */
+import type { ReactNode } from 'react';
+import { type WorkflowStepPhase } from '../workflows/run';
+import type { WorkflowStep, WorkflowStepState } from '../workflows/types';
+import type { TaskFlowItem } from './TaskFlow';
+/** An activity entry, with what the strip needs to place it. */
+export interface WorkflowThreadItem extends TaskFlowItem {
+    /** The activity kind (`step_started`, `assistant_responded`, …). */
+    kind?: string;
+    /** For a step event: the step it is about. */
+    step?: string;
+}
+export interface GroupedThreadActivity<T> {
+    before: T[];
+    byStep: Record<string, T[]>;
+    after: T[];
+}
+/**
+ * Place each activity entry (oldest first): an entry belongs to the step whose event came last
+ * before it — or, once that step has finished, to the step the run now waits on (the first one not
+ * finished). Entries before any step event come before the steps, and entries once every step has
+ * finished come after them. Step events themselves are the steps' own status, not entries.
+ */
+export declare function groupThreadActivity<T extends {
+    kind?: string;
+    step?: string;
+}>(steps: WorkflowStep[], items: readonly T[]): GroupedThreadActivity<T>;
+export interface WorkflowThreadStripLabels {
+    /** The popover heading of a step's entries; `{count}` is replaced. */
+    happened: string;
+    nothingYet: string;
+    skip: string;
+}
+export declare const DEFAULT_WORKFLOW_THREAD_STRIP_LABELS: WorkflowThreadStripLabels;
+export interface WorkflowThreadStripProps {
+    steps: WorkflowStep[];
+    /** Each step's state (from `stepStatesFromActivity`). */
+    states: Record<string, WorkflowStepState>;
+    /** The thread's activity, oldest first, as `TaskFlow` items with their kind (and step). */
+    items: readonly WorkflowThreadItem[];
+    renderIcon?: (key: string) => ReactNode;
+    /**
+     * Skip a step (any unfinished one that is not running: the plan guides the thread, it does not
+     * hold it). Absent = no skipping here.
+     */
+    onSkip?: (stepId: string) => void;
+    /** The host's action for a person's step (fill in the form, approve…), shown in its popover. */
+    renderStepAction?: (step: WorkflowStep, phase: WorkflowStepPhase) => ReactNode;
+    labels?: Partial<WorkflowThreadStripLabels>;
+    className?: string;
+}
+export declare function WorkflowThreadStrip({ steps, states, items, renderIcon, onSkip, renderStepAction, labels, className, }: WorkflowThreadStripProps): import("react").JSX.Element;

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

@@ -23,6 +23,7 @@ export { TaskStatusPill, DEFAULT_TASK_STATUS_PILL_LABELS, type TaskStatusPillPro
 export { TaskActivityTimeline, DEFAULT_TASK_ACTIVITY_LABELS, type TaskActivityEvent, type TaskActivityKind, type TaskActivityLabels, type TaskActivityTimelineProps, } from './TaskActivityTimeline';
 export { TaskActivityDialog, type TaskActivityDialogProps } from './TaskActivityDialog';
 export { TaskFlow, ThreadActivity, type TaskFlowItem } from './TaskFlow';
+export { WorkflowThreadStrip, groupThreadActivity, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, type WorkflowThreadItem, type WorkflowThreadStripProps, type WorkflowThreadStripLabels, type GroupedThreadActivity, } from './WorkflowThreadStrip';
 export { compactThreadActivity, type CompactThreadActivity } from './compact-thread-activity';
 export { TaskOutputsCell, DEFAULT_TASK_OUTPUTS_CELL_LABELS, type TaskOutput, type TaskOutputsCellProps, type TaskOutputsCellLabels, } from './TaskOutputsCell';
 export { TaskThreadChip, DEFAULT_TASK_THREAD_CHIP_LABELS, type TaskThreadChipProps, type TaskThreadChipLabels, } from './TaskThreadChip';

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

@@ -0,0 +1,70 @@
+/**
+ * A stepped workflow run, end to end: the stepper, the step in view (a form, an upload, an agent
+ * step or a review) and moving on. The stepper lays the graph out by depth: a sequence is one row,
+ * steps side by side stack in a column. The run comes from `useWorkflowThread` (a thread on the
+ * server) or `useWorkflowPreview`; wording and the agent output's rendering come from the host.
+ */
+import type { ReactNode } from 'react';
+import { type SchemaFormProps } from './SchemaForm';
+import type { WorkflowRunView } from './useWorkflowView';
+import type { WorkflowAgentStep, WorkflowDefinition, WorkflowReviewStep, WorkflowStep, WorkflowStepState, WorkflowUploadStep } from './types';
+export interface WorkflowRunnerLabels {
+    back: string;
+    next: string;
+    skip: string;
+    /** Skips the step in view (any unfinished step: the plan guides the thread, it does not hold it). */
+    skipStep: string;
+    finish: string;
+    approve: string;
+    working: string;
+    /** An agent step about to start (the run will pick it up). */
+    starting: string;
+    retry: string;
+    failed: string;
+    /** A step whose dependencies have not finished; `{steps}` is replaced with their titles. */
+    blocked: string;
+    awaitingReview: string;
+    approved: string;
+    skipped: string;
+    /** An agent step that runs off the main line and delivers its result to it. */
+    branch: string;
+    /** The default finish heading (the workflow's `completion.title` wins). */
+    complete: string;
+    restart: string;
+    /** The upload step's file list heading; `{count}` is replaced. */
+    filesHeading: string;
+    noFiles: string;
+}
+export declare const DEFAULT_WORKFLOW_RUNNER_LABELS: WorkflowRunnerLabels;
+/** A file the upload step lists (what is already in the run's workspace). */
+export interface WorkflowRunnerFile {
+    id: string;
+    name: string;
+}
+export interface WorkflowRunnerProps extends Pick<SchemaFormProps, 'renderScope' | 'renderDocuments' | 'renderIcon'> {
+    workflow: WorkflowDefinition;
+    run: WorkflowRunView;
+    /** An agent step's output (its answer, a drafted document). */
+    renderAgentOutput: (step: WorkflowAgentStep, state: WorkflowStepState | undefined) => ReactNode;
+    /** A review's extras while it waits (e.g. who to ask). */
+    renderReview?: (step: WorkflowReviewStep) => ReactNode;
+    /** Upload step: the host performs the upload into the run's workspace. */
+    onUpload?: (files: File[]) => void | Promise<void>;
+    uploading?: boolean;
+    /** What the run's workspace holds, listed on the upload step. */
+    files?: WorkflowRunnerFile[];
+    /** Replaces an upload step's body. */
+    renderUpload?: (step: WorkflowUploadStep) => ReactNode;
+    /** Extra content under a step's body (e.g. what a commit created). */
+    renderStepNote?: (step: WorkflowStep, run: WorkflowRunView) => ReactNode;
+    /** Replaces the finish screen. */
+    renderComplete?: (run: WorkflowRunView) => ReactNode;
+    labels?: Partial<WorkflowRunnerLabels>;
+    /**
+     * Test ids: `<prefix>-step-<id>` (pill), `<prefix>-<id>` (body), `<prefix>-field-<name>`,
+     * `<prefix>-next` / `-back`, `<prefix>-done`.
+     */
+    testIdPrefix?: string;
+    className?: string;
+}
+export declare function WorkflowRunner({ workflow, run, renderAgentOutput, renderReview, onUpload, uploading, files, renderUpload, renderStepNote, renderComplete, renderScope, renderDocuments, renderIcon, labels, testIdPrefix, className, }: WorkflowRunnerProps): import("react").JSX.Element;

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

@@ -1,5 +1,5 @@
 export * from './types';
-export { composeWorkflowPrompt, buildLaunch, defaultInputs, validateInputs, isWorkflowScope, isEmptyWorkflowScope, skillToWorkflow, promptFieldName, SKILL_PROMPT_LABEL, SKILL_PROMPT_FALLBACK_PLACEHOLDER, workflowFromFrontmatter, workflowAccepts, workflowsAccepting, workflowsForHost, inputsFromContext, type SkillLike, type WorkflowComposeContext, type WorkflowContext, } from './workflow';
+export { composeWorkflowPrompt, buildLaunch, defaultInputs, validateInputs, isWorkflowScope, isEmptyWorkflowScope, skillToWorkflow, promptFieldName, SKILL_PROMPT_LABEL, SKILL_PROMPT_FALLBACK_PLACEHOLDER, workflowFromFrontmatter, fieldToFrontmatter, workflowAccepts, workflowsAccepting, workflowsForHost, inputsFromContext, type SkillLike, type WorkflowComposeContext, type WorkflowContext, } from './workflow';
 export { SchemaForm, DEFAULT_SCHEMA_FORM_LABELS, type SchemaFormProps, type SchemaFormLabels, } from './SchemaForm';
 export { AgentSelect, DEFAULT_AGENT_SELECT_LABELS, type AgentSelectProps, type AgentSelectLabels, type AgentOption, } from './AgentSelect';
 export { WorkflowConfigDialog, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, type WorkflowConfigDialogProps, type WorkflowConfigDialogLabels, type WorkflowScopeSource, } from './WorkflowConfigDialog';
@@ -7,3 +7,9 @@ export { defaultScopeRenderer, resolveScopeInputs } from './scopeRender';
 export { WorkflowLauncher, type WorkflowLauncherProps } from './WorkflowLauncher';
 export { buildWorkflowScopeSource, matchWorkflowScope, type WorkflowScopeDocument, type WorkflowScopeLabel, } from './workspaceScope';
 export { WorkflowDocumentsField, type WorkflowDocumentsFieldProps } from './WorkflowDocumentsField';
+export { workflowSteps, isSteppedWorkflow, stepDependencies, dependsOn, orderSteps, validateWorkflowGraph, stepLevels, stepStatesFromActivity, runFields, initialRunInputs, stepPhase, isRunFinished, isPersonStep, nextAction, validateStep, fillRunText, fillStepInputs, runThreadTitle, reviewInstructions, composeStepPrompt, type StepComposeOptions, type WorkflowActivityEvent, type WorkflowGraphProblem, type WorkflowStepPhase, type WorkflowNextAction, } from './run';
+export { toPlanSteps, fromPlanSteps, layoutFromPlanSteps, type TaskPlanStep, type ToPlanOptions, } from './planSteps';
+export { workflowToSkillMarkdown, workflowFromSkillMarkdown, skillSlug } from './skillMarkdown';
+export { useWorkflowView, type UseWorkflowViewOptions, type WorkflowRunView, } from './useWorkflowView';
+export { useWorkflowPreview, type UseWorkflowPreviewOptions } from './useWorkflowPreview';
+export { WorkflowRunner, DEFAULT_WORKFLOW_RUNNER_LABELS, type WorkflowRunnerProps, type WorkflowRunnerLabels, type WorkflowRunnerFile, } from './WorkflowRunner';

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

@@ -0,0 +1,28 @@
+/**
+ * A stepped workflow as the plan a run thread carries (`TaskPlan.steps`) and back. The server reads
+ * the structure to start each step: an agent step runs a skill (`skill` + `inputs` templates) or a
+ * prompt (filled from the run's inputs as it starts); everything only a client shows (form fields,
+ * icon, canvas position, which workflow a step names) rides along in `ui`.
+ */
+import type { components } from '@arbidocs/client';
+import { type StepComposeOptions } from './run';
+import type { WorkflowDefinition, WorkflowInputs, WorkflowStep } from './types';
+export type TaskPlanStep = components['schemas']['TaskPlanStep'];
+export type TaskPlan = components['schemas']['TaskPlan'];
+export interface ToPlanOptions extends StepComposeOptions {
+    /**
+     * The run's inputs when it starts: prompts are composed with them. Fields not given yet (or
+     * absent altogether, saving a workflow to run later) keep `{{field}}` placeholders, which the
+     * server fills from the run's inputs.
+     */
+    inputs?: WorkflowInputs;
+}
+/** The plan steps a run thread (or a saved workflow) carries for `workflow`. */
+export declare function toPlanSteps(workflow: WorkflowDefinition, options?: ToPlanOptions): TaskPlanStep[];
+/** Steps from a run's (or a saved workflow's) plan: what the runner, the builder and the top bar show. */
+export declare function fromPlanSteps(steps: TaskPlanStep[] | null | undefined): WorkflowStep[];
+/** Where each step sits on the builder's canvas, as the plan keeps it. */
+export declare function layoutFromPlanSteps(steps: TaskPlanStep[] | null | undefined): Record<string, {
+    x: number;
+    y: number;
+}> | undefined;

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

@@ -0,0 +1,97 @@
+/**
+ * The model of a stepped workflow (`run: { kind: 'steps' }`): the steps form a graph (each waits
+ * for the steps in its `after`), and a run's progress is each step's `WorkflowStepState`, as the
+ * run's thread records it (`stepStatesFromActivity`). Pure functions, shared by the thread runner
+ * (`useWorkflowThread`), the builder's preview and the thread's top bar.
+ */
+import type { WorkflowAgentStep, WorkflowDefinition, WorkflowErrors, WorkflowInputs, WorkflowReviewStep, WorkflowStep, WorkflowStepState } from './types';
+/** A stepped workflow's steps; empty for a single-run one. */
+export declare function workflowSteps(workflow: WorkflowDefinition): WorkflowStep[];
+export declare const isSteppedWorkflow: (workflow: WorkflowDefinition) => boolean;
+/** What a step waits for: its `after`, else the step before it in the list (a sequence). */
+export declare function stepDependencies(steps: WorkflowStep[], id: string): string[];
+/** `a` waits for `b`, directly or through other steps. */
+export declare function dependsOn(steps: WorkflowStep[], a: string, b: string): boolean;
+/**
+ * The steps in dependency order, keeping the given order wherever the graph allows (a stable
+ * topological sort). Every implicit dependency is written out as `after` first, so reordering
+ * never changes what a step waits for. Steps in a cycle keep their place at the end; validation
+ * reports them.
+ */
+export declare function orderSteps(steps: WorkflowStep[]): WorkflowStep[];
+export type WorkflowGraphProblem = {
+    code: 'duplicate';
+    step: string;
+} | {
+    code: 'unknown';
+    step: string;
+    dependency: string;
+} | {
+    code: 'cycle';
+    step: string;
+} | {
+    code: 'order';
+    step: string;
+    dependency: string;
+};
+/** What makes a stepped workflow unrunnable. Empty = valid. */
+export declare function validateWorkflowGraph(steps: WorkflowStep[]): WorkflowGraphProblem[];
+/**
+ * The steps by depth (the longest chain before each): what the stepper shows side by side.
+ * A sequence is one step per level.
+ */
+export declare function stepLevels(steps: WorkflowStep[]): WorkflowStep[][];
+/** One entry of a thread's activity log, as far as steps are concerned. */
+export interface WorkflowActivityEvent {
+    kind: string;
+    detail?: Record<string, unknown> | null;
+}
+/** Each step's state from the thread's activity log (oldest first): its latest step event wins. */
+export declare function stepStatesFromActivity(events: WorkflowActivityEvent[]): Record<string, WorkflowStepState>;
+/** Every field the run asks for: the launch form's, then each form step's. */
+export declare function runFields(workflow: WorkflowDefinition): import("./types").WorkflowField[];
+/** A fresh run's inputs: every field at its default, then the prefills. */
+export declare function initialRunInputs(workflow: WorkflowDefinition, inputs?: WorkflowInputs): WorkflowInputs;
+/**
+ * Where a step stands: `blocked` until everything it waits for has finished (done or skipped),
+ * then `ready`, then its own status.
+ */
+export type WorkflowStepPhase = 'blocked' | 'ready' | 'running' | 'done' | 'skipped' | 'failed';
+export declare function stepPhase(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, id: string): WorkflowStepPhase;
+export declare const isRunFinished: (steps: WorkflowStep[], states: Record<string, WorkflowStepState>) => boolean;
+/** A step a person does (form, upload, review); agent steps run themselves. */
+export declare const isPersonStep: (step: WorkflowStep) => boolean;
+/**
+ * What the primary button does on the step in view:
+ * - `complete`: finish this form, upload or review (approve) and move on;
+ * - `move`: view the next step: this one is finished, or the next does not wait for it;
+ * - `skip`: give up on this agent step (it failed) so what waits for it can go on;
+ * - `finish`: show the completion (every step has finished);
+ * - `wait`: nothing yet (this step is under way and the next waits for it, or it is blocked).
+ */
+export type WorkflowNextAction = 'complete' | 'move' | 'skip' | 'finish' | 'wait';
+export declare function nextAction(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, current: string | null): WorkflowNextAction;
+/** A form step's problems (empty = it can move on); other steps have none. */
+export declare function validateStep(step: WorkflowStep, inputs: WorkflowInputs): WorkflowErrors;
+/**
+ * Fill a step's `with` templates from the run's inputs: `{{a}}`, `{{a || b}}` (first non-blank).
+ * A template that is exactly one bare reference passes the value through untouched.
+ */
+export declare function fillStepInputs(templates: Record<string, string> | undefined, inputs: WorkflowInputs): WorkflowInputs;
+/** A template over the run's inputs, as text (`{{a}}`, `{{a || b}}`). */
+export declare function fillRunText(template: string, inputs: WorkflowInputs): string;
+/** The run thread's title: the workflow's `threadTitle` template, else its title. */
+export declare function runThreadTitle(workflow: WorkflowDefinition, inputs: WorkflowInputs): string;
+/** What a review asks for: its instructions filled from the run, else its title. */
+export declare function reviewInstructions(step: WorkflowReviewStep, inputs: WorkflowInputs): string;
+export interface StepComposeOptions {
+    /** Looks up the workflow a step names (`step.workflow`). */
+    resolveWorkflow?: (id: string) => WorkflowDefinition | undefined;
+    /**
+     * The host's wording for `operation` runs: the named workflow's id (or the step's own id when it
+     * runs inline), its filled inputs, and the whole run's inputs (e.g. to ground it in the record).
+     */
+    compose?: (id: string, inputs: WorkflowInputs, runInputs: WorkflowInputs) => string | undefined;
+}
+/** The prompt an agent step of `workflow` sends; '' when nothing could compose it (no binding). */
+export declare function composeStepPrompt(workflow: WorkflowDefinition, step: WorkflowAgentStep, runInputs: WorkflowInputs, { resolveWorkflow, compose }?: StepComposeOptions): string;

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

@@ -0,0 +1,15 @@
+/**
+ * A skill's form and prompt as SKILL.md text and back: how a built-in becomes a skill of the user's
+ * own ("Make a copy"). A skill is one step; a flow of steps is a workflow (`toPlanSteps`).
+ *
+ * The frontmatter is the line-based `key: value` form the backend parser reads. `inputs` is one
+ * line of JSON (valid YAML flow style): the backend ignores keys it does not know, and
+ * `workflowFromSkillMarkdown` reads it back.
+ */
+import type { WorkflowDefinition } from './types';
+/** A skill slug: lowercase letters, digits and hyphens (what the backend accepts). */
+export declare const skillSlug: (raw: string) => string;
+/** SKILL.md text for a prompt workflow: frontmatter (name, description, form) then the prompt. */
+export declare function workflowToSkillMarkdown(workflow: WorkflowDefinition): string;
+/** Read a SKILL.md back into a workflow (the inverse of `workflowToSkillMarkdown`). */
+export declare function workflowFromSkillMarkdown(id: string, text: string): WorkflowDefinition;

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

@@ -71,7 +71,115 @@ export type WorkflowRun =
 /** The host performs it (bound by workflow id), e.g. create a label then generate. */
  | {
     kind: 'operation';
+}
+/**
+ * A guided run of named steps that form a graph. A run is a work thread on the server: the
+ * thread's plan carries the steps (`toPlanSteps`), its activity log records each step's progress,
+ * and the work runner starts each agent step as a turn in the thread. A person does the form,
+ * upload and review steps (`useWorkflowThread` / `WorkflowRunner`). Not schedulable from a single
+ * form: a workflow (automation) carries the steps and its trigger (`WorkflowBuilder`).
+ */
+ | {
+    kind: 'steps';
+    /** The run thread's title, a template over the run's inputs; defaults to the workflow's. */
+    threadTitle?: string;
+    /** In dependency order: a step only waits for steps listed before it (`orderSteps`). */
+    steps: WorkflowStep[];
+    completion?: WorkflowCompletion;
+    /** Where each step sits on the builder's canvas, by step id. */
+    layout?: Record<string, {
+        x: number;
+        y: number;
+    }>;
 };
+interface WorkflowStepBase {
+    /** Unique within the workflow (`[a-z][a-z0-9_-]*`): the thread's progress is keyed by it. */
+    id: string;
+    /** The step's name: the stepper and the thread's top bar show it. */
+    title: string;
+    /** One line under the step's heading. */
+    description?: string;
+    /** Key into the host's icon map. */
+    icon?: string;
+    /**
+     * The host commits this step before the run moves on (`commit[id]`), e.g. creates the record
+     * later steps work in. Once committed the step's inputs are locked.
+     */
+    commit?: boolean;
+    /** Primary button text while on this step (until it is committed); defaults to "Continue". */
+    nextLabel?: string;
+    /**
+     * The steps this one waits for. Absent: the step before it in the list, so a plain list is a
+     * sequence. `[]`: it starts with the run. A step waiting for several waits for them all.
+     */
+    after?: string[];
+}
+/** Ask for inputs. Every step's fields share the run's one input namespace (`{{name}}`). */
+export interface WorkflowFormStep extends WorkflowStepBase {
+    kind: 'form';
+    inputs: WorkflowField[];
+}
+/** Add files to the run's workspace. Skippable unless `required`. */
+export interface WorkflowUploadStep extends WorkflowStepBase {
+    kind: 'upload';
+    required?: boolean;
+    /** `accept` of the file picker, e.g. `.pdf,.docx`. */
+    accept?: string;
+    /** Small muted line under the drop target. */
+    hint?: string;
+}
+/**
+ * A turn the assistant takes in the run's thread. It runs a skill or another workflow
+ * (`workflow`, its inputs filled from `with`) or its own `run`. It continues the thread's main
+ * line, so it sees everything before it; a `branch` step runs off the main line instead and
+ * delivers only its result back to it.
+ */
+export interface WorkflowAgentStep extends WorkflowStepBase {
+    kind: 'agent';
+    /** Id of the skill or workflow this step runs; its inputs come from `with`. */
+    workflow?: string;
+    /**
+     * The named workflow's inputs, each a template over the run's inputs: `{{client}}`, with
+     * `{{a || b}}` falling back to `b` when `a` is blank. A bare `{{name}}` passes the value as is.
+     */
+    with?: Record<string, string>;
+    /** Used when no `workflow` is named. `operation`: the host composes the prompt (`compose`). */
+    run?: Extract<WorkflowRun, {
+        kind: 'prompt';
+    } | {
+        kind: 'operation';
+    }>;
+    /** What the step shows: the answer (default) or the drafted document. */
+    output?: 'answer' | 'artifact';
+    /** Runs off the thread's main line and delivers only its result to it. */
+    branch?: boolean;
+}
+/** A person's review or approval: whoever completes it on the thread approves it. */
+export interface WorkflowReviewStep extends WorkflowStepBase {
+    kind: 'review';
+    /** What to review, a template over the run's inputs. */
+    instructions?: string;
+}
+export type WorkflowStep = WorkflowFormStep | WorkflowUploadStep | WorkflowAgentStep | WorkflowReviewStep;
+/** The finish screen of a stepped run. */
+export interface WorkflowCompletion {
+    title: string;
+    description?: string;
+    icon?: string;
+}
+/**
+ * Where a step of a run is, as the thread records it: not reached yet (`pending`), `running`,
+ * `done`, `skipped`, or `failed` (it can be retried or skipped).
+ */
+export type WorkflowStepStatus = 'pending' | 'running' | 'done' | 'skipped' | 'failed';
+export interface WorkflowStepState {
+    status: WorkflowStepStatus;
+    /** The step's answer in the thread (an agent step), or the result a branch delivered. */
+    responseId?: string | null;
+    /** The answer's text, once read. */
+    text?: string;
+    error?: string | null;
+}
 export interface WorkflowDefinition {
     /** Execute a document operation directly, without creating a chat. */
     documentAction?: 'annotate_documents' | 'email_documents';
@@ -127,3 +235,4 @@ export type WorkflowInputs = Record<string, WorkflowInputValue>;
 /** Validation problem of one field: the dialog maps the code to a label. */
 export type WorkflowFieldError = 'required' | 'min' | 'max' | 'number';
 export type WorkflowErrors = Record<string, WorkflowFieldError>;
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * A stepped workflow run on screen only (the builder's preview): agent steps run one at a time,
+ * the way the server does, and answer with the prompt they would send. No thread, no agent.
+ */
+import { type StepComposeOptions } from './run';
+import type { WorkflowDefinition } from './types';
+import { type WorkflowRunView } from './useWorkflowView';
+export interface UseWorkflowPreviewOptions extends StepComposeOptions {
+    /** What a stand-in agent step answers; `{prompt}` is replaced with the prompt it would send. */
+    answer?: string;
+    /** How long a stand-in step takes. */
+    delayMs?: number;
+}
+export declare function useWorkflowPreview(workflow: WorkflowDefinition, { answer, delayMs, resolveWorkflow, compose }?: UseWorkflowPreviewOptions): WorkflowRunView;

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

@@ -0,0 +1,54 @@
+/**
+ * The screen side of a stepped run: which step is in view, form problems, and what the primary
+ * button does. The run itself happens elsewhere (the thread on the server, `useWorkflowThread`, or
+ * the builder's preview): this hook gets each step's state and the host's actions, so every host
+ * shows a run the same way (`WorkflowRunner`).
+ */
+import { type WorkflowNextAction, type WorkflowStepPhase } from './run';
+import type { WorkflowErrors, WorkflowInputValue, WorkflowInputs, WorkflowStep, WorkflowStepState } from './types';
+export interface UseWorkflowViewOptions {
+    steps: WorkflowStep[];
+    /** Each step's state (missing = pending). */
+    states: Record<string, WorkflowStepState>;
+    inputs: WorkflowInputs;
+    setInput: (name: string, value: WorkflowInputValue) => void;
+    /** Finish a person's step (a form, an upload, a review's approval). A throw keeps the user on it. */
+    complete: (step: WorkflowStep) => Promise<void>;
+    /** Give up on a step so what waits for it can go on. */
+    skip: (stepId: string) => Promise<void>;
+    /** Run a failed agent step again. */
+    retry?: (stepId: string) => Promise<void>;
+    /** A form step whose inputs can no longer change (committed, or recorded on the thread). */
+    isLocked?: (stepId: string) => boolean;
+}
+/** What `WorkflowRunner` shows and does. */
+export interface WorkflowRunView {
+    steps: WorkflowStep[];
+    /** The step in view; `undefined` once the run's completion is shown. */
+    step: WorkflowStep | undefined;
+    current: string | null;
+    isComplete: boolean;
+    inputs: WorkflowInputs;
+    setInput: (name: string, value: WorkflowInputValue) => void;
+    stateOf: (stepId: string) => WorkflowStepState | undefined;
+    phaseOf: (stepId: string) => WorkflowStepPhase;
+    isLocked: (stepId: string) => boolean;
+    /** The form step in view's problems, shown once moving on was attempted. */
+    errors: WorkflowErrors;
+    /** An action is under way (completing, skipping). */
+    busy: boolean;
+    actionError: string | null;
+    /** Some agent step is running. */
+    isRunning: boolean;
+    action: WorkflowNextAction;
+    canBack: boolean;
+    next: () => Promise<void>;
+    back: () => void;
+    /** View a step (one further down the plan too: it can be skipped from there). */
+    goTo: (stepId: string) => void;
+    skip: (stepId: string) => Promise<void>;
+    retry?: (stepId: string) => Promise<void>;
+    /** Show the run from the start again (a host that starts a new run resets its own state). */
+    restart: () => void;
+}
+export declare function useWorkflowView(options: UseWorkflowViewOptions): WorkflowRunView;

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

@@ -1,4 +1,4 @@
-import { type WorkflowDefinition, type WorkflowErrors, type WorkflowContextKind, type WorkflowInputs, type WorkflowLaunch, type WorkflowScope } from './types';
+import { type WorkflowDefinition, type WorkflowErrors, type WorkflowField, type WorkflowContextKind, type WorkflowInputs, type WorkflowLaunch, type WorkflowScope } from './types';
 export declare const isWorkflowScope: (value: unknown) => value is WorkflowScope;
 export declare const isEmptyWorkflowScope: (scope: WorkflowScope) => boolean;
 /** The inputs a fresh form starts with: each field's default, else an empty value of its type. */
@@ -60,3 +60,5 @@ export declare function skillToWorkflow(skill: SkillLike): WorkflowDefinition;
  * template). The inverse of what the backend will publish; seeded workflows use the same shape.
  */
 export declare function workflowFromFrontmatter(id: string, frontmatter: Record<string, unknown>, body: string): WorkflowDefinition;
+/** snake_case keys of the on-disk form of a field (what `workflowFromFrontmatter` reads). */
+export declare function fieldToFrontmatter(field: WorkflowField): Record<string, unknown>;