@sqlrooms/ai 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2025 Ilya Boyandin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/AiSlice.d.ts

@@ -0,0 +1,366 @@
+import { ProjectState } from '@sqlrooms/project-builder';
+import { BaseProjectConfig } from '@sqlrooms/project-config';
+import { CoreAssistantMessage, CoreToolMessage, CoreUserMessage, LanguageModelV1 } from 'ai';
+import { z } from 'zod';
+type AiMessage = (CoreToolMessage | CoreAssistantMessage | CoreUserMessage) & {
+    id: string;
+};
+export declare const AiSliceConfig: z.ZodObject<{
+    ai: z.ZodObject<{
+        model: z.ZodString;
+        analysisResults: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            toolResults: z.ZodArray<z.ZodObject<{
+                toolName: z.ZodString;
+                toolCallId: z.ZodString;
+                args: z.ZodRecord<z.ZodString, z.ZodAny>;
+                result: z.ZodUnion<[z.ZodObject<{
+                    success: z.ZodLiteral<false>;
+                    error: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    success: false;
+                    error: string;
+                }, {
+                    success: false;
+                    error: string;
+                }>, z.ZodObject<{
+                    success: z.ZodLiteral<true>;
+                    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    success: true;
+                    data: Record<string, any>;
+                }, {
+                    success: true;
+                    data: Record<string, any>;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }, {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }>, "many">;
+            toolCalls: z.ZodArray<z.ZodObject<{
+                toolName: z.ZodString;
+                toolCallId: z.ZodString;
+                args: z.ZodUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"query">;
+                    sqlQuery: z.ZodString;
+                    reasoning: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                }, {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"answer">;
+                    answer: z.ZodString;
+                    chart: z.ZodUnion<[z.ZodObject<{
+                        sqlQuery: z.ZodString;
+                        vegaLiteSpec: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    }, {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    }>, z.ZodNull]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                }, {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }, {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }, {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        analysisResults: {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }[];
+    }, {
+        model: string;
+        analysisResults: {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ai: {
+        model: string;
+        analysisResults: {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }[];
+    };
+}, {
+    ai: {
+        model: string;
+        analysisResults: {
+            id: string;
+            prompt: string;
+            toolResults: {
+                toolName: string;
+                toolCallId: string;
+                args: Record<string, any>;
+                result: {
+                    success: false;
+                    error: string;
+                } | {
+                    success: true;
+                    data: Record<string, any>;
+                };
+            }[];
+            toolCalls: {
+                toolName: string;
+                toolCallId: string;
+                args: {
+                    type: "query";
+                    sqlQuery: string;
+                    reasoning: string;
+                } | {
+                    type: "answer";
+                    answer: string;
+                    chart: {
+                        sqlQuery: string;
+                        vegaLiteSpec: string;
+                    } | null;
+                };
+            }[];
+        }[];
+    };
+}>;
+export type AiSliceConfig = z.infer<typeof AiSliceConfig>;
+export declare function createDefaultAiConfig(): AiSliceConfig;
+export type AiSliceState = {
+    ai: {
+        supportedModels: string[];
+        analysisPrompt: string;
+        isRunningAnalysis: boolean;
+        analysisAbortController?: AbortController;
+        apiKey: string | null;
+        setAiModel: (model: string) => void;
+        setAnalysisPrompt: (prompt: string) => void;
+        setApiKey: (key: string) => void;
+        startAnalysis: () => Promise<void>;
+        cancelAnalysis: () => void;
+        messagesById: Map<string, AiMessage>;
+        addMessages: (messages: AiMessage[]) => void;
+        getMessages: () => AiMessage[];
+    };
+};
+export declare function createAiSlice<PC extends BaseProjectConfig & AiSliceConfig>({ supportedModels, createModel, }: {
+    supportedModels: string[];
+    createModel: (model: string, apiKey: string) => LanguageModelV1;
+}): import("zustand").StateCreator<AiSliceState>;
+type ProjectConfigWithAi = BaseProjectConfig & AiSliceConfig;
+type ProjectStateWithAi = ProjectState<ProjectConfigWithAi> & AiSliceState;
+export declare function useStoreWithAi<T>(selector: (state: ProjectStateWithAi) => T): T;
+export {};
+//# sourceMappingURL=AiSlice.d.ts.map

package/dist/AiSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiSlice.d.ts","sourceRoot":"","sources":["../src/AiSlice.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EAEb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,eAAe,EAChB,MAAM,IAAI,CAAC;AAEZ,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAQtB,KAAK,SAAS,GAAG,CAAC,eAAe,GAAG,oBAAoB,GAAG,eAAe,CAAC,GAAG;IAC5E,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,wBAAgB,qBAAqB,IAAI,aAAa,CAOrD;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE;QACF,eAAe,EAAE,MAAM,EAAE,CAAC;QAC1B,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,OAAO,CAAC;QAC3B,uBAAuB,CAAC,EAAE,eAAe,CAAC;QAC1C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QACpC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;QAC5C,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QACjC,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QACnC,cAAc,EAAE,MAAM,IAAI,CAAC;QAC3B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QACrC,WAAW,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;QAC7C,WAAW,EAAE,MAAM,SAAS,EAAE,CAAC;KAChC,CAAC;CACH,CAAC;AAEF,wBAAgB,aAAa,CAAC,EAAE,SAAS,iBAAiB,GAAG,aAAa,EAAE,EAC1E,eAAe,EACf,WAAW,GACZ,EAAE;IACD,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,eAAe,CAAC;CACjE,gDAuKA;AAsCD,KAAK,mBAAmB,GAAG,iBAAiB,GAAG,aAAa,CAAC;AAC7D,KAAK,kBAAkB,GAAG,YAAY,CAAC,mBAAmB,CAAC,GAAG,YAAY,CAAC;AAE3E,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,CAAC,GACzC,CAAC,CAMH"}

package/dist/AiSlice.js

@@ -0,0 +1,191 @@
+import { createId } from '@paralleldrive/cuid2';
+import { createProjectSlice, useBaseProjectStore, } from '@sqlrooms/project-builder';
+import { produce } from 'immer';
+import { z } from 'zod';
+import { runAnalysis } from './analysis';
+import { AnalysisResultSchema, } from './schemas';
+export const AiSliceConfig = z.object({
+    ai: z.object({
+        model: z.string(),
+        analysisResults: z.array(AnalysisResultSchema),
+    }),
+});
+export function createDefaultAiConfig() {
+    return {
+        ai: {
+            model: 'gpt-4o-mini',
+            analysisResults: [],
+        },
+    };
+}
+export function createAiSlice({ supportedModels, createModel, }) {
+    return createProjectSlice((set, get) => ({
+        ai: {
+            supportedModels,
+            analysisPrompt: 'Describe the data in the table and make a chart providing an overview.',
+            isRunningAnalysis: false,
+            messagesById: new Map(),
+            apiKey: typeof window !== 'undefined'
+                ? localStorage.getItem('ai_api_key')
+                : null,
+            setApiKey: (key) => {
+                localStorage.setItem('ai_api_key', key);
+                set((state) => produce(state, (draft) => {
+                    draft.ai.apiKey = key;
+                }));
+            },
+            setAnalysisPrompt: (prompt) => {
+                set((state) => produce(state, (draft) => {
+                    draft.ai.analysisPrompt = prompt;
+                }));
+            },
+            setAiModel: (model) => {
+                set({ projectConfig: { ...get().projectConfig, model: model } });
+            },
+            /**
+             * Add messages to the project store uniquely by id
+             * @param messages - The messages to add.
+             */
+            addMessages: (messages) => {
+                set((state) => {
+                    const newMessages = messages.filter((m) => !state.ai.messagesById.has(m.id));
+                    const newMessagesById = new Map(state.ai.messagesById);
+                    for (const m of newMessages) {
+                        if (!m.id) {
+                            console.warn('Message has no id', m);
+                        }
+                        newMessagesById.set(m.id, m);
+                    }
+                    console.log('newMessagesById', Array.from(newMessagesById.values()));
+                    return {
+                        ai: {
+                            ...state.ai,
+                            messagesById: newMessagesById,
+                        },
+                    };
+                });
+            },
+            getMessages: () => {
+                return Array.from(get().ai.messagesById.values());
+            },
+            startAnalysis: async () => {
+                const resultId = createId();
+                const abortController = new AbortController();
+                const { apiKey } = get().ai;
+                const model = get().projectConfig.ai.model;
+                if (!apiKey) {
+                    throw new Error('OpenAI API key is required');
+                }
+                set((state) => produce(state, (draft) => {
+                    draft.ai.analysisAbortController = abortController;
+                    draft.ai.isRunningAnalysis = true;
+                    draft.projectConfig.ai.analysisResults.push({
+                        id: resultId,
+                        prompt: get().ai.analysisPrompt,
+                        toolResults: [],
+                        toolCalls: [],
+                    });
+                }));
+                get().ai.addMessages([
+                    {
+                        id: createId(),
+                        role: 'user',
+                        content: get().ai.analysisPrompt,
+                    },
+                ]);
+                set((state) => produce(state, (draft) => {
+                    draft.ai.analysisPrompt = '';
+                }));
+                try {
+                    const { toolResults, toolCalls, ...rest } = await runAnalysis({
+                        model: createModel(model, apiKey),
+                        // prompt: get().analysisPrompt,
+                        messages: get().ai.getMessages(),
+                        onStepFinish: (event) => {
+                            console.log('onStepFinish', event);
+                            get().ai.addMessages(event.response.messages);
+                            set(makeResultsAppender({
+                                resultId,
+                                toolResults: event.toolResults,
+                                toolCalls: event.toolCalls,
+                            }));
+                        },
+                        abortSignal: abortController.signal,
+                        apiKey,
+                    });
+                    console.log('final result', { toolResults, toolCalls, ...rest });
+                    get().ai.addMessages([
+                        {
+                            id: createId(),
+                            role: 'tool',
+                            content: [],
+                            // @ts-ignore
+                            tool_call_id: toolCalls[toolCalls.length - 1].toolCallId,
+                        },
+                    ]);
+                    // set(
+                    //   makeResultsAppender({
+                    //     resultId,
+                    //     toolResults,
+                    //     toolCalls: rest.toolCalls,
+                    //   }),
+                    // );
+                }
+                catch (err) {
+                    set(makeResultsAppender({
+                        resultId,
+                        toolResults: [
+                            {
+                                toolName: 'answer',
+                                toolCallId: createId(),
+                                args: {},
+                                result: {
+                                    success: false,
+                                    error: err instanceof Error ? err.message : String(err),
+                                },
+                            },
+                        ],
+                        toolCalls: [],
+                    }));
+                }
+                finally {
+                    set((state) => produce(state, (draft) => {
+                        draft.ai.isRunningAnalysis = false;
+                    }));
+                }
+            },
+            cancelAnalysis: () => {
+                set((state) => produce(state, (draft) => {
+                    draft.ai.isRunningAnalysis = false;
+                }));
+                get().ai.analysisAbortController?.abort('Analysis cancelled');
+            },
+        },
+    }));
+}
+function findResultById(analysisResults, id) {
+    return analysisResults.find((r) => r.id === id);
+}
+/**
+ * Returns a function that will update the state by appending new results
+ * to the analysis results.
+ * @param resultId - The result id
+ * @param toolResults - The new tool results
+ * @param toolCalls - The new tool calls
+ * @returns The new state
+ */
+function makeResultsAppender({ resultId, toolResults, toolCalls, }) {
+    return (state) => produce(state, (draft) => {
+        const result = findResultById(draft.projectConfig.ai.analysisResults, resultId);
+        if (result) {
+            result.toolResults = [...result.toolResults, ...toolResults];
+            result.toolCalls = [...result.toolCalls, ...toolCalls];
+        }
+        else {
+            console.error('Result not found', resultId);
+        }
+    });
+}
+export function useStoreWithAi(selector) {
+    return useBaseProjectStore((state) => selector(state));
+}

package/dist/AnalysisResult.d.ts

@@ -0,0 +1,7 @@
+import { AnalysisResultSchema } from './schemas';
+interface AnalysisResultProps {
+    result: AnalysisResultSchema;
+}
+export declare const AnalysisResult: React.FC<AnalysisResultProps>;
+export {};
+//# sourceMappingURL=AnalysisResult.d.ts.map

package/dist/AnalysisResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalysisResult.d.ts","sourceRoot":"","sources":["../src/AnalysisResult.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAC,MAAM,WAAW,CAAC;AAM/C,UAAU,mBAAmB;IAC3B,MAAM,EAAE,oBAAoB,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAmCxD,CAAC"}

package/dist/AnalysisResult.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ToolCall } from './ToolCall';
+import { ToolResult } from './ToolResult';
+import { SquareTerminalIcon, CodeIcon } from 'lucide-react';
+import { Button, Popover, PopoverContent, PopoverTrigger } from '@sqlrooms/ui';
+export const AnalysisResult = ({ result }) => {
+    return (_jsxs("div", { className: "flex flex-col w-full text-sm gap-5 border py-6 px-4 rounded-md", children: [_jsxs("div", { className: "bg-gray-700 p-2 mb-2 rounded-md text-gray-100 flex items-center gap-2", children: [_jsx(SquareTerminalIcon, { className: "w-4 h-4" }), _jsx("div", { className: "text-sm flex-1", children: result.prompt }), _jsxs(Popover, { children: [_jsx(PopoverTrigger, { asChild: true, children: _jsx(Button, { variant: "ghost", size: "icon", className: "w-6 h-6", children: _jsx(CodeIcon, { className: "w-4 h-4" }) }) }), _jsx(PopoverContent, { className: "w-[400px] max-h-[400px] overflow-auto", align: "end", side: "right", children: _jsx("pre", { className: "text-xs", children: JSON.stringify(result, null, 2) }) })] })] }), _jsx("div", { className: "flex flex-col gap-5 px-4", children: result.toolResults.map((toolResult) => (_jsx(ToolResult, { toolResult: toolResult }, toolResult.toolCallId))) }), _jsx("div", { className: "flex flex-col gap-5 px-4", children: result.toolCalls
+                    .filter((toolCall) => toolCall.toolName === 'answer')
+                    .map((toolCall) => (_jsx(ToolCall, { toolCall: toolCall }, toolCall.toolCallId))) })] }));
+};

package/dist/AnalysisResultsContainer.d.ts

@@ -0,0 +1,2 @@
+export declare const AnalysisResultsContainer: React.FC;
+//# sourceMappingURL=AnalysisResultsContainer.d.ts.map

package/dist/AnalysisResultsContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalysisResultsContainer.d.ts","sourceRoot":"","sources":["../src/AnalysisResultsContainer.tsx"],"names":[],"mappings":"AAUA,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EA6C5C,CAAC"}

package/dist/AnalysisResultsContainer.js

@@ -0,0 +1,14 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn, SkeletonPane } from '@sqlrooms/ui';
+import { ChevronDown } from 'lucide-react';
+import { useStoreWithAi } from './AiSlice';
+import { AnalysisResult } from './AnalysisResult';
+import { useScrollToBottom, useScrollToBottomButton, } from './hooks/use-scroll-to-bottom';
+export const AnalysisResultsContainer = () => {
+    const isRunningAnalysis = useStoreWithAi((s) => s.ai.isRunningAnalysis);
+    const analysisResults = useStoreWithAi((s) => s.projectConfig.ai.analysisResults);
+    const [messagesContainerRef, messagesEndRef] = useScrollToBottom();
+    const { showButton, scrollToBottom } = useScrollToBottomButton(messagesContainerRef);
+    return (_jsxs("div", { className: "flex relative h-full w-full overflow-hidden", children: [_jsxs("div", { className: "flex flex-grow flex-col w-full gap-4 p-4 overflow-auto", ref: messagesContainerRef, children: [_jsxs("div", { className: "flex flex-col gap-10 ", children: [analysisResults.map((result) => (_jsx(AnalysisResult, { result: result }, result.id))), _jsx("div", { className: "h-20" }), messagesEndRef && (_jsx("div", { ref: messagesEndRef, className: "shrink-0 min-w-[24px] min-h-[24px]" }))] }), isRunningAnalysis && _jsx(SkeletonPane, { className: "p-4" })] }), _jsx("div", { className: "absolute inset-x-0 bottom-0 pointer-events-none flex justify-center", children: _jsx("button", { onClick: scrollToBottom, className: cn('pointer-events-auto bg-primary hover:bg-primary/90 text-primary-foreground z-50', 'rounded-full p-2 shadow-md transition-all duration-200 opacity-0 translate-y-4 mb-6', showButton && 'opacity-100 translate-y-0'), "aria-label": "Scroll to bottom", children: _jsx(ChevronDown, { className: "w-5 h-5" }) }) })] }));
+};

package/dist/QueryControls.d.ts

@@ -0,0 +1,6 @@
+interface QueryControlsProps {
+    className?: string;
+}
+export declare const QueryControls: React.FC<QueryControlsProps>;
+export {};
+//# sourceMappingURL=QueryControls.d.ts.map

package/dist/QueryControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryControls.d.ts","sourceRoot":"","sources":["../src/QueryControls.tsx"],"names":[],"mappings":"AAgBA,UAAU,kBAAkB;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAgHtD,CAAC"}

package/dist/QueryControls.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, cn, Input, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Spinner, Textarea, } from '@sqlrooms/ui';
+import { KeyIcon, OctagonXIcon } from 'lucide-react';
+import { useCallback } from 'react';
+import { useStoreWithAi } from './AiSlice';
+export const QueryControls = ({ className }) => {
+    const isRunningAnalysis = useStoreWithAi((s) => s.ai.isRunningAnalysis);
+    const runAnalysis = useStoreWithAi((s) => s.ai.startAnalysis);
+    const cancelAnalysis = useStoreWithAi((s) => s.ai.cancelAnalysis);
+    const analysisPrompt = useStoreWithAi((s) => s.ai.analysisPrompt);
+    const setAnalysisPrompt = useStoreWithAi((s) => s.ai.setAnalysisPrompt);
+    const apiKey = useStoreWithAi((s) => s.ai.apiKey);
+    const setApiKey = useStoreWithAi((s) => s.ai.setApiKey);
+    const model = useStoreWithAi((s) => s.projectConfig.ai.model);
+    const setAiModel = useStoreWithAi((s) => s.ai.setAiModel);
+    const supportedModels = useStoreWithAi((s) => s.ai.supportedModels);
+    const handleKeyDown = useCallback((e) => {
+        if (e.key === 'Enter' &&
+            !e.shiftKey &&
+            !e.ctrlKey &&
+            !e.altKey &&
+            !e.metaKey) {
+            e.preventDefault();
+            if (!isRunningAnalysis &&
+                apiKey &&
+                model &&
+                analysisPrompt.trim().length) {
+                runAnalysis();
+            }
+        }
+    }, [isRunningAnalysis, apiKey, model, analysisPrompt, runAnalysis]);
+    return (_jsxs("div", { className: cn('flex flex-col items-center justify-center gap-4 w-full p-4', className), children: [_jsxs("div", { className: "flex items-center justify-between gap-4 w-full", children: [_jsx("div", { className: "font-semibold text-lg pl-1", children: "What would you like to learn about the data?" }), _jsx("div", { className: "flex-col items-center gap-2", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsxs("div", { className: "relative flex items-center", children: [_jsx(KeyIcon, { className: "w-4 h-4 absolute left-2 text-gray-400" }), _jsx(Input, { type: "password", placeholder: "OpenAI API Key", value: apiKey || '', onChange: (e) => setApiKey(e.target.value), className: "pl-8 w-[150px] bg-gray-800" })] }), _jsxs(Select, { value: model || '', onValueChange: setAiModel, children: [_jsx(SelectTrigger, { className: "w-[140px] bg-gray-800", children: _jsx(SelectValue, { placeholder: "Select model" }) }), _jsx(SelectContent, { children: supportedModels.map((model) => (_jsx(SelectItem, { value: model, children: model }, model))) })] })] }) })] }), _jsxs("div", { className: "relative w-full", children: [_jsx(Textarea, { disabled: isRunningAnalysis, className: "h-[100px] bg-gray-800", value: analysisPrompt, onChange: (e) => setAnalysisPrompt(e.target.value), onKeyDown: handleKeyDown }), _jsxs("div", { className: "absolute top-1 right-1 flex items-center gap-2", children: [isRunningAnalysis && (_jsxs(Button, { variant: "outline", onClick: cancelAnalysis, children: [_jsx(OctagonXIcon, { className: "w-4 h-4" }), "Stop"] })), _jsx(Button, { variant: "outline", onClick: runAnalysis, disabled: isRunningAnalysis ||
+                                    !apiKey ||
+                                    !model ||
+                                    !analysisPrompt.trim().length, children: isRunningAnalysis ? (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Spinner, { className: "w-4 h-4" }), " Running\u2026"] })) : ('Start Analysis') })] })] })] }));
+};