Spaces:
Running
Running
| import type { Edge, Node } from "@xyflow/react"; | |
| /** Port data types, derived from Gradio component kinds. */ | |
| export type DataType = | |
| | "text" | |
| | "number" | |
| | "boolean" | |
| | "image" | |
| | "audio" | |
| | "video" | |
| | "file" | |
| | "gallery" | |
| | "json" | |
| | "any"; | |
| export type Category = "Inputs" | "Utilities" | "Spaces" | "Functions"; | |
| export type WidgetValue = string | number | boolean; | |
| export type WidgetDef = | |
| | { kind: "text"; id: string; label: string; default: string; placeholder?: string } | |
| | { kind: "textarea"; id: string; label: string; default: string; placeholder?: string; /** Always show the expanded editor (notes, prompts). */ block?: boolean } | |
| | { kind: "number"; id: string; label: string; default: number; min?: number; max?: number; step?: number; precision?: number } | |
| | { kind: "slider"; id: string; label: string; default: number; min: number; max: number; step?: number; precision?: number } | |
| | { kind: "seed"; id: string; label: string; default: number } | |
| | { kind: "select"; id: string; label: string; default: string; options: readonly string[]; /** Raw choice values when the Space uses non-string choices (numbers, booleans), parallel to `options`. */ raw?: readonly (string | number | boolean)[] } | |
| | { kind: "toggle"; id: string; label: string; default: boolean } | |
| /** A file input: value is a URL, or `local:<id>` for a file picked in the browser. */ | |
| | { kind: "file"; id: string; label: string; default: string; accept: DataType }; | |
| export interface Port { | |
| id: string; | |
| label: string; | |
| type: DataType; | |
| /** Inputs only: how the value is entered when nothing is wired in. */ | |
| widget?: WidgetDef; | |
| /** Inputs only: the Gradio component this maps to (for payload shaping). */ | |
| component?: string; | |
| optional?: boolean; | |
| } | |
| export interface SpaceRef { | |
| id: string; | |
| apiName: string; | |
| /** Gradio dependency id (fn_index) for the queue protocol. */ | |
| fnIndex: number; | |
| triggerId: number | null; | |
| host: string; | |
| apiPrefix: string; | |
| /** Component ids of outputs, in order. */ | |
| outputComponents: string[]; | |
| /** | |
| * The queue protocol wants one value per dependency input component, but /info lists only the | |
| * ones that take a value (State, buttons and the like are skipped). inputSlots[i] is the port | |
| * index that fills dependency input i, or null for a component that gets no value. | |
| */ | |
| inputSlots?: (number | null)[]; | |
| /** outputSlots[k]: which entry of the returned data list is port k (State outputs are skipped). */ | |
| outputSlots?: number[]; | |
| } | |
| export interface NodeDef { | |
| type: string; | |
| title: string; | |
| category: Category; | |
| description: string; | |
| inputs: Port[]; | |
| outputs: Port[]; | |
| /** Pure widgets (not wirable), used by input nodes. */ | |
| widgets: WidgetDef[]; | |
| width?: number; | |
| /** Colour accent; defaults to the first output type. */ | |
| accent?: DataType; | |
| /** Set for nodes that call a Space endpoint. */ | |
| space?: SpaceRef; | |
| /** Set for input nodes: which widget value is exposed on the single output. */ | |
| emits?: string; | |
| /** Simulated cost is gone; 0 marks nodes that never execute (groups, notes). */ | |
| cost?: number; | |
| } | |
| export type NodeStatus = "idle" | "queued" | "running" | "done" | "error"; | |
| export type NodeMode = "always" | "bypass" | "never"; | |
| /** A file produced by a Space, as returned in its output payload. */ | |
| export interface FileRef { | |
| url: string; | |
| name?: string; | |
| mime?: string; | |
| } | |
| export type OutputValue = string | number | boolean | FileRef | FileRef[] | null | Record<string, unknown> | unknown[]; | |
| export interface CanvasNodeData extends Record<string, unknown> { | |
| defType: string; | |
| title?: string; | |
| values: Record<string, WidgetValue>; | |
| collapsed?: boolean; | |
| mode: NodeMode; | |
| status: NodeStatus; | |
| progress: number; | |
| /** True while `progress` is extrapolated from past run times rather than reported by the Space. */ | |
| progressEstimated?: boolean; | |
| /** Short live status, e.g. queue rank or ETA. */ | |
| statusText?: string; | |
| error?: string; | |
| /** Results of the last run, keyed by output port id. */ | |
| outputs?: Record<string, OutputValue>; | |
| /** Hash of the inputs that produced `outputs`; lets unchanged nodes skip. */ | |
| cacheKey?: string; | |
| /** Pinned in place: can't be dragged. */ | |
| locked?: boolean; | |
| /** Colour tag (a key of NODE_COLORS). */ | |
| color?: string; | |
| /** Free-form note shown under the header. */ | |
| note?: string; | |
| /** Group nodes only: the reusable function this group was made from. */ | |
| fnId?: string; | |
| /** Group nodes only, derived for display: ports shown while collapsed. */ | |
| groupPorts?: { inputs: GroupPort[]; outputs: GroupPort[] }; | |
| } | |
| export type CanvasNode = Node<CanvasNodeData, "space" | "group">; | |
| export type CanvasEdge = Edge<{ type: DataType; flowing?: boolean }, "typed">; | |
| /** One line of the run log; the copilot reads these to diagnose failures. */ | |
| export interface LogEntry { | |
| t: number; | |
| level: "info" | "warn" | "error"; | |
| node?: string; | |
| msg: string; | |
| } | |
| export interface HistoryItem { | |
| id: string; | |
| workflow: string; | |
| finishedAt: number; | |
| durationMs: number; | |
| nodes: number; | |
| status: "done" | "cancelled" | "error"; | |
| thumb?: string; | |
| error?: string; | |
| /** The graph as it was when the run finished, outputs included, so it can be restored. */ | |
| graph?: GraphSnapshot; | |
| /** Set when this run was one cell of a batch / sweep. */ | |
| batch?: BatchRef; | |
| /** Which widget values this run set before starting (seeds, the swept text). */ | |
| vary?: VaryRef[]; | |
| } | |
| /** Where a run sits in its batch grid: rows are sweep lines, columns are seed variations. */ | |
| export interface BatchRef { | |
| id: string; | |
| index: number; | |
| count: number; | |
| rows: number; | |
| cols: number; | |
| row: number; | |
| col: number; | |
| /** What the rows / columns vary ("prompt", "seed"). */ | |
| rowLabel?: string; | |
| colLabel?: string; | |
| } | |
| export interface VaryRef { | |
| nodeId: string; | |
| widgetId: string; | |
| label: string; | |
| value: WidgetValue; | |
| } | |
| export interface GraphSnapshot { | |
| nodes: CanvasNode[]; | |
| edges: CanvasEdge[]; | |
| order: string[]; | |
| } | |
| export interface QueueItem { | |
| id: string; | |
| workflow: string; | |
| queuedAt: number; | |
| /** Run only these nodes and what they depend on. */ | |
| targets?: string[]; | |
| /** Widget values to set just before this item runs (batch runs and sweeps). */ | |
| apply?: { nodeId: string; widgetId: string; value: WidgetValue }[]; | |
| /** Ignore cached outputs on the targets so they call their Space again. */ | |
| force?: boolean; | |
| batch?: BatchRef; | |
| } | |
| export type ViewMode = "canvas" | "pipeline"; | |
| export interface GroupPort extends Port { | |
| nodeId: string; | |
| portId: string; | |
| } | |
| export interface FunctionDef { | |
| id: string; | |
| name: string; | |
| description: string; | |
| nodes: CanvasNode[]; | |
| edges: CanvasEdge[]; | |
| } | |
| export type SpaceStage = "RUNNING" | "SLEEPING" | "BUILDING" | "PAUSED" | "STOPPED" | "RUNTIME_ERROR" | "NO_APP_FILE" | "CONFIG_ERROR" | "BUILD_ERROR" | "DELETING" | "APP_STARTING" | "UNKNOWN"; | |
| export interface SpaceSummary { | |
| id: string; | |
| author: string; | |
| name: string; | |
| title: string; | |
| emoji: string; | |
| likes: number; | |
| sdk?: string; | |
| stage: SpaceStage; | |
| hardware: string | null; | |
| zeroGpu: boolean; | |
| subdomain: string; | |
| shortDescription?: string; | |
| /** Card gradient colours from the Space README, as Hugging Face shows them. */ | |
| colorFrom?: string; | |
| colorTo?: string; | |
| private?: boolean; | |
| } | |
| /** A Space added to the workflow, with the node defs derived from its API. */ | |
| export interface SpaceEntry { | |
| summary: SpaceSummary; | |
| host: string; | |
| apiPrefix: string; | |
| version?: string; | |
| defs: NodeDef[]; | |
| status: "loading" | "ready" | "error"; | |
| error?: string; | |
| loadedAt?: number; | |
| } | |
| export interface WorkflowTemplate { | |
| id: string; | |
| name: string; | |
| description: string; | |
| /** Space ids that must be loaded before the graph can be built. */ | |
| spaces: string[]; | |
| build: (defsOf: (spaceId: string) => NodeDef[]) => { nodes: CanvasNode[]; edges: CanvasEdge[] }; | |
| } | |
| /** The on-disk workflow file. */ | |
| export interface WorkflowFile { | |
| version: 1; | |
| /** Stable id of the saved document (cloud sync key). Absent in older files. */ | |
| id?: string; | |
| /** ms epoch of the last edit that was saved. */ | |
| updatedAt?: number; | |
| /** Changed by the user (not just a template as loaded). */ | |
| edited?: boolean; | |
| name: string; | |
| nodes: CanvasNode[]; | |
| edges: CanvasEdge[]; | |
| order: string[]; | |
| functions: FunctionDef[]; | |
| /** Schema snapshot so the graph renders before live schemas arrive. */ | |
| spaces: SpaceEntry[]; | |
| } | |