windmill-components 1.623.1 → 1.642.0

package/package/components/copilot/chat/shared.d.ts

@@ -14,7 +14,8 @@ import type { ContextElement, FlowModuleCodePieceElement } from './context';
 import type { ExtendedOpenFlow } from '../../flows/types';
 import type { FunctionParameters } from 'openai/resources/shared.mjs';
 import { z } from 'zod';
-import { type CompletedJob, type FlowModule } from '../../../gen';
+import { type CompletedJob, type FlowModule, type Script } from '../../../gen';
+import { type editor as meditor } from 'monaco-editor';
 export declare const TOOL_PRETTIFY_MAP: Record<string, (content: string) => string>;
 export interface ContextStringResult {
     dbContext: string;
@@ -106,6 +107,7 @@ export declare const createSearchHubScriptsTool: (withContent?: boolean) => {
     }) => Promise<string>;
 };
 export declare function buildSchemaForTool(toolDef: ChatCompletionFunctionTool, schemaBuilder: () => Promise<FunctionParameters>): Promise<boolean>;
+export declare const MAX_RUNNABLE_CONTENT_LENGTH = 20000;
 export interface TestRunConfig {
     jobStarter: () => Promise<string>;
     workspace: string;
@@ -119,4 +121,64 @@ export declare function extractCodeFromMarkdown(markdown: string): string[];
 export declare function getLatestAssistantMessage(displayMessages: DisplayMessage[]): string | undefined;
 export declare function buildTestRunArgs(args: any, toolDef: ChatCompletionFunctionTool): Promise<any>;
 export declare function executeTestRun(config: TestRunConfig): Promise<string>;
+/** Result of linting a script */
+export interface ScriptLintResult {
+    errorCount: number;
+    warningCount: number;
+    errors: meditor.IMarker[];
+    warnings: meditor.IMarker[];
+}
+/** Format script lint result for display */
+export declare function formatScriptLintResult(lintResult: ScriptLintResult): string;
+export declare class WorkspaceRunnablesSearch {
+    private uf;
+    private scriptsWorkspace;
+    private flowsWorkspace;
+    private scripts;
+    private flows;
+    private scriptCache;
+    private flowCache;
+    constructor();
+    private initScripts;
+    private initFlows;
+    searchScripts(query: string, workspace: string): Promise<{
+        type: "script";
+        path: string;
+        summary: string;
+    }[]>;
+    searchFlows(query: string, workspace: string): Promise<{
+        type: "flow";
+        path: string;
+        summary: string;
+    }[]>;
+    search(query: string, workspace: string, type?: 'all' | 'scripts' | 'flows'): Promise<{
+        type: "script" | "flow";
+        path: string;
+        summary: string;
+    }[]>;
+    getScript(path: string, workspace: string): Promise<Script>;
+    getFlow(path: string, workspace: string): Promise<import("../../../gen").OpenFlow & import("../../../gen").FlowMetadata & {
+        lock_error_logs?: string;
+        version_id?: number;
+    }>;
+}
+export declare const workspaceRunnablesSearch: WorkspaceRunnablesSearch;
+export declare const createSearchWorkspaceTool: () => {
+    def: ChatCompletionFunctionTool;
+    fn: ({ args, workspace, toolId, toolCallbacks }: {
+        args: any;
+        workspace: string;
+        toolId: string;
+        toolCallbacks: ToolCallbacks;
+    }) => Promise<string>;
+};
+export declare const createGetRunnableDetailsTool: () => {
+    def: ChatCompletionFunctionTool;
+    fn: ({ args, workspace, toolId, toolCallbacks }: {
+        args: any;
+        workspace: string;
+        toolId: string;
+        toolCallbacks: ToolCallbacks;
+    }) => Promise<string>;
+};
 export {};

package/package/components/copilot/chat/shared.js

@@ -12,9 +12,12 @@ export const SPECIAL_MODULE_IDS = {
 import { get } from 'svelte/store';
 import { workspaceStore } from '../../../stores';
 import { z } from 'zod';
-import { ScriptService, JobService } from '../../../gen';
+import { ScriptService, FlowService, JobService } from '../../../gen';
+import uFuzzy from '@leeoniya/ufuzzy';
+import { emptyString } from '../../../utils';
 import { scriptLangToEditorLang } from '../../../scripts';
 import { getCurrentModel } from '../../../aiStore';
+import {} from 'monaco-editor';
 // Prettify function for code arguments - extracts and formats code from JSON
 function prettifyCodeArguments(content) {
     let codeContent = content;
@@ -228,6 +231,7 @@ export function buildContextString(selectedContext) {
     let hasDiff = false;
     let hasFlowModule = false;
     let hasError = false;
+    let workspaceItemsContext = '';
     let result = '\n\n';
     for (const context of selectedContext) {
         if (context.type === 'code') {
@@ -260,6 +264,24 @@ export function buildContextString(selectedContext) {
             hasFlowModule = true;
             flowModuleContext += `${context.id}\n`;
         }
+        else if (context.type === 'workspace_script') {
+            workspaceItemsContext += `\nWORKSPACE SCRIPT (${context.path}):\n`;
+            workspaceItemsContext += `Summary: ${context.summary}\n`;
+            workspaceItemsContext += `Language: ${context.language}\n`;
+            if (context.schema) {
+                workspaceItemsContext += `Inputs: ${JSON.stringify(context.schema)}\n`;
+            }
+            workspaceItemsContext += `Code:\n${context.content}\n`;
+        }
+        else if (context.type === 'workspace_flow') {
+            workspaceItemsContext += `\nWORKSPACE FLOW (${context.path}):\n`;
+            workspaceItemsContext += `Summary: ${context.summary}\n`;
+            workspaceItemsContext += `Description: ${context.description}\n`;
+            if (context.schema) {
+                workspaceItemsContext += `Inputs: ${JSON.stringify(context.schema)}\n`;
+            }
+            workspaceItemsContext += `Value:\n${context.value}\n`;
+        }
     }
     if (hasCode) {
         result += '\n' + codeContext;
@@ -276,6 +298,9 @@ export function buildContextString(selectedContext) {
     if (hasFlowModule) {
         result += '\n' + flowModuleContext;
     }
+    if (workspaceItemsContext) {
+        result += '\n' + workspaceItemsContext;
+    }
     return result;
 }
 async function callTool({ tools, functionName, args, workspace, helpers, toolCallbacks, toolId }) {
@@ -491,6 +516,7 @@ export async function buildSchemaForTool(toolDef, schemaBuilder) {
 // Constants for result formatting
 const MAX_RESULT_LENGTH = 12000;
 const MAX_LOG_LENGTH = 4000;
+export const MAX_RUNNABLE_CONTENT_LENGTH = 20000;
 // Common job polling function
 export async function pollJobCompletion(jobId, workspace, toolId, toolCallbacks) {
     let attempts = 0;
@@ -640,3 +666,227 @@ function formatResultSummary(result, logs, success) {
     resultSummary += formatLogs(logs) ?? 'No logs available';
     return resultSummary;
 }
+/** Format script lint result for display */
+export function formatScriptLintResult(lintResult) {
+    let response = '';
+    const hasIssues = lintResult.errorCount > 0 || lintResult.warningCount > 0;
+    if (hasIssues) {
+        if (lintResult.errorCount > 0) {
+            response += `❌ **${lintResult.errorCount} error(s)** found that must be fixed:\n`;
+            for (const error of lintResult.errors) {
+                response += `- Line ${error.startLineNumber}: ${error.message}\n`;
+            }
+        }
+        if (lintResult.warningCount > 0) {
+            response += `\n⚠️ **${lintResult.warningCount} warning(s)** found:\n`;
+            for (const warning of lintResult.warnings) {
+                response += `- Line ${warning.startLineNumber}: ${warning.message}\n`;
+            }
+        }
+    }
+    else {
+        response = '✅ No lint issues found.';
+    }
+    return response;
+}
+// ============= Workspace Runnables Search =============
+export class WorkspaceRunnablesSearch {
+    uf;
+    scriptsWorkspace = undefined;
+    flowsWorkspace = undefined;
+    scripts = undefined;
+    flows = undefined;
+    scriptCache = new Map();
+    flowCache = new Map();
+    constructor() {
+        this.uf = new uFuzzy();
+    }
+    async initScripts(workspace) {
+        if (this.scripts === undefined || this.scriptsWorkspace !== workspace) {
+            this.scripts = await ScriptService.listScripts({ workspace });
+            this.scriptsWorkspace = workspace;
+        }
+    }
+    async initFlows(workspace) {
+        if (this.flows === undefined || this.flowsWorkspace !== workspace) {
+            this.flows = await FlowService.listFlows({ workspace });
+            this.flowsWorkspace = workspace;
+        }
+    }
+    async searchScripts(query, workspace) {
+        await this.initScripts(workspace);
+        const scripts = this.scripts;
+        if (!scripts)
+            return [];
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return scripts.map((s) => ({
+                type: 'script',
+                path: s.path,
+                summary: s.summary
+            }));
+        }
+        const haystack = scripts.map((s) => emptyString(s.summary) ? s.path : s.summary + ' (' + s.path + ')');
+        const [idxs, , order] = this.uf.search(haystack, trimmed);
+        if (!idxs || !order)
+            return [];
+        return order.map((orderIdx) => {
+            const haystackIdx = idxs[orderIdx];
+            return {
+                type: 'script',
+                path: scripts[haystackIdx].path,
+                summary: scripts[haystackIdx].summary
+            };
+        });
+    }
+    async searchFlows(query, workspace) {
+        await this.initFlows(workspace);
+        const flows = this.flows;
+        if (!flows)
+            return [];
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return flows.map((f) => ({
+                type: 'flow',
+                path: f.path,
+                summary: f.summary
+            }));
+        }
+        const haystack = flows.map((f) => emptyString(f.summary) ? f.path : f.summary + ' (' + f.path + ')');
+        const [idxs, , order] = this.uf.search(haystack, trimmed);
+        if (!idxs || !order)
+            return [];
+        return order.map((orderIdx) => {
+            const haystackIdx = idxs[orderIdx];
+            return {
+                type: 'flow',
+                path: flows[haystackIdx].path,
+                summary: flows[haystackIdx].summary
+            };
+        });
+    }
+    async search(query, workspace, type = 'all') {
+        const results = [];
+        if (type === 'all' || type === 'scripts') {
+            results.push(...(await this.searchScripts(query, workspace)));
+        }
+        if (type === 'all' || type === 'flows') {
+            results.push(...(await this.searchFlows(query, workspace)));
+        }
+        return results;
+    }
+    async getScript(path, workspace) {
+        const key = `${workspace}:${path}`;
+        let cached = this.scriptCache.get(key);
+        if (!cached) {
+            cached = await ScriptService.getScriptByPath({ workspace, path });
+            this.scriptCache.set(key, cached);
+        }
+        return cached;
+    }
+    async getFlow(path, workspace) {
+        const key = `${workspace}:${path}`;
+        let cached = this.flowCache.get(key);
+        if (!cached) {
+            cached = await FlowService.getFlowByPath({ workspace, path });
+            this.flowCache.set(key, cached);
+        }
+        return cached;
+    }
+}
+const searchWorkspaceSchema = z.object({
+    query: z
+        .string()
+        .describe('Comma separated list of keywords to search for (e.g. "stripe, send email, ETL")'),
+    type: z
+        .enum(['all', 'scripts', 'flows'])
+        .describe('Filter by type: "all" for both scripts and flows, "scripts" for scripts only, "flows" for flows only.')
+});
+const searchWorkspaceToolDef = createToolDef(searchWorkspaceSchema, 'search_workspace', 'Search for scripts and flows in the workspace. Use this when a user asks about existing building blocks, wants to find a script/flow, or asks "what do I have for X". ALWAYS search really broadly.');
+export const workspaceRunnablesSearch = new WorkspaceRunnablesSearch();
+export const createSearchWorkspaceTool = () => ({
+    def: searchWorkspaceToolDef,
+    fn: async ({ args, workspace, toolId, toolCallbacks }) => {
+        const parsedArgs = searchWorkspaceSchema.parse(args);
+        const type = parsedArgs.type;
+        toolCallbacks.setToolStatus(toolId, {
+            content: `Searching workspace...`
+        });
+        const results = [];
+        const keywords = parsedArgs.query.split(',').map((keyword) => keyword.trim());
+        const seenPaths = new Set();
+        for (const keyword of keywords) {
+            const keywordResults = await workspaceRunnablesSearch.search(keyword, workspace, type);
+            for (const result of keywordResults) {
+                if (!seenPaths.has(result.path)) {
+                    results.push(result);
+                    seenPaths.add(result.path);
+                }
+            }
+        }
+        toolCallbacks.setToolStatus(toolId, {
+            content: `Found ${results.length} result(s)`
+        });
+        return JSON.stringify(results, null, 2);
+    }
+});
+const getRunnableDetailsSchema = z.object({
+    path: z.string().describe('The path of the script or flow (e.g. "f/marketing/send_email")'),
+    type: z.enum(['script', 'flow']).describe('Whether this is a script or a flow')
+});
+const getRunnableDetailsToolDef = createToolDef(getRunnableDetailsSchema, 'get_runnable_details', 'Get details (summary, description, inputs schema, content) of a specific script or flow by path');
+export const createGetRunnableDetailsTool = () => ({
+    def: getRunnableDetailsToolDef,
+    fn: async ({ args, workspace, toolId, toolCallbacks }) => {
+        const parsedArgs = getRunnableDetailsSchema.parse(args);
+        const { path, type } = parsedArgs;
+        toolCallbacks.setToolStatus(toolId, {
+            content: `Getting ${type} details for "${path}"...`
+        });
+        try {
+            if (type === 'script') {
+                const script = await workspaceRunnablesSearch.getScript(path, workspace);
+                toolCallbacks.setToolStatus(toolId, {
+                    content: `Retrieved script details for "${path}"`
+                });
+                const content = script.content ?? '';
+                const truncatedContent = content.length > MAX_RUNNABLE_CONTENT_LENGTH
+                    ? content.slice(0, MAX_RUNNABLE_CONTENT_LENGTH) + '\n... (truncated)'
+                    : content;
+                return JSON.stringify({
+                    path: script.path,
+                    summary: script.summary,
+                    description: script.description,
+                    language: script.language,
+                    schema: script.schema,
+                    content: truncatedContent
+                }, null, 2);
+            }
+            else {
+                const flow = await workspaceRunnablesSearch.getFlow(path, workspace);
+                toolCallbacks.setToolStatus(toolId, {
+                    content: `Retrieved flow details for "${path}"`
+                });
+                const flowValue = JSON.stringify(flow.value, null, 2);
+                const truncatedValue = flowValue.length > MAX_RUNNABLE_CONTENT_LENGTH
+                    ? flowValue.slice(0, MAX_RUNNABLE_CONTENT_LENGTH) + '\n... (truncated)'
+                    : flowValue;
+                return JSON.stringify({
+                    path: flow.path,
+                    summary: flow.summary,
+                    description: flow.description,
+                    schema: flow.schema,
+                    value: truncatedValue
+                }, null, 2);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            toolCallbacks.setToolStatus(toolId, {
+                content: `Error getting ${type} details`,
+                error: errorMessage
+            });
+            return `Error getting ${type} details for "${path}": ${errorMessage}`;
+        }
+    }
+});

package/package/components/copilot/lib.d.ts

@@ -25,7 +25,7 @@ export interface ModelResponse {
     };
 }
 export declare function fetchAvailableModels(resourcePath: string, workspace: string, provider: AIProvider, signal?: AbortSignal): Promise<string[]>;
-export declare function getModelMaxTokens(provider: AIProvider, model: string): 128000 | 32000 | 100000 | 64000 | 32768 | 16384 | 4096 | 8192;
+export declare function getModelMaxTokens(provider: AIProvider, model: string): 100000 | 128000 | 32000 | 64000 | 32768 | 16384 | 4096 | 8192;
 export declare function getModelContextWindow(model: string): 1000000 | 400000 | 128000 | 200000 | 32000;
 export declare const PROVIDER_COMPLETION_CONFIG_MAP: Record<AIProvider, ChatCompletionCreateParams>;
 declare class WorkspacedAIClients {

package/package/components/copilot/lib.js

@@ -9,6 +9,7 @@ import { formatResourceTypes } from './utils';
 import { z } from 'zod';
 import { processToolCall } from './chat/shared';
 import { getNonStreamingOpenAIResponsesCompletion, getOpenAIResponsesCompletionStream } from './chat/openai-responses';
+import { convertOpenAIToAnthropicMessages } from './chat/anthropic';
 import { generateRandomString } from '../../utils';
 import { copilotInfo, getCurrentModel } from '../../aiStore';
 export const SUPPORTED_LANGUAGES = new Set(Object.keys(GEN_CONFIG.prompts));
@@ -271,7 +272,6 @@ function prepareMessages(aiProvider, messages) {
 }
 const DEFAULT_COMPLETION_CONFIG = {
     model: '',
-    seed: 42,
     messages: []
 };
 export const PROVIDER_COMPLETION_CONFIG_MAP = {
@@ -282,14 +282,8 @@ export const PROVIDER_COMPLETION_CONFIG_MAP = {
     togetherai: DEFAULT_COMPLETION_CONFIG,
     deepseek: DEFAULT_COMPLETION_CONFIG,
     customai: DEFAULT_COMPLETION_CONFIG,
-    googleai: {
-        ...DEFAULT_COMPLETION_CONFIG,
-        seed: undefined // not supported by gemini
-    },
-    mistral: {
-        ...DEFAULT_COMPLETION_CONFIG,
-        seed: undefined
-    },
+    googleai: DEFAULT_COMPLETION_CONFIG,
+    mistral: DEFAULT_COMPLETION_CONFIG,
     anthropic: DEFAULT_COMPLETION_CONFIG,
     aws_bedrock: DEFAULT_COMPLETION_CONFIG
 };
@@ -344,6 +338,17 @@ export async function testKey({ apiKey, resourcePath, model, abortController, me
     if (!modelToTest) {
         throw new Error('Missing a model to test');
     }
+    // Use Anthropic SDK for Anthropic provider
+    if (aiProvider === 'anthropic') {
+        await testAnthropicKey({
+            apiKey,
+            resourcePath,
+            model: modelToTest,
+            abortController,
+            messages
+        });
+        return;
+    }
     await getNonStreamingCompletion(messages, abortController, {
         apiKey,
         resourcePath,
@@ -353,6 +358,36 @@ export async function testKey({ apiKey, resourcePath, model, abortController, me
         }
     });
 }
+async function testAnthropicKey({ apiKey, resourcePath, model, abortController, messages }) {
+    const { system, messages: anthropicMessages } = convertOpenAIToAnthropicMessages(messages);
+    const headers = {
+        'X-Provider': 'anthropic',
+        'anthropic-version': '2023-06-01',
+        'X-Anthropic-SDK': 'true'
+    };
+    if (resourcePath) {
+        headers['X-Resource-Path'] = resourcePath;
+    }
+    else if (apiKey) {
+        headers['X-API-Key'] = apiKey;
+    }
+    const anthropicClient = apiKey
+        ? new Anthropic({
+            baseURL: `${location.origin}${OpenAPI.BASE}/ai/proxy`,
+            apiKey: 'fake-key',
+            dangerouslyAllowBrowser: true
+        })
+        : workspaceAIClients.getAnthropicClient();
+    await anthropicClient.messages.create({
+        model,
+        max_tokens: 100,
+        messages: anthropicMessages,
+        ...(system && { system })
+    }, {
+        signal: abortController.signal,
+        headers
+    });
+}
 async function getResourceTypes(scriptOptions) {
     const elems = scriptOptions.type === 'gen' || scriptOptions.type === 'edit' ? [scriptOptions.description] : [];
     if (scriptOptions.type === 'edit' || scriptOptions.type === 'fix') {

package/package/components/copilot/utils.d.ts

@@ -6,3 +6,8 @@ export declare function pythonCompile(schema: Schema): string;
 export declare function phpCompile(schema: Schema): string;
 export declare function formatResourceTypes(resourceTypes: ResourceType[], lang: 'python3' | 'typescript' | 'php'): string;
 export declare function yamlStringifyExceptKeys(obj: any, keys: string[]): string;
+/**
+ * Checks if a model supports FIM (Fill-in-the-Middle) autocomplete.
+ * Currently only Codestral models (non-embedding) support this.
+ */
+export declare function supportsAutocomplete(model: string): boolean;

package/package/components/copilot/utils.js

@@ -159,3 +159,11 @@ export function yamlStringifyExceptKeys(obj, keys) {
         }
     });
 }
+/**
+ * Checks if a model supports FIM (Fill-in-the-Middle) autocomplete.
+ * Currently only Codestral models (non-embedding) support this.
+ */
+export function supportsAutocomplete(model) {
+    const lower = model.toLowerCase();
+    return lower.includes('codestral') && !lower.includes('embed');
+}

package/package/components/custom_ui.d.ts

@@ -10,6 +10,7 @@ export type FlowBuilderWhitelabelCustomUi = {
         extraDeployOptions?: boolean;
         editableSummary?: boolean;
         settings?: boolean;
+        draft?: boolean;
     };
     settingsPanel?: boolean;
     settingsTabs?: {
@@ -79,6 +80,7 @@ export type EditorBarUi = {
     database?: boolean;
     ducklake?: boolean;
     dataTable?: boolean;
+    debug?: boolean;
 };
 export type EditableSchemaFormUi = {
     jsonOnly?: boolean;

package/package/components/dbOps.d.ts

@@ -1,7 +1,8 @@
-import { type ColumnDef } from './apps/components/display/dbtable/utils';
+import { type ColumnDef, type TableMetadata } from './apps/components/display/dbtable/utils';
 import type { DBSchema } from '../stores';
 import type { DbInput, DbType } from './dbTypes';
-import { type CreateTableValues } from './apps/components/display/dbtable/queries/createTable';
+import { type TableEditorValues } from './apps/components/display/dbtable/tableEditor';
+import { type AlterTableValues } from './apps/components/display/dbtable/queries/alterTable';
 export type IDbTableOps = {
     dbType: DbType;
     tableKey: string;
@@ -41,19 +42,32 @@ export type IDbSchemaOps = {
         schema?: string;
     }) => Promise<void>;
     onCreate: (params: {
-        values: CreateTableValues;
+        values: TableEditorValues;
         schema?: string;
     }) => Promise<void>;
     previewCreateSql: (params: {
-        values: CreateTableValues;
+        values: TableEditorValues;
         schema?: string;
     }) => string;
+    onAlter: (params: {
+        values: AlterTableValues;
+        schema?: string;
+    }) => Promise<void>;
+    previewAlterSql: (params: {
+        values: AlterTableValues;
+        schema?: string;
+    }) => string[];
     onCreateSchema: (params: {
         schema: string;
     }) => Promise<void>;
     onDeleteSchema: (params: {
         schema: string;
     }) => Promise<void>;
+    onFetchTableEditorDefinition: (params: {
+        table: string;
+        schema?: string;
+        colDefs: TableMetadata;
+    }) => Promise<TableEditorValues>;
 };
 export declare function dbSchemaOpsWithPreviewScripts({ workspace, input }: {
     workspace: string;

package/package/components/dbOps.js

@@ -9,7 +9,10 @@ import { makeDeleteTableQuery } from './apps/components/display/dbtable/queries/
 import { stringifySchema } from './copilot/lib';
 import { wrapDucklakeQuery } from './ducklake';
 import { assert } from '../utils';
+import { buildTableEditorValues } from './apps/components/display/dbtable/tableEditor';
+import { makeAlterTableQueries, makeAlterTableQuery } from './apps/components/display/dbtable/queries/alterTable';
 import { makeCreateTableQuery } from './apps/components/display/dbtable/queries/createTable';
+import { fetchTableRelationalKeys } from './apps/components/display/dbtable/queries/relationalKeys';
 export function dbTableOpsWithPreviewScripts({ input, tableKey, colDefs, workspace }) {
     const dbType = getDbType(input);
     const language = getLanguageByResourceType(dbType);
@@ -30,15 +33,15 @@ export function dbTableOpsWithPreviewScripts({ input, tableKey, colDefs, workspa
             return count;
         },
         getRows: async (params) => {
-            let query = makeSelectQuery(tableKey, colDefs, undefined, dbType);
+            let query = makeSelectQuery(tableKey, colDefs, undefined, dbType, undefined, {
+                fixPgIntTypes: true
+            });
             if (input.type === 'ducklake')
                 query = wrapDucklakeQuery(query, input.ducklake);
             let items = (await runScriptAndPollResult({
                 workspace,
                 requestBody: { args: { ...dbArg, ...params }, language, content: query }
             }));
-            if (input.type === 'database' && input.resourceType === 'ms_sql_server')
-                items = items?.[0];
             if (!items || !Array.isArray(items)) {
                 throw 'items is not an array';
             }
@@ -101,6 +104,16 @@ export function dbSchemaOpsWithPreviewScripts({ workspace, input }) {
             });
         },
         previewCreateSql: ({ values, schema }) => makeCreateTableQuery(values, dbType, schema),
+        onAlter: async ({ values, schema }) => {
+            let query = makeAlterTableQuery(values, dbType, schema);
+            if (input.type === 'ducklake')
+                query = wrapDucklakeQuery(query, input.ducklake);
+            await runScriptAndPollResult({
+                workspace,
+                requestBody: { args: dbArg, content: query, language }
+            });
+        },
+        previewAlterSql: ({ values, schema }) => makeAlterTableQueries(values, dbType, schema),
         onCreateSchema: async ({ schema }) => {
             let createSchemaQuery = `CREATE SCHEMA ${schema};`;
             if (input.type === 'ducklake')
@@ -118,6 +131,15 @@ export function dbSchemaOpsWithPreviewScripts({ workspace, input }) {
                 workspace,
                 requestBody: { args: { ...dbArg }, language, content: dropSchemaQuery }
             });
+        },
+        onFetchTableEditorDefinition: async ({ table, schema, colDefs }) => {
+            let { foreignKeys, pk_constraint_name } = await fetchTableRelationalKeys(input, dbType, table, schema, workspace, dbArg, language);
+            return buildTableEditorValues({
+                tableName: table,
+                metadata: colDefs,
+                foreignKeys,
+                pk_constraint_name
+            });
         }
     };
 }