@d34dman/flowdrop 0.0.56 → 0.0.58

package/dist/types/agentspec.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Open Agent Specification (Agent Spec) TypeScript Types
+ *
+ * Type definitions mirroring Oracle's Open Agent Spec format.
+ * Used for bidirectional conversion between FlowDrop and Agent Spec.
+ *
+ * @see https://github.com/oracle/agent-spec
+ * @see https://oracle.github.io/agent-spec/
+ */
+/** Agent Spec node component_type discriminator values */
+export type AgentSpecNodeComponentType = 'start_node' | 'end_node' | 'llm_node' | 'api_node' | 'agent_node' | 'flow_node' | 'map_node' | 'branching_node' | 'tool_node';
+/** Agent Spec tool component_type discriminator values */
+export type AgentSpecToolComponentType = 'server_tool' | 'client_tool' | 'remote_tool';
+/** All Agent Spec component_type values */
+export type AgentSpecComponentType = 'agent' | 'flow' | AgentSpecNodeComponentType | AgentSpecToolComponentType | 'llm_config';
+/**
+ * Agent Spec Property — JSON Schema-based input/output definition.
+ *
+ * Uses JSON Schema types and structure for describing data shape.
+ * Placeholder syntax `{{variable_name}}` generates implicit input properties.
+ */
+export interface AgentSpecProperty {
+    /** Property name (used as identifier in edges and templates) */
+    title: string;
+    /** JSON Schema type */
+    type: string;
+    /** Human-readable description */
+    description?: string;
+    /** Default value */
+    default?: unknown;
+    /** Allowed values (JSON Schema enum) */
+    enum?: unknown[];
+    /** Array item schema */
+    items?: AgentSpecProperty;
+    /** Object property schemas */
+    properties?: Record<string, AgentSpecProperty>;
+    /** Required properties (for object types) */
+    required?: string[];
+    /** Additional JSON Schema fields */
+    [key: string]: unknown;
+}
+/** Base interface for all Agent Spec nodes */
+export interface AgentSpecNodeBase {
+    /** Discriminator for node type */
+    component_type: AgentSpecNodeComponentType;
+    /** Node name (used as identifier in edges) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Input properties */
+    inputs?: AgentSpecProperty[];
+    /** Output properties */
+    outputs?: AgentSpecProperty[];
+    /** Extension metadata (includes FlowDrop-specific data for round-trip) */
+    metadata?: Record<string, unknown>;
+}
+/** Graph entry point */
+export interface AgentSpecStartNode extends AgentSpecNodeBase {
+    component_type: 'start_node';
+}
+/** Graph exit point */
+export interface AgentSpecEndNode extends AgentSpecNodeBase {
+    component_type: 'end_node';
+}
+/** LLM text generation node */
+export interface AgentSpecLLMNode extends AgentSpecNodeBase {
+    component_type: 'llm_node';
+    /** LLM configuration (inline or $component_ref string) */
+    llm_config?: AgentSpecLLMConfig | string;
+    /** System prompt template (supports {{variable}} syntax) */
+    system_prompt?: string;
+    /** User prompt template (supports {{variable}} syntax) */
+    prompt_template?: string;
+    /** Output JSON Schema for structured output */
+    output_schema?: Record<string, unknown>;
+}
+/** API call node */
+export interface AgentSpecAPINode extends AgentSpecNodeBase {
+    component_type: 'api_node';
+    /** API endpoint URL */
+    endpoint?: string;
+    /** HTTP method */
+    method?: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body template */
+    body?: Record<string, unknown>;
+}
+/** Multi-round agent conversation node */
+export interface AgentSpecAgentNode extends AgentSpecNodeBase {
+    component_type: 'agent_node';
+    /** Agent reference ($component_ref or inline) */
+    agent?: AgentSpecAgent | string;
+}
+/** Nested flow execution node */
+export interface AgentSpecFlowNode extends AgentSpecNodeBase {
+    component_type: 'flow_node';
+    /** Flow reference ($component_ref or inline) */
+    flow?: AgentSpecFlow | string;
+}
+/** Map-reduce operation node */
+export interface AgentSpecMapNode extends AgentSpecNodeBase {
+    component_type: 'map_node';
+    /** Input collection property name */
+    input_collection?: string;
+    /** Output collection property name */
+    output_collection?: string;
+    /** Flow or node to execute per item ($component_ref or inline) */
+    map_flow?: AgentSpecFlow | string;
+}
+/** Conditional routing node */
+export interface AgentSpecBranchingNode extends AgentSpecNodeBase {
+    component_type: 'branching_node';
+    /** Branch definitions with conditions */
+    branches: AgentSpecBranch[];
+}
+/** Tool execution node */
+export interface AgentSpecToolNode extends AgentSpecNodeBase {
+    component_type: 'tool_node';
+    /** Tool reference ($component_ref or inline) */
+    tool?: AgentSpecTool | string;
+}
+/** Union of all Agent Spec node types */
+export type AgentSpecNode = AgentSpecStartNode | AgentSpecEndNode | AgentSpecLLMNode | AgentSpecAPINode | AgentSpecAgentNode | AgentSpecFlowNode | AgentSpecMapNode | AgentSpecBranchingNode | AgentSpecToolNode;
+/** Branch definition for BranchingNode */
+export interface AgentSpecBranch {
+    /** Branch name (used as from_branch in ControlFlowEdge) */
+    name: string;
+    /** Condition expression for this branch */
+    condition?: string;
+    /** Human-readable description */
+    description?: string;
+}
+/**
+ * Control Flow Edge — defines execution order between nodes.
+ *
+ * Multiple control flow connections from the same branch are prohibited.
+ */
+export interface AgentSpecControlFlowEdge {
+    /** Edge name (identifier) */
+    name: string;
+    /** Source node name */
+    from_node: string;
+    /** Target node name */
+    to_node: string;
+    /** Source branch name (null/undefined = default "next" branch) */
+    from_branch?: string | null;
+}
+/**
+ * Data Flow Edge — routes data between node outputs and inputs.
+ *
+ * Maps a specific output property of a source node to a specific
+ * input property of a destination node.
+ */
+export interface AgentSpecDataFlowEdge {
+    /** Edge name (identifier) */
+    name: string;
+    /** Source node name */
+    source_node: string;
+    /** Source output property title */
+    source_output: string;
+    /** Destination node name */
+    destination_node: string;
+    /** Destination input property title */
+    destination_input: string;
+}
+/**
+ * Agent Spec Flow — a directed, potentially cyclic graph of nodes.
+ *
+ * Flows function as "subroutines" encapsulating repeatable processes.
+ * They separate control-flow (execution order) from data-flow (data routing).
+ */
+export interface AgentSpecFlow {
+    component_type: 'flow';
+    /** Flow name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Reference to the StartNode name */
+    start_node: string;
+    /** All nodes in the flow */
+    nodes: AgentSpecNode[];
+    /** Execution order edges */
+    control_flow_connections: AgentSpecControlFlowEdge[];
+    /**
+     * Data routing edges.
+     * When null, data flows by matching input/output property names
+     * across connected nodes (name-based variable access).
+     */
+    data_flow_connections?: AgentSpecDataFlowEdge[] | null;
+    /** Extension metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Base interface for Agent Spec tools */
+export interface AgentSpecToolBase {
+    component_type: AgentSpecToolComponentType;
+    /** Tool name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Input parameters */
+    inputs?: AgentSpecProperty[];
+    /** Output parameters */
+    outputs?: AgentSpecProperty[];
+    /** Extension metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Tool executed in the same runtime environment */
+export interface AgentSpecServerTool extends AgentSpecToolBase {
+    component_type: 'server_tool';
+    /** Function name or module path */
+    function_name?: string;
+}
+/** Tool executed by the client, results returned to runtime */
+export interface AgentSpecClientTool extends AgentSpecToolBase {
+    component_type: 'client_tool';
+}
+/** Tool triggered via RPC/REST calls */
+export interface AgentSpecRemoteTool extends AgentSpecToolBase {
+    component_type: 'remote_tool';
+    /** Remote endpoint URL */
+    endpoint?: string;
+    /** HTTP method */
+    method?: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+}
+/** Union of all Agent Spec tool types */
+export type AgentSpecTool = AgentSpecServerTool | AgentSpecClientTool | AgentSpecRemoteTool;
+/** LLM model configuration */
+export interface AgentSpecLLMConfig {
+    component_type: 'llm_config';
+    /** Configuration name */
+    name: string;
+    /** Model identifier (e.g., "gpt-4o", "claude-sonnet-4-5-20250929") */
+    model_id: string;
+    /** Provider name (e.g., "openai", "anthropic") */
+    provider?: string;
+    /** API endpoint URL */
+    url?: string;
+    /** Generation parameters (temperature, max_tokens, etc.) */
+    parameters?: Record<string, unknown>;
+    /** Extension metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent Spec Agent — top-level conversational AI system.
+ *
+ * Serves as the entry point and holds shared resources like
+ * tools, memory, and LLM configuration.
+ */
+export interface AgentSpecAgent {
+    component_type: 'agent';
+    /** Agent name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Agent inputs */
+    inputs?: AgentSpecProperty[];
+    /** Agent outputs */
+    outputs?: AgentSpecProperty[];
+    /** Available tools (inline or $component_ref strings) */
+    tools?: (AgentSpecTool | string)[];
+    /** LLM configuration (inline or $component_ref string) */
+    llm_config?: AgentSpecLLMConfig | string;
+    /** System prompt template */
+    system_prompt?: string;
+    /** Extension metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Top-level Agent Spec document.
+ *
+ * Contains a flow and/or agent definition along with shared
+ * tool and LLM configuration declarations.
+ */
+export interface AgentSpecDocument {
+    /** Agent definition */
+    agent?: AgentSpecAgent;
+    /** Flow definition */
+    flow?: AgentSpecFlow;
+    /** Shared tool declarations */
+    tools?: AgentSpecTool[];
+    /** Shared LLM configurations */
+    llm_configs?: AgentSpecLLMConfig[];
+    /** Document-level metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Prefix for component references in Agent Spec */
+export declare const COMPONENT_REF_PREFIX = "$component_ref:";
+/**
+ * Check if a value is a component reference string.
+ *
+ * @example
+ * ```typescript
+ * isComponentRef("$component_ref:my_tool") // true
+ * isComponentRef("just a string") // false
+ * ```
+ */
+export declare function isComponentRef(value: unknown): value is string;
+/**
+ * Extract the component ID from a component reference string.
+ *
+ * @example
+ * ```typescript
+ * extractComponentRefId("$component_ref:my_tool") // "my_tool"
+ * ```
+ */
+export declare function extractComponentRefId(ref: string): string;
+/**
+ * Create a component reference string.
+ *
+ * @example
+ * ```typescript
+ * createComponentRef("my_tool") // "$component_ref:my_tool"
+ * ```
+ */
+export declare function createComponentRef(componentId: string): string;

package/dist/types/agentspec.js

@@ -0,0 +1,48 @@
+/**
+ * Open Agent Specification (Agent Spec) TypeScript Types
+ *
+ * Type definitions mirroring Oracle's Open Agent Spec format.
+ * Used for bidirectional conversion between FlowDrop and Agent Spec.
+ *
+ * @see https://github.com/oracle/agent-spec
+ * @see https://oracle.github.io/agent-spec/
+ */
+// ============================================================================
+// Component Reference
+// ============================================================================
+/** Prefix for component references in Agent Spec */
+export const COMPONENT_REF_PREFIX = '$component_ref:';
+/**
+ * Check if a value is a component reference string.
+ *
+ * @example
+ * ```typescript
+ * isComponentRef("$component_ref:my_tool") // true
+ * isComponentRef("just a string") // false
+ * ```
+ */
+export function isComponentRef(value) {
+    return typeof value === 'string' && value.startsWith(COMPONENT_REF_PREFIX);
+}
+/**
+ * Extract the component ID from a component reference string.
+ *
+ * @example
+ * ```typescript
+ * extractComponentRefId("$component_ref:my_tool") // "my_tool"
+ * ```
+ */
+export function extractComponentRefId(ref) {
+    return ref.slice(COMPONENT_REF_PREFIX.length);
+}
+/**
+ * Create a component reference string.
+ *
+ * @example
+ * ```typescript
+ * createComponentRef("my_tool") // "$component_ref:my_tool"
+ * ```
+ */
+export function createComponentRef(componentId) {
+    return `${COMPONENT_REF_PREFIX}${componentId}`;
+}

package/dist/types/events.d.ts

@@ -6,7 +6,7 @@
  *
  * @module types/events
  */
-import type { Workflow } from './index.js';
+import type { Workflow, NodeExecutionInfo } from './index.js';
 /**
  * Types of workflow changes
  *
@@ -113,6 +113,33 @@ export interface FlowDropEventHandlers {
      * @returns true to suppress default error handling, false/void to show default toast
      */
     onApiError?: (error: Error, operation: string) => boolean | void;
+    /**
+     * Called when an Agent Spec execution starts
+     *
+     * @param executionId - The runtime execution ID
+     */
+    onAgentSpecExecutionStarted?: (executionId: string) => void;
+    /**
+     * Called when an Agent Spec execution completes successfully
+     *
+     * @param executionId - The runtime execution ID
+     * @param results - Execution results from the runtime
+     */
+    onAgentSpecExecutionCompleted?: (executionId: string, results: Record<string, unknown>) => void;
+    /**
+     * Called when an Agent Spec execution fails
+     *
+     * @param executionId - The runtime execution ID
+     * @param error - The error that occurred
+     */
+    onAgentSpecExecutionFailed?: (executionId: string, error: Error) => void;
+    /**
+     * Called when a node's execution status is updated during Agent Spec execution
+     *
+     * @param nodeId - The FlowDrop node ID
+     * @param status - Updated execution info
+     */
+    onAgentSpecNodeStatusUpdate?: (nodeId: string, status: NodeExecutionInfo) => void;
 }
 /**
  * Feature flags for FlowDrop

package/dist/types/index.d.ts

@@ -24,6 +24,20 @@ export type BuiltinNodeCategory = 'triggers' | 'inputs' | 'outputs' | 'prompts'
  * ```
  */
 export type NodeCategory = BuiltinNodeCategory | (string & Record<never, never>);
+/**
+ * Built-in workflow format identifiers that ship with FlowDrop.
+ */
+export type BuiltinWorkflowFormat = 'flowdrop' | 'agentspec';
+/**
+ * Workflow format identifier.
+ * Determines sidebar node filtering and export behavior.
+ * Includes built-in formats plus any custom string for third-party adapters.
+ */
+export type WorkflowFormat = BuiltinWorkflowFormat | (string & Record<never, never>);
+/**
+ * Default workflow format used when none is specified.
+ */
+export declare const DEFAULT_WORKFLOW_FORMAT: WorkflowFormat;
 /**
  * Category definition with metadata for display and organization.
  * Fetched from the `/categories` API endpoint or provided as defaults.
@@ -536,9 +550,22 @@ export interface NodeMetadata {
     inputs: NodePort[];
     outputs: NodePort[];
     configSchema?: ConfigSchema;
+    /**
+     * Optional UI Schema that controls how configSchema fields are
+     * arranged, grouped, and displayed in the configuration form.
+     *
+     * When not provided, fields render in flat order (backward compatible).
+     * Uses JSON Forms-inspired format with VerticalLayout, Group, and Control elements.
+     *
+     * @see UISchemaElement for the element type definitions
+     * @see https://jsonforms.io/docs/uischema
+     */
+    uiSchema?: import('./uischema.js').UISchemaElement;
     /** Default configuration values for this node type */
     config?: Record<string, unknown>;
     tags?: string[];
+    /** Workflow formats this node is compatible with. Omit = universal (all formats). */
+    formats?: WorkflowFormat[];
     /**
      * Admin/Edit configuration for nodes with dynamic or external configuration.
      * Used when the config schema cannot be determined at workflow load time
@@ -1095,6 +1122,8 @@ export interface Workflow {
         tags?: string[];
         versionId?: string;
         updateNumber?: number;
+        /** Workflow format. Determines sidebar filtering and export behavior. */
+        format?: WorkflowFormat;
     };
 }
 /**
@@ -1199,3 +1228,5 @@ export type { AuthProvider, StaticAuthConfig, CallbackAuthConfig } from './auth.
 export { StaticAuthProvider, CallbackAuthProvider, NoAuthProvider } from './auth.js';
 export type { FlowDropSettings, ThemeSettings, EditorSettings, UISettings, BehaviorSettings, ApiSettings, ThemePreference, ResolvedTheme, SettingsCategory, PartialSettings, SyncStatus, SettingsStoreState, SettingsChangeEvent, SettingsChangeCallback } from './settings.js';
 export { DEFAULT_SETTINGS, DEFAULT_THEME_SETTINGS, DEFAULT_EDITOR_SETTINGS, DEFAULT_UI_SETTINGS, DEFAULT_BEHAVIOR_SETTINGS, DEFAULT_API_SETTINGS, SETTINGS_CATEGORIES, SETTINGS_CATEGORY_LABELS, SETTINGS_CATEGORY_ICONS, SETTINGS_STORAGE_KEY } from './settings.js';
+export type { UISchemaElementType, UISchemaElementBase, UISchemaControl, UISchemaVerticalLayout, UISchemaGroup, UISchemaElement } from './uischema.js';
+export { isUISchemaControl, isUISchemaVerticalLayout, isUISchemaGroup } from './uischema.js';

package/dist/types/index.js

@@ -2,6 +2,10 @@
  * Core types for the Workflow Library
  */
 import { ConnectionLineType } from '@xyflow/svelte';
+/**
+ * Default workflow format used when none is specified.
+ */
+export const DEFAULT_WORKFLOW_FORMAT = 'flowdrop';
 /**
  * Convert a DynamicPort to a NodePort
  * @param port - The dynamic port configuration
@@ -20,3 +24,4 @@ export function dynamicPortToNodePort(port, portType) {
 }
 export { StaticAuthProvider, CallbackAuthProvider, NoAuthProvider } from './auth.js';
 export { DEFAULT_SETTINGS, DEFAULT_THEME_SETTINGS, DEFAULT_EDITOR_SETTINGS, DEFAULT_UI_SETTINGS, DEFAULT_BEHAVIOR_SETTINGS, DEFAULT_API_SETTINGS, SETTINGS_CATEGORIES, SETTINGS_CATEGORY_LABELS, SETTINGS_CATEGORY_ICONS, SETTINGS_STORAGE_KEY } from './settings.js';
+export { isUISchemaControl, isUISchemaVerticalLayout, isUISchemaGroup } from './uischema.js';

package/dist/types/uischema.d.ts

@@ -0,0 +1,144 @@
+/**
+ * UISchema Types for FlowDrop Form Layout
+ *
+ * Inspired by JSON Forms (EclipseSource) UISchema specification.
+ * Controls how form fields are arranged, grouped, and displayed
+ * without modifying the underlying data schema (ConfigSchema).
+ *
+ * The UISchema is a separate concern from the data schema:
+ * - ConfigSchema defines what data is valid (validation)
+ * - UISchema defines how the form is rendered (presentation)
+ *
+ * @see https://jsonforms.io/docs/uischema
+ *
+ * @example
+ * ```json
+ * {
+ *   "type": "VerticalLayout",
+ *   "elements": [
+ *     { "type": "Control", "scope": "#/properties/model" },
+ *     {
+ *       "type": "Group",
+ *       "label": "Advanced Settings",
+ *       "collapsible": true,
+ *       "defaultOpen": false,
+ *       "elements": [
+ *         { "type": "Control", "scope": "#/properties/temperature" },
+ *         { "type": "Control", "scope": "#/properties/maxTokens" }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+/**
+ * Supported UISchema element types.
+ * Designed for future extension with HorizontalLayout, Categorization, etc.
+ */
+export type UISchemaElementType = 'VerticalLayout' | 'Group' | 'Control';
+/**
+ * Base interface for all UISchema elements.
+ */
+export interface UISchemaElementBase {
+    /** Discriminator for the element type */
+    type: UISchemaElementType;
+}
+/**
+ * Control element - references a single field in the data schema.
+ * Uses JSON Pointer syntax for the scope path.
+ *
+ * @example
+ * ```json
+ * { "type": "Control", "scope": "#/properties/temperature" }
+ * ```
+ */
+export interface UISchemaControl extends UISchemaElementBase {
+    type: 'Control';
+    /**
+     * JSON Pointer to the property in the data schema.
+     * Must follow the format: #/properties/<fieldName>
+     */
+    scope: string;
+    /**
+     * Optional label override. If not provided, the field's
+     * schema title or key is used.
+     */
+    label?: string;
+}
+/**
+ * Layout container that arranges its child elements vertically.
+ * Can be used as root element or nested inside groups.
+ *
+ * @example
+ * ```json
+ * {
+ *   "type": "VerticalLayout",
+ *   "elements": [
+ *     { "type": "Control", "scope": "#/properties/name" },
+ *     { "type": "Control", "scope": "#/properties/email" }
+ *   ]
+ * }
+ * ```
+ */
+export interface UISchemaVerticalLayout extends UISchemaElementBase {
+    type: 'VerticalLayout';
+    /** Child elements to render vertically */
+    elements: UISchemaElement[];
+}
+/**
+ * Group element - renders a fieldset with a label and optional collapsible behavior.
+ * Extends the JSON Forms Group with FlowDrop-specific collapse options.
+ *
+ * @example
+ * ```json
+ * {
+ *   "type": "Group",
+ *   "label": "Advanced Settings",
+ *   "description": "Fine-tuning parameters",
+ *   "collapsible": true,
+ *   "defaultOpen": false,
+ *   "elements": [
+ *     { "type": "Control", "scope": "#/properties/temperature" },
+ *     { "type": "Control", "scope": "#/properties/maxTokens" }
+ *   ]
+ * }
+ * ```
+ */
+export interface UISchemaGroup extends UISchemaElementBase {
+    type: 'Group';
+    /** Display label for the fieldset legend / summary */
+    label: string;
+    /** Child elements within the group */
+    elements: UISchemaElement[];
+    /** Optional description displayed below the label */
+    description?: string;
+    /**
+     * Whether the group can be collapsed.
+     * When true, renders as `<details>/<summary>`.
+     * @default true
+     */
+    collapsible?: boolean;
+    /**
+     * Whether the group is initially open (expanded).
+     * Only relevant when collapsible is true.
+     * @default true
+     */
+    defaultOpen?: boolean;
+}
+/**
+ * Union type of all supported UISchema elements.
+ * This is the recursive type used in elements arrays.
+ */
+export type UISchemaElement = UISchemaControl | UISchemaVerticalLayout | UISchemaGroup;
+/**
+ * Type guard: checks if element is a Control
+ */
+export declare function isUISchemaControl(element: UISchemaElement): element is UISchemaControl;
+/**
+ * Type guard: checks if element is a VerticalLayout
+ */
+export declare function isUISchemaVerticalLayout(element: UISchemaElement): element is UISchemaVerticalLayout;
+/**
+ * Type guard: checks if element is a Group
+ */
+export declare function isUISchemaGroup(element: UISchemaElement): element is UISchemaGroup;

package/dist/types/uischema.js

@@ -0,0 +1,51 @@
+/**
+ * UISchema Types for FlowDrop Form Layout
+ *
+ * Inspired by JSON Forms (EclipseSource) UISchema specification.
+ * Controls how form fields are arranged, grouped, and displayed
+ * without modifying the underlying data schema (ConfigSchema).
+ *
+ * The UISchema is a separate concern from the data schema:
+ * - ConfigSchema defines what data is valid (validation)
+ * - UISchema defines how the form is rendered (presentation)
+ *
+ * @see https://jsonforms.io/docs/uischema
+ *
+ * @example
+ * ```json
+ * {
+ *   "type": "VerticalLayout",
+ *   "elements": [
+ *     { "type": "Control", "scope": "#/properties/model" },
+ *     {
+ *       "type": "Group",
+ *       "label": "Advanced Settings",
+ *       "collapsible": true,
+ *       "defaultOpen": false,
+ *       "elements": [
+ *         { "type": "Control", "scope": "#/properties/temperature" },
+ *         { "type": "Control", "scope": "#/properties/maxTokens" }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+/**
+ * Type guard: checks if element is a Control
+ */
+export function isUISchemaControl(element) {
+    return element.type === 'Control';
+}
+/**
+ * Type guard: checks if element is a VerticalLayout
+ */
+export function isUISchemaVerticalLayout(element) {
+    return element.type === 'VerticalLayout';
+}
+/**
+ * Type guard: checks if element is a Group
+ */
+export function isUISchemaGroup(element) {
+    return element.type === 'Group';
+}