@bbigbang/core 0.1.0

package/dist/services/workspaceToolLatestStateProjector.js

@@ -0,0 +1,91 @@
+import { log } from '@bbigbang/runtime-acp';
+const REALTIME_STATE_COALESCE_MS = 500;
+export class WorkspaceToolLatestStateProjector {
+    deps;
+    pendingRealtimeStateUpdates = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    hasPendingRealtimeStateUpdate(toolId) {
+        return this.pendingRealtimeStateUpdates.has(toolId);
+    }
+    // Persists latest state and rewrites the tool snapshot panel in one DB
+    // transaction. The state_updated broadcast is intentionally commit-after.
+    updateLatestState(params) {
+        this.deps.snapshotPanels.updateLatestState(params, {
+            onCommitted: () => this.deps.onStateUpdated?.(params),
+        });
+    }
+    // Completion/status sync is diagnostic UI only; callers use the best-effort
+    // wrapper when a snapshot failure must not roll back run completion.
+    syncStatus(toolId, status) {
+        this.deps.snapshotPanels.syncForTool(toolId, status);
+    }
+    syncStatusBestEffort(toolId, status) {
+        try {
+            this.syncStatus(toolId, status);
+        }
+        catch (error) {
+            log.warn('[workspace-tools] failed to sync tool panel snapshot status', {
+                toolId,
+                status,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    scheduleRealtimeStateUpdate(ctx, state) {
+        const existing = this.pendingRealtimeStateUpdates.get(ctx.toolId);
+        if (existing) {
+            existing.state = state;
+            existing.userId = ctx.userId;
+            existing.agentId = ctx.agentId;
+            existing.maintenanceConversationId = ctx.maintenanceConversationId;
+            return;
+        }
+        const timer = setTimeout(() => {
+            this.flushPendingRealtimeStateForTool(ctx.toolId);
+        }, REALTIME_STATE_COALESCE_MS);
+        timer.unref?.();
+        this.pendingRealtimeStateUpdates.set(ctx.toolId, {
+            toolId: ctx.toolId,
+            userId: ctx.userId,
+            agentId: ctx.agentId,
+            maintenanceConversationId: ctx.maintenanceConversationId,
+            state,
+            timer,
+        });
+    }
+    flushPendingRealtimeStateForTool(toolId) {
+        const pending = this.pendingRealtimeStateUpdates.get(toolId);
+        if (!pending)
+            return;
+        this.pendingRealtimeStateUpdates.delete(toolId);
+        clearTimeout(pending.timer);
+        try {
+            this.updateLatestState({
+                toolId: pending.toolId,
+                userId: pending.userId,
+                agentId: pending.agentId,
+                maintenanceConversationId: pending.maintenanceConversationId,
+                state: pending.state,
+            });
+        }
+        catch (error) {
+            log.warn('[workspace-tools] failed to flush realtime tool state', {
+                toolId,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    clearPendingRealtimeStateForTool(toolId) {
+        const pending = this.pendingRealtimeStateUpdates.get(toolId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingRealtimeStateUpdates.delete(toolId);
+    }
+    getToolInfoForActionViewerAfterPendingRealtimeFlush(params) {
+        this.flushPendingRealtimeStateForTool(params.toolId);
+        return this.deps.getToolInfoForActionViewer(params.viewerUserId, params.toolId, params.allowAdminBypass);
+    }
+}

package/dist/services/workspaceToolManifest.js

@@ -0,0 +1,572 @@
+import { z } from 'zod';
+import { WORKSPACE_TOOL_PANEL_ACTION_PARAM_NAMESPACE, buildWorkspaceToolPanelActionParamKey, collectPanelLevelUnsupportedNodes, validatePanelTemplateProps, } from '@bbigbang/protocol';
+import { WorkspaceToolServiceError } from './workspaceToolErrors.js';
+const WORKSPACE_TOOL_ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const WORKSPACE_TOOL_CONDA_ENV_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const WORKSPACE_TOOL_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const WORKSPACE_TOOL_PARAM_INPUTS = ['text', 'textarea', 'number', 'checkbox', 'select', 'multiselect', 'tags', 'date', 'file'];
+const WORKSPACE_TOOL_FILE_PARAM_MAX_BYTES = 5 * 1024 * 1024;
+const workspaceToolParamBoundSchema = z.union([z.number().finite(), z.string()]);
+const workspaceToolParamFieldSchema = z.object({
+    name: z.string().trim().min(1),
+    label: z.string().trim().min(1).optional(),
+    description: z.string().trim().min(1).optional(),
+    input: z.enum(WORKSPACE_TOOL_PARAM_INPUTS).optional(),
+    required: z.boolean().optional(),
+    placeholder: z.string().optional(),
+    defaultValue: z.unknown().optional(),
+    min: workspaceToolParamBoundSchema.optional(),
+    max: workspaceToolParamBoundSchema.optional(),
+    accept: z.string().trim().min(1).optional(),
+    multiple: z.boolean().optional(),
+    maxBytes: z.number().int().positive().max(WORKSPACE_TOOL_FILE_PARAM_MAX_BYTES).optional(),
+    options: z.array(z.object({
+        label: z.string().trim().min(1),
+        value: z.string(),
+    })).optional(),
+});
+const workspaceToolActionManifestSchema = z.object({
+    actionId: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+    description: z.string().trim().min(1).optional(),
+    kind: z.enum(['start', 'stop', 'status', 'restart', 'custom']),
+    mode: z.enum(['platform_exec', 'notify_agent']).optional(),
+    command: z.string().optional(),
+    cwd: z.string().optional(),
+    persistent: z.boolean().optional(),
+    maxRunSeconds: z.number().int().positive().optional(),
+    idleTimeoutSeconds: z.number().int().positive().optional(),
+    paramsSchema: z.array(workspaceToolParamFieldSchema).optional(),
+});
+const workspaceToolExecutionEnvSchema = z.object({
+    condaEnv: z.string().trim().min(1).optional(),
+    vars: z.record(z.string(), z.string()).optional(),
+    cwd: z.string().trim().min(1).optional(),
+}).optional();
+const workspaceToolCliManifestSchema = z.object({
+    entry: z.string().trim().min(1),
+}).optional();
+const workspaceToolRuntimeManifestSchema = z.object({
+    mode: z.enum(['per_action', 'persistent_runtime']).optional(),
+    idleTtlSeconds: z.number().int().positive().optional(),
+    entry: z.string().trim().min(1).optional(),
+    logDir: z.string().trim().min(1).optional(),
+}).optional();
+const workspaceToolManifestSchema = z.object({
+    slug: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    description: z.string().default(''),
+    icon: z.string().trim().min(1).optional(),
+    defaultCwd: z.string().trim().min(1).optional(),
+    env: workspaceToolExecutionEnvSchema,
+    cli: workspaceToolCliManifestSchema,
+    runtime: workspaceToolRuntimeManifestSchema,
+    scope: z.enum(['private', 'channel', 'public']).optional(),
+    scopeChannelId: z.string().trim().min(1).optional().nullable(),
+    allowSharedExec: z.boolean().optional(),
+    service: z.object({
+        port: z.number().int().min(1).max(65535),
+        healthPath: z.string().trim().min(1).optional(),
+    }).optional(),
+    actions: z.array(workspaceToolActionManifestSchema),
+    view: z.object({
+        title: z.string().trim().min(1).optional(),
+        fields: z.array(z.object({
+            name: z.string().trim().min(1),
+            label: z.string().trim().min(1).optional(),
+            type: z.enum(['string', 'number', 'boolean']),
+            filterable: z.boolean().optional(),
+            sortable: z.boolean().optional(),
+        })),
+        mediaSlots: z.array(z.object({
+            name: z.string().trim().min(1),
+            kind: z.literal('workspace_path'),
+            displayType: z.enum(['img', 'latex', 'text']),
+        })).optional(),
+        summary: z.unknown().optional(),
+        parameterForm: z.unknown().optional(),
+        template: z.unknown(),
+    }),
+});
+const TOOL_PARAMETER_FORM_TEXT_TYPES = new Set(['TextInput', 'TextArea']);
+const TOOL_PARAMETER_FORM_NUMBER_TYPES = new Set(['NumberInput', 'Slider']);
+const TOOL_PARAMETER_FORM_SELECT_TYPES = new Set(['Select']);
+const TOOL_PARAMETER_FORM_MULTISELECT_TYPES = new Set(['MultiSelect']);
+const TOOL_PARAMETER_FORM_TAG_TYPES = new Set(['TagInput']);
+const TOOL_PARAMETER_FORM_DATE_TYPES = new Set(['DatePicker']);
+const TOOL_PARAMETER_FORM_FILE_TYPES = new Set(['FileUpload']);
+const TOOL_PARAMETER_FORM_UNSUPPORTED_TYPES = new Set(['Button', 'RunStatusCard', 'RunLogViewer', 'ArtifactList']);
+const TOOL_SUMMARY_UNSUPPORTED_TYPES = new Set([
+    'ActionBar',
+    'TextInput',
+    'TextArea',
+    'NumberInput',
+    'Checkbox',
+    'Select',
+    'MultiSelect',
+    'TagInput',
+    'Slider',
+    'DatePicker',
+    'FileUpload',
+    'Button',
+]);
+export function parseWorkspaceToolManifest(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new WorkspaceToolServiceError('Tool manifest is not valid JSON.', 400);
+    }
+    const result = workspaceToolManifestSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new WorkspaceToolServiceError(`Tool manifest is invalid: ${result.error.issues[0]?.message ?? 'unknown error'}`, 400);
+    }
+    const manifest = result.data;
+    if (manifest.scope === 'channel' && !(manifest.scopeChannelId?.trim())) {
+        throw new WorkspaceToolServiceError('Channel-scoped tools must declare scopeChannelId.', 400);
+    }
+    validateWorkspaceToolExecutionEnv(manifest);
+    validateWorkspaceToolRuntime(manifest);
+    validateWorkspaceToolActionParams(manifest);
+    const actionIds = new Set();
+    for (const action of manifest.actions) {
+        if (actionIds.has(action.actionId)) {
+            throw new WorkspaceToolServiceError(`Duplicate tool action id "${action.actionId}".`, 400);
+        }
+        actionIds.add(action.actionId);
+        if (manifest.runtime?.mode === 'persistent_runtime' && action.kind === 'restart') {
+            throw new WorkspaceToolServiceError('Persistent runtime tools do not support restart actions; use a custom action or stop and invoke again.', 400);
+        }
+        const hasExecutionEntry = manifest.cli?.entry?.trim() || (manifest.runtime?.mode === 'persistent_runtime' && manifest.runtime.entry?.trim());
+        if (actionRequiresCommand(action) && !action.command?.trim() && !hasExecutionEntry) {
+            throw new WorkspaceToolServiceError(`Tool action "${action.actionId}" must declare a command or use manifest cli.entry.`, 400);
+        }
+    }
+    validateWorkspaceToolView(manifest);
+    return manifest;
+}
+export function withPersistedToolSettings(manifest, settings) {
+    return {
+        ...manifest,
+        scope: settings.scope,
+        scopeChannelId: settings.scope === 'channel' ? settings.scopeChannelId ?? null : null,
+        allowSharedExec: settings.allowSharedExec,
+    };
+}
+export function sanitizeWorkspaceToolManifestForViewer(manifest, settings) {
+    const persisted = withPersistedToolSettings(manifest, settings);
+    if (settings.isOwner) {
+        return persisted;
+    }
+    return {
+        ...persisted,
+        defaultCwd: undefined,
+        env: undefined,
+        cli: undefined,
+        runtime: undefined,
+        actions: persisted.actions.map((action) => ({
+            actionId: action.actionId,
+            label: action.label,
+            description: action.description,
+            kind: action.kind,
+            mode: action.mode,
+            persistent: action.persistent,
+            maxRunSeconds: action.maxRunSeconds,
+            paramsSchema: action.paramsSchema,
+            cwd: undefined,
+            command: undefined,
+        })),
+    };
+}
+export function resolveWorkspaceToolActionMode(action) {
+    return action.mode ?? 'platform_exec';
+}
+export function actionRequiresCommand(action) {
+    return resolveWorkspaceToolActionMode(action) === 'platform_exec'
+        && (action.kind === 'start'
+            || action.kind === 'status'
+            || action.kind === 'restart'
+            || action.kind === 'custom'
+            || action.persistent === true);
+}
+export function resolveWorkspaceToolActionParamBinding(actions, key) {
+    if (typeof key !== 'string')
+        return null;
+    const namespacePrefix = `${WORKSPACE_TOOL_PANEL_ACTION_PARAM_NAMESPACE}.`;
+    if (!key.startsWith(namespacePrefix))
+        return null;
+    const remainder = key.slice(namespacePrefix.length);
+    const actionIds = [...new Set(actions.map((action) => action.actionId))]
+        .filter((actionId) => actionId.length > 0)
+        .sort((left, right) => right.length - left.length);
+    for (const actionId of actionIds) {
+        const actionPrefix = `${actionId}.`;
+        if (remainder.startsWith(actionPrefix) && remainder.length > actionPrefix.length) {
+            return {
+                actionId,
+                paramName: remainder.slice(actionPrefix.length),
+            };
+        }
+    }
+    return null;
+}
+function validateWorkspaceToolExecutionEnv(manifest) {
+    const env = manifest.env;
+    if (!env)
+        return;
+    if (env.condaEnv && !WORKSPACE_TOOL_CONDA_ENV_PATTERN.test(env.condaEnv)) {
+        throw new WorkspaceToolServiceError('Tool execution env.condaEnv may only contain letters, numbers, dot, underscore, or dash.', 400);
+    }
+    for (const key of Object.keys(env.vars ?? {})) {
+        if (!WORKSPACE_TOOL_ENV_VAR_NAME_PATTERN.test(key)) {
+            throw new WorkspaceToolServiceError(`Tool execution env var "${key}" is invalid.`, 400);
+        }
+    }
+}
+function validateWorkspaceToolRuntime(manifest) {
+    const runtime = manifest.runtime;
+    if (!runtime)
+        return;
+    const mode = runtime.mode ?? 'per_action';
+    if (mode === 'persistent_runtime' && !(runtime.entry?.trim() || manifest.cli?.entry?.trim())) {
+        throw new WorkspaceToolServiceError('Persistent tool runtime must declare runtime.entry or cli.entry.', 400);
+    }
+}
+function validateWorkspaceToolActionParams(manifest) {
+    for (const action of manifest.actions) {
+        const paramNames = new Set();
+        for (const field of action.paramsSchema ?? []) {
+            if (paramNames.has(field.name)) {
+                throw new WorkspaceToolServiceError(`Tool action "${action.actionId}" declares duplicate parameter "${field.name}".`, 400);
+            }
+            paramNames.add(field.name);
+            if ((field.input ?? 'text') === 'file' && resolveWorkspaceToolActionMode(action) !== 'platform_exec') {
+                throw new WorkspaceToolServiceError(`Tool action "${action.actionId}" file parameter "${field.name}" requires platform_exec mode.`, 400);
+            }
+            validateWorkspaceToolParamField(action.actionId, field);
+        }
+    }
+}
+function validateWorkspaceToolParamField(actionId, field) {
+    const input = field.input ?? 'text';
+    if ((input === 'select' || input === 'multiselect') && !field.options?.length) {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" must declare static options for ${input}.`, 400);
+    }
+    if (field.options?.length && input !== 'select' && input !== 'multiselect') {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" options are only supported for select or multiselect inputs.`, 400);
+    }
+    if (input !== 'file' && (field.accept !== undefined || field.multiple !== undefined || field.maxBytes !== undefined)) {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" upload options are only supported for file inputs.`, 400);
+    }
+    if (input === 'file' && field.defaultValue !== undefined) {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" file inputs do not support defaultValue.`, 400);
+    }
+    const optionValues = new Set();
+    for (const option of field.options ?? []) {
+        if (optionValues.has(option.value)) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" has duplicate option value "${option.value}".`, 400);
+        }
+        optionValues.add(option.value);
+    }
+    validateWorkspaceToolParamBounds(actionId, field, input);
+    validateWorkspaceToolParamDefault(actionId, field, input, optionValues);
+}
+function validateWorkspaceToolParamBounds(actionId, field, input) {
+    const bounds = [
+        ['min', field.min],
+        ['max', field.max],
+    ];
+    for (const [key, value] of bounds) {
+        if (value === undefined)
+            continue;
+        if (input === 'number') {
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" ${key} must be a finite number for number inputs.`, 400);
+            }
+            continue;
+        }
+        if (input === 'date') {
+            if (typeof value !== 'string' || !isValidWorkspaceToolDate(value)) {
+                throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" ${key} must be a YYYY-MM-DD date for date inputs.`, 400);
+            }
+            continue;
+        }
+        if (input === 'file') {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" ${key} is not supported for file inputs; use maxBytes instead.`, 400);
+        }
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" ${key} is only supported for number or date inputs.`, 400);
+    }
+    if (input === 'number' && typeof field.min === 'number' && typeof field.max === 'number' && field.min > field.max) {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" min cannot exceed max.`, 400);
+    }
+    if (input === 'date' && typeof field.min === 'string' && typeof field.max === 'string' && field.min > field.max) {
+        throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" min cannot exceed max.`, 400);
+    }
+}
+function validateWorkspaceToolParamDefault(actionId, field, input, optionValues) {
+    if (field.defaultValue === undefined || field.defaultValue === null || field.defaultValue === '')
+        return;
+    const defaultValue = field.defaultValue;
+    if (input === 'number') {
+        const numeric = typeof defaultValue === 'number' ? defaultValue : Number(defaultValue);
+        if (!Number.isFinite(numeric)) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a number.`, 400);
+        }
+        if (typeof field.min === 'number' && numeric < field.min) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be at least ${field.min}.`, 400);
+        }
+        if (typeof field.max === 'number' && numeric > field.max) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be at most ${field.max}.`, 400);
+        }
+        return;
+    }
+    if (input === 'checkbox') {
+        if (typeof defaultValue !== 'boolean') {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a boolean.`, 400);
+        }
+        return;
+    }
+    if (input === 'select') {
+        if (typeof defaultValue !== 'string' || !optionValues.has(defaultValue)) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must match a declared option.`, 400);
+        }
+        return;
+    }
+    if (input === 'multiselect') {
+        if (!Array.isArray(defaultValue) || !defaultValue.every((item) => typeof item === 'string' && optionValues.has(item))) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be an array of declared option values.`, 400);
+        }
+        return;
+    }
+    if (input === 'tags') {
+        if (!Array.isArray(defaultValue) && typeof defaultValue !== 'string') {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a string or string array.`, 400);
+        }
+        if (Array.isArray(defaultValue) && !defaultValue.every((item) => typeof item === 'string')) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a string array.`, 400);
+        }
+        return;
+    }
+    if (input === 'date') {
+        if (typeof defaultValue !== 'string' || !isValidWorkspaceToolDate(defaultValue)) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a YYYY-MM-DD date.`, 400);
+        }
+        if (typeof field.min === 'string' && defaultValue < field.min) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be on or after ${field.min}.`, 400);
+        }
+        if (typeof field.max === 'string' && defaultValue > field.max) {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be on or before ${field.max}.`, 400);
+        }
+        return;
+    }
+    if (input === 'textarea') {
+        if (typeof defaultValue !== 'string') {
+            throw new WorkspaceToolServiceError(`Tool action "${actionId}" parameter "${field.name}" defaultValue must be a string.`, 400);
+        }
+    }
+}
+function isValidWorkspaceToolDate(value) {
+    if (!WORKSPACE_TOOL_DATE_PATTERN.test(value))
+        return false;
+    const [year, month, day] = value.split('-').map(Number);
+    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day))
+        return false;
+    const parsed = new Date(Date.UTC(year, month - 1, day));
+    return parsed.getUTCFullYear() === year
+        && parsed.getUTCMonth() === month - 1
+        && parsed.getUTCDate() === day;
+}
+function validateWorkspaceToolView(manifest) {
+    for (const slot of manifest.view.mediaSlots ?? []) {
+        if (slot.kind !== 'workspace_path') {
+            throw new WorkspaceToolServiceError(`Tool media slot "${slot.name}" must use kind "workspace_path".`, 400);
+        }
+    }
+    const validation = validatePanelTemplateProps('RowTemplateGrid', {
+        title: manifest.view.title,
+        fields: manifest.view.fields,
+        mediaSlots: manifest.view.mediaSlots ?? [],
+        summary: manifest.view.summary,
+        parameterForm: manifest.view.parameterForm,
+        template: manifest.view.template,
+    }, manifest.actions.map((action) => ({ id: action.actionId })));
+    if (!validation.ok) {
+        throw new WorkspaceToolServiceError(`Tool manifest is invalid: ${validation.errors[0] ?? 'invalid view template'}`, 400);
+    }
+    validateWorkspaceToolSummaryNode(manifest.view.summary);
+    validateWorkspaceToolParameterFormBindings(manifest);
+}
+function validateWorkspaceToolSummaryNode(summary) {
+    if (!summary)
+        return;
+    const unsupported = collectPanelLevelUnsupportedNodes(summary, {
+        unsupportedTypes: TOOL_SUMMARY_UNSUPPORTED_TYPES,
+    });
+    if (unsupported.length > 0) {
+        throw new WorkspaceToolServiceError('Tool view.summary is display-only and does not support action or parameter controls; put action parameters in view.parameterForm.', 400);
+    }
+}
+function validateWorkspaceToolParameterFormBindings(manifest) {
+    const parameterForm = manifest.view.parameterForm;
+    if (!parameterForm)
+        return;
+    const actionsById = new Map(manifest.actions.map((action) => [action.actionId, action]));
+    const boundParams = new Set();
+    collectWorkspaceToolParameterFormBindings(parameterForm, manifest.actions, actionsById, boundParams);
+    for (const action of manifest.actions) {
+        for (const field of action.paramsSchema ?? []) {
+            if (field.required === true && field.defaultValue === undefined) {
+                const key = buildWorkspaceToolPanelActionParamKey(action.actionId, field.name);
+                if (!boundParams.has(key)) {
+                    throw new WorkspaceToolServiceError(`Tool parameter form must expose required parameter "${action.actionId}.${field.name}".`, 400);
+                }
+            }
+        }
+    }
+}
+function collectWorkspaceToolParameterFormBindings(node, actions, actionsById, boundParams) {
+    switch (node.type) {
+        case 'Section':
+        case 'ParameterFormSection':
+        case 'Card':
+        case 'Stack':
+        case 'Inline':
+        case 'Grid':
+            for (const child of node.children) {
+                collectWorkspaceToolParameterFormBindings(child, actions, actionsById, boundParams);
+            }
+            return;
+        case 'Columns':
+            for (const column of node.columns) {
+                for (const child of column.children) {
+                    collectWorkspaceToolParameterFormBindings(child, actions, actionsById, boundParams);
+                }
+            }
+            return;
+        case 'ActionBar':
+            return;
+        case 'RunStatusCard':
+        case 'RunLogViewer':
+        case 'ArtifactList':
+            throw new WorkspaceToolServiceError(`Tool parameter form control "${node.type}" is not supported. Use TextInput, TextArea, NumberInput, Slider, Checkbox, Select, MultiSelect, TagInput, DatePicker, or FileUpload with declared tool action params.`, 400);
+        case 'TextInput':
+        case 'TextArea':
+        case 'NumberInput':
+        case 'Checkbox':
+        case 'Select':
+        case 'MultiSelect':
+        case 'TagInput':
+        case 'Slider':
+        case 'DatePicker':
+        case 'FileUpload':
+        case 'Button': {
+            if (TOOL_PARAMETER_FORM_UNSUPPORTED_TYPES.has(node.type)) {
+                throw new WorkspaceToolServiceError(`Tool parameter form control "${node.type}" is not supported. Use TextInput, TextArea, NumberInput, Slider, Checkbox, Select, MultiSelect, TagInput, DatePicker, or FileUpload with declared tool action params.`, 400);
+            }
+            const rawName = isPlainRecord(node.props) ? node.props.name : undefined;
+            if (typeof rawName !== 'string' || !rawName.trim()) {
+                throw new WorkspaceToolServiceError(`Tool parameter form control "${node.type}" must declare props.name.`, 400);
+            }
+            const binding = resolveWorkspaceToolActionParamBinding(actions, rawName);
+            if (!binding) {
+                throw new WorkspaceToolServiceError(`Tool parameter form control "${rawName}" must use the tool_action.<actionId>.<paramName> namespace.`, 400);
+            }
+            const action = actionsById.get(binding.actionId);
+            if (!action) {
+                throw new WorkspaceToolServiceError(`Tool parameter form references unknown action "${binding.actionId}".`, 400);
+            }
+            const field = (action.paramsSchema ?? []).find((candidate) => candidate.name === binding.paramName);
+            if (!field) {
+                throw new WorkspaceToolServiceError(`Tool parameter form references unknown parameter "${binding.actionId}.${binding.paramName}".`, 400);
+            }
+            validateWorkspaceToolParameterControlType(node.type, field, binding);
+            validateWorkspaceToolParameterControlProps(node.type, node.props, field, binding);
+            boundParams.add(buildWorkspaceToolPanelActionParamKey(binding.actionId, binding.paramName));
+            return;
+        }
+        default:
+            return;
+    }
+}
+function validateWorkspaceToolParameterControlProps(nodeType, props, field, binding) {
+    if (props.defaultValue !== undefined && !valuesDeepEqual(props.defaultValue, field.defaultValue)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" defaultValue must match paramsSchema.defaultValue.`, 400);
+    }
+    if (props.value !== undefined && !valuesDeepEqual(props.value, field.defaultValue)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" value must match paramsSchema.defaultValue.`, 400);
+    }
+    if (props.required !== undefined && props.required !== (field.required === true)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" required must match paramsSchema.required.`, 400);
+    }
+    if (props.min !== undefined && !valuesDeepEqual(props.min, field.min)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" min must match paramsSchema.min.`, 400);
+    }
+    if (props.max !== undefined && !valuesDeepEqual(props.max, field.max)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" max must match paramsSchema.max.`, 400);
+    }
+    if ((nodeType === 'Select' || nodeType === 'MultiSelect')
+        && props.options !== undefined
+        && !valuesDeepEqual(props.options, field.options)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" options must match paramsSchema.options.`, 400);
+    }
+    if (nodeType === 'FileUpload') {
+        if (props.accept !== undefined && !valuesDeepEqual(props.accept, field.accept)) {
+            throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" accept must match paramsSchema.accept.`, 400);
+        }
+        if (props.multiple !== undefined && !valuesDeepEqual(props.multiple, field.multiple === true)) {
+            throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" multiple must match paramsSchema.multiple.`, 400);
+        }
+        if (props.maxBytes !== undefined && !valuesDeepEqual(props.maxBytes, field.maxBytes)) {
+            throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" maxBytes must match paramsSchema.maxBytes.`, 400);
+        }
+    }
+}
+function validateWorkspaceToolParameterControlType(nodeType, field, binding) {
+    const fieldInput = field.input ?? 'text';
+    if (fieldInput === 'checkbox' && nodeType !== 'Checkbox') {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use Checkbox.`, 400);
+    }
+    if (fieldInput === 'number' && !TOOL_PARAMETER_FORM_NUMBER_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use NumberInput or Slider.`, 400);
+    }
+    if (fieldInput === 'select' && !TOOL_PARAMETER_FORM_SELECT_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use Select.`, 400);
+    }
+    if (fieldInput === 'multiselect' && !TOOL_PARAMETER_FORM_MULTISELECT_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use MultiSelect.`, 400);
+    }
+    if (fieldInput === 'tags' && !TOOL_PARAMETER_FORM_TAG_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use TagInput.`, 400);
+    }
+    if (fieldInput === 'date' && !TOOL_PARAMETER_FORM_DATE_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use DatePicker.`, 400);
+    }
+    if (fieldInput === 'textarea' && nodeType !== 'TextArea') {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use TextArea.`, 400);
+    }
+    if (fieldInput === 'file' && !TOOL_PARAMETER_FORM_FILE_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use FileUpload.`, 400);
+    }
+    if (fieldInput === 'text' && !TOOL_PARAMETER_FORM_TEXT_TYPES.has(nodeType)) {
+        throw new WorkspaceToolServiceError(`Tool parameter form control for "${binding.actionId}.${binding.paramName}" must use TextInput or TextArea.`, 400);
+    }
+}
+function valuesDeepEqual(left, right) {
+    return stableStringify(left) === stableStringify(right);
+}
+function stableStringify(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'undefined';
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(',')}}`;
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}