windmill-components 1.655.2 → 1.665.1

package/package/components/copilot/chat/openai-responses.js

@@ -1,7 +1,6 @@
 import OpenAI, { OpenAIError } from 'openai';
-import { getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
+import { createOpenAIProxyClient, getAiProxyBaseURL, getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
 import { processToolCall } from './shared';
-import { OpenAPI } from '../../../gen';
 // Conversion utilities for Responses API
 function convertMessagesToResponsesInput(messages) {
     const systemMessage = messages.find((m) => m.role === 'system');
@@ -94,12 +93,17 @@ function convertCompletionConfigToResponsesConfig(config) {
     }
     return responsesConfig;
 }
-export async function getOpenAIResponsesCompletion(messages, abortController, tools) {
-    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true, tools });
+export async function getOpenAIResponsesCompletion(messages, abortController, tools, options) {
+    const { provider, config } = getProviderAndCompletionConfig({
+        messages,
+        stream: true,
+        tools,
+        forceModelProvider: options?.forceModelProvider
+    });
     const { instructions, input } = convertMessagesToResponsesInput(messages);
     const responsesConfig = convertCompletionConfigToResponsesConfig(config);
-    const openaiClient = workspaceAIClients.getOpenaiClient();
-    const runner = openaiClient.responses.stream({
+    const client = options?.openaiClient ?? workspaceAIClients.getOpenaiClient();
+    const runner = client.responses.stream({
         ...responsesConfig,
         input,
         ...(instructions ? { instructions } : {})
@@ -149,7 +153,7 @@ export async function* getOpenAIResponsesCompletionStream(messages, abortControl
         }
     }
 }
-export async function parseOpenAIResponsesCompletion(runner, callbacks, messages, addedMessages, tools, helpers) {
+export async function parseOpenAIResponsesCompletion(runner, callbacks, messages, addedMessages, tools, helpers, options) {
     let toolCallsToProcess = [];
     let error = null;
     let textContent = '';
@@ -264,7 +268,8 @@ export async function parseOpenAIResponsesCompletion(runner, callbacks, messages
                 tools,
                 toolCall,
                 helpers,
-                toolCallbacks: callbacks
+                toolCallbacks: callbacks,
+                workspace: options?.workspace
             });
             messages.push(messageToAdd);
             addedMessages.push(messageToAdd);
@@ -300,15 +305,10 @@ export async function getNonStreamingOpenAIResponsesCompletion(messages, abortCo
         };
     }
     const openaiClient = testOptions?.apiKey
-        ? new OpenAI({
-            baseURL: `${location.origin}${OpenAPI.BASE}/ai/proxy`,
-            apiKey: 'fake-key',
-            defaultHeaders: {
-                Authorization: '' // a non empty string will be unable to access Windmill backend proxy
-            },
-            dangerouslyAllowBrowser: true
-        })
-        : workspaceAIClients.getOpenaiClient();
+        ? createOpenAIProxyClient(getAiProxyBaseURL())
+        : testOptions?.workspace
+            ? workspaceAIClients.createOpenaiClient(testOptions.workspace)
+            : workspaceAIClients.getOpenaiClient();
     const response = await openaiClient.responses.create({
         ...responsesConfig,
         input,

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

@@ -64,11 +64,12 @@ export type AssistantDisplayMessage = BaseDisplayMessage & {
     role: 'assistant';
 };
 export type DisplayMessage = UserDisplayMessage | ToolDisplayMessage | AssistantDisplayMessage;
-export declare function processToolCall<T>({ tools, toolCall, helpers, toolCallbacks }: {
+export declare function processToolCall<T>({ tools, toolCall, helpers, toolCallbacks, workspace }: {
     tools: Tool<T>[];
     toolCall: ChatCompletionMessageFunctionToolCall;
     helpers: T;
     toolCallbacks: ToolCallbacks;
+    workspace?: string;
 }): Promise<ChatCompletionMessageParam>;
 export interface Tool<T> {
     def: ChatCompletionFunctionTool;

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

@@ -310,7 +310,7 @@ async function callTool({ tools, functionName, args, workspace, helpers, toolCal
     }
     return tool.fn({ args, workspace, helpers, toolCallbacks, toolId });
 }
-export async function processToolCall({ tools, toolCall, helpers, toolCallbacks }) {
+export async function processToolCall({ tools, toolCall, helpers, toolCallbacks, workspace }) {
     try {
         const args = JSON.parse(toolCall.function.arguments || '{}');
         const tool = tools.find((t) => t.def.function.name === toolCall.function.name);
@@ -353,7 +353,7 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks
                 tools,
                 functionName: toolCall.function.name,
                 args,
-                workspace: get(workspaceStore) ?? '',
+                workspace: workspace ?? get(workspaceStore) ?? '',
                 helpers,
                 toolCallbacks,
                 toolId: toolCall.id

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

@@ -28,19 +28,22 @@ export declare function fetchAvailableModels(resourcePath: string, workspace: st
 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>;
+export declare function getAiProxyBaseURL(workspace?: string): string;
+export declare function createOpenAIProxyClient(baseURL: string): OpenAI;
+export declare function createAnthropicProxyClient(baseURL: string): Anthropic;
 declare class WorkspacedAIClients {
     private openaiClient;
     private anthropicClient;
     init(workspace: string): void;
-    private getBaseURL;
-    private initOpenai;
-    private initAnthropic;
+    createOpenaiClient(workspace: string): OpenAI;
+    createAnthropicClient(workspace: string): Anthropic;
     getOpenaiClient(): OpenAI;
     getAnthropicClient(): Anthropic;
 }
 export declare const workspaceAIClients: WorkspacedAIClients;
-export declare function testKey({ apiKey, resourcePath, model, abortController, messages, aiProvider }: {
+export declare function testKey({ apiKey, workspace, resourcePath, model, abortController, messages, aiProvider }: {
     apiKey?: string;
+    workspace?: string;
     resourcePath?: string;
     model: string | undefined;
     messages: ChatCompletionMessageParam[];
@@ -84,17 +87,23 @@ export declare function getProviderAndCompletionConfig<K extends boolean>({ mess
 export declare function getNonStreamingCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, testOptions?: {
     apiKey?: string;
     resourcePath?: string;
+    workspace?: string;
     forceModelProvider: AIProviderModel;
 }): Promise<string>;
 export declare const FIM_MAX_TOKENS = 256;
 export declare function getFimCompletion(prompt: string, suffix: string, providerModel: AIProviderModel, abortController: AbortController): Promise<string | undefined>;
 export declare function getCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[], options?: {
     forceCompletions?: boolean;
+    forceModelProvider?: AIProviderModel;
+    openaiClient?: OpenAI;
 }): Promise<Stream<ChatCompletionChunk>>;
 export declare function parseOpenAICompletion(completion: Stream<ChatCompletionChunk>, callbacks: ToolCallbacks & {
     onNewToken: (token: string) => void;
     onMessageEnd: () => void;
-}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, _abortController?: AbortController): Promise<boolean>;
+}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, _abortController?: AbortController, // unused, for signature compatibility with parseAnthropicCompletion
+options?: {
+    workspace?: string;
+}): Promise<boolean>;
 export declare function getResponseFromEvent(part: OpenAI.Chat.Completions.ChatCompletionChunk): string;
 export declare function copilot(scriptOptions: CopilotOptions, generatedCode: Writable<string>, abortController: AbortController, generatedExplanation?: Writable<string>): Promise<string>;
 export {};

package/package/components/copilot/lib.js

@@ -45,7 +45,14 @@ export const AI_PROVIDERS = {
     },
     googleai: {
         label: 'Google AI',
-        defaultModels: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite', 'gemini-3-flash', 'gemini-3.1-pro', 'gemini-3.1-flash-lite']
+        defaultModels: [
+            'gemini-2.5-flash',
+            'gemini-2.5-pro',
+            'gemini-2.5-flash-lite',
+            'gemini-3-flash',
+            'gemini-3.1-pro',
+            'gemini-3.1-flash-lite'
+        ]
     },
     groq: {
         label: 'Groq',
@@ -216,7 +223,13 @@ export function getModelContextWindow(model) {
 function getModelSpecificConfig(modelProvider, tools) {
     const defaultMaxTokens = getModelMaxTokens(modelProvider.provider, modelProvider.model);
     const modelKey = `${modelProvider.provider}:${modelProvider.model}`;
-    const customMaxTokensStore = get(copilotInfo)?.maxTokensPerModel;
+    let customMaxTokensStore;
+    try {
+        customMaxTokensStore = get(copilotInfo)?.maxTokensPerModel;
+    }
+    catch {
+        // copilotInfo store may not be initialized in vitest
+    }
     const maxTokens = customMaxTokensStore?.[modelKey] ?? defaultMaxTokens;
     if ((modelProvider.provider === 'openai' || modelProvider.provider === 'azure_openai') &&
         (modelProvider.model.startsWith('o') || modelProvider.model.startsWith('gpt-5'))) {
@@ -286,34 +299,40 @@ export const PROVIDER_COMPLETION_CONFIG_MAP = {
     anthropic: DEFAULT_COMPLETION_CONFIG,
     aws_bedrock: DEFAULT_COMPLETION_CONFIG
 };
+export function getAiProxyBaseURL(workspace) {
+    return workspace
+        ? `${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy`
+        : `${location.origin}${OpenAPI.BASE}/ai/proxy`;
+}
+export function createOpenAIProxyClient(baseURL) {
+    return new OpenAI({
+        baseURL,
+        apiKey: 'fake-key',
+        defaultHeaders: {
+            Authorization: '' // a non empty string will be unable to access Windmill backend proxy
+        },
+        dangerouslyAllowBrowser: true
+    });
+}
+export function createAnthropicProxyClient(baseURL) {
+    return new Anthropic({
+        baseURL,
+        apiKey: 'fake-key',
+        dangerouslyAllowBrowser: true
+    });
+}
 class WorkspacedAIClients {
     openaiClient;
     anthropicClient;
     init(workspace) {
-        this.initOpenai(workspace);
-        this.initAnthropic(workspace);
-    }
-    getBaseURL(workspace) {
-        return `${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy`;
-    }
-    initOpenai(workspace) {
-        const baseURL = this.getBaseURL(workspace);
-        this.openaiClient = new OpenAI({
-            baseURL,
-            apiKey: 'fake-key',
-            defaultHeaders: {
-                Authorization: '' // a non empty string will be unable to access Windmill backend proxy
-            },
-            dangerouslyAllowBrowser: true
-        });
+        this.openaiClient = this.createOpenaiClient(workspace);
+        this.anthropicClient = this.createAnthropicClient(workspace);
     }
-    initAnthropic(workspace) {
-        const baseURL = this.getBaseURL(workspace);
-        this.anthropicClient = new Anthropic({
-            baseURL,
-            apiKey: 'fake-key',
-            dangerouslyAllowBrowser: true
-        });
+    createOpenaiClient(workspace) {
+        return createOpenAIProxyClient(getAiProxyBaseURL(workspace));
+    }
+    createAnthropicClient(workspace) {
+        return createAnthropicProxyClient(getAiProxyBaseURL(workspace));
     }
     getOpenaiClient() {
         if (!this.openaiClient) {
@@ -329,7 +348,7 @@ class WorkspacedAIClients {
     }
 }
 export const workspaceAIClients = new WorkspacedAIClients();
-export async function testKey({ apiKey, resourcePath, model, abortController, messages, aiProvider }) {
+export async function testKey({ apiKey, workspace, resourcePath, model, abortController, messages, aiProvider }) {
     if (!apiKey && !resourcePath) {
         throw new Error('API key or resource path is required');
     }
@@ -341,6 +360,7 @@ export async function testKey({ apiKey, resourcePath, model, abortController, me
     if (aiProvider === 'anthropic') {
         await testAnthropicKey({
             apiKey,
+            workspace,
             resourcePath,
             model: modelToTest,
             abortController,
@@ -350,6 +370,7 @@ export async function testKey({ apiKey, resourcePath, model, abortController, me
     }
     await getNonStreamingCompletion(messages, abortController, {
         apiKey,
+        workspace,
         resourcePath,
         forceModelProvider: {
             model: modelToTest,
@@ -357,7 +378,7 @@ export async function testKey({ apiKey, resourcePath, model, abortController, me
         }
     });
 }
-async function testAnthropicKey({ apiKey, resourcePath, model, abortController, messages }) {
+async function testAnthropicKey({ apiKey, workspace, resourcePath, model, abortController, messages }) {
     const { system, messages: anthropicMessages } = convertOpenAIToAnthropicMessages(messages);
     const headers = {
         'X-Provider': 'anthropic',
@@ -371,12 +392,10 @@ async function testAnthropicKey({ apiKey, resourcePath, model, abortController,
         headers['X-API-Key'] = apiKey;
     }
     const anthropicClient = apiKey
-        ? new Anthropic({
-            baseURL: `${location.origin}${OpenAPI.BASE}/ai/proxy`,
-            apiKey: 'fake-key',
-            dangerouslyAllowBrowser: true
-        })
-        : workspaceAIClients.getAnthropicClient();
+        ? createAnthropicProxyClient(getAiProxyBaseURL())
+        : workspace
+            ? workspaceAIClients.createAnthropicClient(workspace)
+            : workspaceAIClients.getAnthropicClient();
     await anthropicClient.messages.create({
         model,
         max_tokens: 100,
@@ -556,15 +575,10 @@ export async function getNonStreamingCompletion(messages, abortController, testO
         };
     }
     const openaiClient = testOptions?.apiKey
-        ? new OpenAI({
-            baseURL: `${location.origin}${OpenAPI.BASE}/ai/proxy`,
-            apiKey: 'fake-key',
-            defaultHeaders: {
-                Authorization: '' // a non empty string will be unable to access Windmill backend proxy
-            },
-            dangerouslyAllowBrowser: true
-        })
-        : workspaceAIClients.getOpenaiClient();
+        ? createOpenAIProxyClient(getAiProxyBaseURL())
+        : testOptions?.workspace
+            ? workspaceAIClients.createOpenaiClient(testOptions.workspace)
+            : workspaceAIClients.getOpenaiClient();
     const completion = await openaiClient.chat.completions.create(config, fetchOptions);
     response = completion.choices?.[0]?.message.content || '';
     return response;
@@ -621,7 +635,12 @@ export async function getFimCompletion(prompt, suffix, providerModel, abortContr
     }
 }
 export async function getCompletion(messages, abortController, tools, options) {
-    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true, tools });
+    const { provider, config } = getProviderAndCompletionConfig({
+        messages,
+        stream: true,
+        tools,
+        forceModelProvider: options?.forceModelProvider
+    });
     // Use Responses API for OpenAI and Azure OpenAI
     if ((provider === 'openai' || provider === 'azure_openai') && !options?.forceCompletions) {
         try {
@@ -633,8 +652,8 @@ export async function getCompletion(messages, abortController, tools, options) {
         }
     }
     // Use Completions API for other providers
-    const openaiClient = workspaceAIClients.getOpenaiClient();
-    const completion = openaiClient.chat.completions.create(config, {
+    const client = options?.openaiClient ?? workspaceAIClients.getOpenaiClient();
+    const completion = client.chat.completions.create(config, {
         signal: abortController.signal,
         headers: {
             'X-Provider': provider
@@ -652,8 +671,8 @@ function extractFirstJSON(str) {
     }
     return str.slice(0, i + 1);
 }
-export async function parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers, _abortController // unused, for signature compatibility with parseAnthropicCompletion
-) {
+export async function parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers, _abortController, // unused, for signature compatibility with parseAnthropicCompletion
+options) {
     const finalToolCalls = {};
     let malformedFunctionCallError = false;
     let answer = '';
@@ -773,7 +792,8 @@ export async function parseOpenAICompletion(completion, callbacks, messages, add
                 tools,
                 toolCall,
                 helpers,
-                toolCallbacks: callbacks
+                toolCallbacks: callbacks,
+                workspace: options?.workspace
             });
             messages.push(messageToAdd);
             addedMessages.push(messageToAdd);

package/package/components/dbOps.d.ts

@@ -48,7 +48,7 @@ export type IDbSchemaOps = {
     previewCreateSql: (params: {
         values: TableEditorValues;
         schema?: string;
-    }) => string;
+    }) => Promise<string>;
     onAlter: (params: {
         values: AlterTableValues;
         schema?: string;
@@ -56,7 +56,7 @@ export type IDbSchemaOps = {
     previewAlterSql: (params: {
         values: AlterTableValues;
         schema?: string;
-    }) => string[];
+    }) => Promise<string>;
     onCreateSchema: (params: {
         schema: string;
     }) => Promise<void>;

package/package/components/dbOps.js

@@ -1,46 +1,42 @@
 import { getLanguageByResourceType } from './apps/components/display/dbtable/utils';
-import { makeSelectQuery } from './apps/components/display/dbtable/queries/select';
 import { runScriptAndPollResult } from './jobs/utils';
-import { makeCountQuery } from './apps/components/display/dbtable/queries/count';
-import { makeUpdateQuery } from './apps/components/display/dbtable/queries/update';
-import { makeDeleteQuery } from './apps/components/display/dbtable/queries/delete';
-import { makeInsertQuery } from './apps/components/display/dbtable/queries/insert';
-import { makeDeleteTableQuery } from './apps/components/display/dbtable/queries/deleteTable';
 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';
+import {} from './apps/components/display/dbtable/queries/alterTable';
+import { transformForeignKeys, transformSnowflakeForeignKeys } from './apps/components/display/dbtable/queries/relationalKeys';
 export function dbTableOpsWithPreviewScripts({ input, tableKey, colDefs, workspace }) {
     const dbType = getDbType(input);
     const language = getLanguageByResourceType(dbType);
     const dbArg = getDatabaseArg(input);
+    const ducklake = input.type === 'ducklake' ? input.ducklake : undefined;
+    function makeMarker(op, payload) {
+        if (ducklake)
+            payload.ducklake = ducklake;
+        return `-- WM_INTERNAL_DB_${op} ${JSON.stringify(payload)}`;
+    }
     return {
         dbType,
         tableKey,
         colDefs,
         getCount: async ({ quicksearch }) => {
-            let countQuery = makeCountQuery(dbType, tableKey, undefined, colDefs);
-            if (input.type === 'ducklake')
-                countQuery = wrapDucklakeQuery(countQuery, input.ducklake);
+            const content = makeMarker('COUNT', { table: tableKey, columnDefs: colDefs });
             const result = await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg, quicksearch }, language, content: countQuery }
+                requestBody: { args: { ...dbArg, quicksearch }, language, content }
             });
             const count = result?.[0].count;
             return count;
         },
         getRows: async (params) => {
-            let query = makeSelectQuery(tableKey, colDefs, undefined, dbType, undefined, {
+            const content = makeMarker('SELECT', {
+                table: tableKey,
+                columnDefs: colDefs,
                 fixPgIntTypes: true
             });
-            if (input.type === 'ducklake')
-                query = wrapDucklakeQuery(query, input.ducklake);
             let items = (await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg, ...params }, language, content: query }
+                requestBody: { args: { ...dbArg, ...params }, language, content }
             }));
             if (!items || !Array.isArray(items)) {
                 throw 'items is not an array';
@@ -48,34 +44,32 @@ export function dbTableOpsWithPreviewScripts({ input, tableKey, colDefs, workspa
             return items;
         },
         onUpdate: async ({ values }, colDef, newValue) => {
-            let updateQuery = makeUpdateQuery(tableKey, colDef, colDefs, dbType);
-            if (input.type === 'ducklake')
-                updateQuery = wrapDucklakeQuery(updateQuery, input.ducklake);
+            const content = makeMarker('UPDATE', {
+                table: tableKey,
+                column: colDef,
+                columns: colDefs
+            });
             await runScriptAndPollResult({
                 workspace,
                 requestBody: {
                     args: { ...dbArg, value_to_update: newValue, ...values },
                     language,
-                    content: updateQuery
+                    content
                 }
             });
         },
         onDelete: async ({ values }) => {
-            let deleteQuery = makeDeleteQuery(tableKey, colDefs, dbType);
-            if (input.type === 'ducklake')
-                deleteQuery = wrapDucklakeQuery(deleteQuery, input.ducklake);
+            const content = makeMarker('DELETE', { table: tableKey, columns: colDefs });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg, ...values }, language, content: deleteQuery }
+                requestBody: { args: { ...dbArg, ...values }, language, content }
             });
         },
         onInsert: async ({ values }) => {
-            let insertQuery = makeInsertQuery(tableKey, colDefs, dbType);
-            if (input.type === 'ducklake')
-                insertQuery = wrapDucklakeQuery(insertQuery, input.ducklake);
+            const content = makeMarker('INSERT', { table: tableKey, columns: colDefs });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg, ...values }, language, content: insertQuery }
+                requestBody: { args: { ...dbArg, ...values }, language, content }
             });
         }
     };
@@ -84,56 +78,126 @@ export function dbSchemaOpsWithPreviewScripts({ workspace, input }) {
     const dbType = getDbType(input);
     const dbArg = getDatabaseArg(input);
     const language = getLanguageByResourceType(dbType);
+    const ducklake = input.type === 'ducklake' ? input.ducklake : undefined;
+    function makeMarker(op, payload) {
+        if (ducklake)
+            payload.ducklake = ducklake;
+        return `-- WM_INTERNAL_DB_${op} ${JSON.stringify(payload)}`;
+    }
     return {
         onDelete: async ({ tableKey, schema }) => {
-            let deleteQuery = makeDeleteTableQuery(tableKey, dbType, schema);
-            if (input.type === 'ducklake')
-                deleteQuery = wrapDucklakeQuery(deleteQuery, input.ducklake);
+            const content = makeMarker('DROP_TABLE', { table: tableKey, schema });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg }, language, content: deleteQuery }
+                requestBody: { args: { ...dbArg }, language, content }
             });
         },
         onCreate: async ({ values, schema }) => {
-            let query = makeCreateTableQuery(values, dbType, schema);
-            if (input?.type === 'ducklake')
-                query = wrapDucklakeQuery(query, input.ducklake);
+            const content = makeMarker('CREATE_TABLE', {
+                name: values.name,
+                columns: values.columns,
+                foreignKeys: values.foreignKeys,
+                schema
+            });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: dbArg, content: query, language }
+                requestBody: { args: dbArg, content, language }
             });
         },
-        previewCreateSql: ({ values, schema }) => makeCreateTableQuery(values, dbType, schema),
+        previewCreateSql: async ({ values, schema }) => {
+            const content = makeMarker('CREATE_TABLE', {
+                name: values.name,
+                columns: values.columns,
+                foreignKeys: values.foreignKeys,
+                schema
+            });
+            return expandMarker(workspace, language, content);
+        },
         onAlter: async ({ values, schema }) => {
-            let query = makeAlterTableQuery(values, dbType, schema);
-            if (input.type === 'ducklake')
-                query = wrapDucklakeQuery(query, input.ducklake);
+            const content = makeMarker('ALTER_TABLE', {
+                name: values.name,
+                operations: values.operations,
+                schema
+            });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: dbArg, content: query, language }
+                requestBody: { args: dbArg, content, language }
+            });
+        },
+        previewAlterSql: async ({ values, schema }) => {
+            const content = makeMarker('ALTER_TABLE', {
+                name: values.name,
+                operations: values.operations,
+                schema
             });
+            return expandMarker(workspace, language, content);
         },
-        previewAlterSql: ({ values, schema }) => makeAlterTableQueries(values, dbType, schema),
         onCreateSchema: async ({ schema }) => {
-            let createSchemaQuery = `CREATE SCHEMA ${schema};`;
-            if (input.type === 'ducklake')
-                createSchemaQuery = wrapDucklakeQuery(createSchemaQuery, input.ducklake);
+            const content = makeMarker('CREATE_SCHEMA', { schema });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg }, language, content: createSchemaQuery }
+                requestBody: { args: { ...dbArg }, language, content }
             });
         },
         onDeleteSchema: async ({ schema }) => {
-            let dropSchemaQuery = `DROP SCHEMA ${schema} CASCADE;`;
-            if (input.type === 'ducklake')
-                dropSchemaQuery = wrapDucklakeQuery(dropSchemaQuery, input.ducklake);
+            const content = makeMarker('DROP_SCHEMA', { schema });
             await runScriptAndPollResult({
                 workspace,
-                requestBody: { args: { ...dbArg }, language, content: dropSchemaQuery }
+                requestBody: { args: { ...dbArg }, language, content }
             });
         },
         onFetchTableEditorDefinition: async ({ table, schema, colDefs }) => {
-            let { foreignKeys, pk_constraint_name } = await fetchTableRelationalKeys(input, dbType, table, schema, workspace, dbArg, language);
+            let foreignKeys = [];
+            let pk_constraint_name;
+            // Fetch foreign keys (not supported for BigQuery)
+            if (dbType !== 'bigquery') {
+                try {
+                    const fkContent = makeMarker('FOREIGN_KEYS', { table, schema });
+                    const fkResult = await runScriptAndPollResult({
+                        workspace,
+                        requestBody: { args: dbArg, content: fkContent, language }
+                    });
+                    let rawForeignKeys;
+                    if (dbType === 'snowflake') {
+                        rawForeignKeys = transformSnowflakeForeignKeys(fkResult);
+                    }
+                    else {
+                        rawForeignKeys = fkResult;
+                        if (rawForeignKeys && Array.isArray(rawForeignKeys)) {
+                            rawForeignKeys = rawForeignKeys.map((fk) => {
+                                const lowerFk = {};
+                                Object.keys(fk).forEach((key) => {
+                                    lowerFk[key.toLowerCase()] = fk[key];
+                                });
+                                return lowerFk;
+                            });
+                        }
+                    }
+                    if (rawForeignKeys && Array.isArray(rawForeignKeys)) {
+                        foreignKeys = transformForeignKeys(rawForeignKeys);
+                    }
+                }
+                catch (e) {
+                    console.warn('Failed to fetch foreign keys:', e);
+                }
+            }
+            // Fetch primary key constraint name (not supported for BigQuery/MySQL)
+            if (dbType !== 'bigquery' && dbType !== 'mysql') {
+                try {
+                    const pkContent = makeMarker('PRIMARY_KEY_CONSTRAINT', { table, schema });
+                    const pkResult = (await runScriptAndPollResult({
+                        workspace,
+                        requestBody: { args: dbArg, content: pkContent, language }
+                    }));
+                    if (pkResult && Array.isArray(pkResult) && pkResult.length > 0) {
+                        const pkRecord = pkResult[0];
+                        pk_constraint_name = pkRecord?.constraint_name || pkRecord?.CONSTRAINT_NAME || '';
+                    }
+                }
+                catch (e) {
+                    console.warn('Failed to fetch primary key constraint:', e);
+                }
+            }
             return buildTableEditorValues({
                 tableName: table,
                 metadata: colDefs,
@@ -201,3 +265,15 @@ export function getDatabaseArg(input) {
     }
     return {};
 }
+async function expandMarker(workspace, language, content) {
+    const response = await fetch(`/api/w/${workspace}/internal_db/expand_marker`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ language, content })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const result = (await response.json());
+    return result.code;
+}