@grapesjs/studio-sdk-plugins 1.0.32 → 1.0.33-rc.1

package/dist/aiChat/clientTools.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from 'grapesjs';
+import { AiChatDefaultTools, AiChatToolApis } from './types';
+export declare const defaultToolApis: Required<AiChatToolApis>;
+export declare function createDefaultTools(editor: Editor, toolApis?: AiChatToolApis): AiChatDefaultTools;

package/dist/aiChat/clientToolsProcessors.d.ts

@@ -0,0 +1,94 @@
+import { UIMessage } from '@ai-sdk/react';
+import { ChatOnDataCallback } from 'ai';
+import { Component, Editor } from 'grapesjs';
+import { UpdatesFromStream } from './components/utils';
+import { AiChatToolName, AiChatToolsArguments, ChatToolAgentCode, ToolDataAddComponent, ToolDataAddPage, ToolDataAddProjectPage, ToolDataEditComponent, ToolDataTypes } from './types';
+export interface ToolAddComponentSetupResult {
+    target: Component | undefined;
+    at: number | undefined;
+    domPosition: InsertPosition;
+    tempDOM: HTMLDivElement;
+    tempTargetEl: HTMLElement | undefined;
+    cleanUp: () => void;
+}
+export interface ToolEditComponentSetupResult {
+    toUpdate: {
+        cleanup(): void;
+        update: (content: string) => Map<string, UpdatesFromStream>;
+    };
+    mapUpdates: Map<string, UpdatesFromStream>;
+    cleanUp: () => void;
+}
+export interface ToolAddPageSetupResult {
+    pageId: string;
+    cmpRoot: Component;
+    cleanUp: () => void;
+}
+export interface ToolAddProjectPageSetupResult {
+    cmpRoot: Component;
+    pageName: string;
+    isEmail: boolean;
+    cleanUp: () => void;
+}
+interface ToolStatusAddComponent {
+    type: ChatToolAgentCode.ADD_COMPONENT_CODE;
+    toolSetup: ToolAddComponentSetupResult;
+    completed?: boolean;
+}
+interface ToolStatusEditComponent {
+    type: ChatToolAgentCode.EDIT_COMPONENT_CODE;
+    toolSetup: ToolEditComponentSetupResult;
+    completed?: boolean;
+}
+interface ToolStatusAddPage {
+    type: ChatToolAgentCode.ADD_PAGE_CODE;
+    toolSetup: ToolAddPageSetupResult;
+    completed?: boolean;
+}
+interface ToolStatusAddProjectPage {
+    type: ChatToolAgentCode.ADD_PROJECT_PAGE_CODE;
+    toolSetup: ToolAddProjectPageSetupResult;
+    completed?: boolean;
+}
+export type ToolStatusProgressEntry = ToolStatusAddComponent | ToolStatusEditComponent | ToolStatusAddPage | ToolStatusAddProjectPage;
+export type ToolStatusProgressMap = Map<string, ToolStatusProgressEntry>;
+export declare function toolAddComponentSetup(editor: Editor, args: AiChatToolsArguments[AiChatToolName.ADD_NEW_COMPONENT]): ToolAddComponentSetupResult;
+export declare function toolAddComponentEnd(editor: Editor, toolSetup: ToolAddComponentSetupResult, content: string): Component | undefined;
+export declare function processToolAddComponent(props: {
+    editor: Editor;
+    toolStatus: ToolDataAddComponent;
+    toolStatusProgress: ToolStatusProgressMap;
+}): void;
+export declare function toolEditComponentEnd(editor: Editor, toolSetup: ToolEditComponentSetupResult): void;
+export declare function processToolEditComponent(props: {
+    editor: Editor;
+    toolStatus: ToolDataEditComponent;
+    toolStatusProgress: ToolStatusProgressMap;
+}): void;
+export declare function toolAddPageEnd(toolSetup: ToolAddPageSetupResult, content: string): void;
+export declare function processToolAddPage(props: {
+    editor: Editor;
+    toolStatus: ToolDataAddPage;
+    toolStatusProgress: ToolStatusProgressMap;
+}): void;
+export declare function toolAddProjectPageEnd(editor: Editor, content: string, name: string): void;
+export declare const commandMjmlToHtml = "mjml-code-to-html";
+export declare function processToolNewProjectPage(props: {
+    editor: Editor;
+    toolStatus: ToolDataAddProjectPage;
+    toolStatusProgress: ToolStatusProgressMap;
+}): void;
+type DataToolStatusProcessor = (props: {
+    editor: Editor;
+    toolStatus: ToolDataTypes;
+    toolStatusProgress: ToolStatusProgressMap;
+}) => void;
+export declare const dataToolStatusProcessors: {
+    [K in ChatToolAgentCode]?: DataToolStatusProcessor;
+};
+export declare const processDataToolsStatus: ({ editor, data, toolStatusProgress }: {
+    editor: Editor;
+    data: Parameters<ChatOnDataCallback<UIMessage>>[0];
+    toolStatusProgress: ToolStatusProgressMap;
+}) => void;
+export {};

package/dist/aiChat/components/AiChatEmptyState.d.ts

@@ -0,0 +1,9 @@
+import { CommonComponentProps } from '../types';
+export interface AiChatEmptyStateProps extends CommonComponentProps {
+    /**
+     * Suggestions to show in the empty state.
+     */
+    suggestions?: string[];
+}
+export declare const AiChatEmptyState: React.FC<AiChatEmptyStateProps>;
+export default AiChatEmptyState;

package/dist/aiChat/components/AiChatError.d.ts

@@ -0,0 +1,4 @@
+import { CommonComponentProps } from '../types';
+export interface AiChatErrorProps extends CommonComponentProps {
+}
+export declare const AiChatError: React.FC<AiChatErrorProps>;

package/dist/aiChat/components/AiChatHeader.d.ts

@@ -0,0 +1,5 @@
+import { CommonComponentProps } from '../types';
+export interface AiChatHeaderProps extends CommonComponentProps {
+}
+export declare const AiChatHeader: React.FC<AiChatHeaderProps>;
+export default AiChatHeader;

package/dist/aiChat/components/AiChatInput.d.ts

@@ -0,0 +1,17 @@
+import { CommonComponentProps, UploadedAsset } from '../types';
+export interface AiChatInputProps extends CommonComponentProps {
+    /**
+     * Maximum number of images per message. Set to 0 to disable images.
+     * @default 5
+     */
+    maxImages?: number;
+    /**
+     * Upload project assets (images) to server.
+     * If not provided and files are added, they will be sent directly to the chat.
+     */
+    uploadProjectAssets?: (props: {
+        files: File[];
+    }) => Promise<UploadedAsset[]>;
+}
+export declare const AiChatInput: React.FC<AiChatInputProps>;
+export default AiChatInput;

package/dist/aiChat/components/AiChatLoadingState.d.ts

@@ -0,0 +1,4 @@
+import { CommonComponentProps } from '../types';
+export interface AiChatLoadingStateProps extends CommonComponentProps {
+}
+export declare const AiChatLoadingState: React.FC<AiChatLoadingStateProps>;

package/dist/aiChat/components/AiChatMessage.d.ts

@@ -0,0 +1,17 @@
+import { Editor } from 'grapesjs';
+import { CSSProperties } from 'react';
+import { ChatContext, ChatMessage } from '../types';
+export interface AiChatMessageProps {
+    editor: Editor;
+    chatContext: ChatContext;
+    message: ChatMessage;
+    isStreaming?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface AiChatMessagePartProps {
+    part: ChatMessage['parts'][0];
+    isStreamingPart?: boolean;
+}
+export declare const AiChatMessage: React.FC<AiChatMessageProps>;
+export default AiChatMessage;

package/dist/aiChat/components/AiChatMessages.d.ts

@@ -0,0 +1,13 @@
+import { useChat } from '@ai-sdk/react';
+import { Editor } from 'grapesjs';
+import { ChatContext, ChatMessage } from '../types';
+type ChatStatus = ReturnType<typeof useChat>['status'];
+export interface AiChatMessagesProps {
+    editor: Editor;
+    chatContext: ChatContext;
+    messages: ChatMessage[];
+    status: ChatStatus;
+    suggestions?: string[];
+}
+export declare function AiChatMessages({ editor, chatContext, messages, status, suggestions }: AiChatMessagesProps): import("react/jsx-runtime").JSX.Element;
+export default AiChatMessages;

package/dist/aiChat/components/AiChatPanel.d.ts

@@ -0,0 +1,14 @@
+import { Editor } from 'grapesjs';
+import { AiChatOptions } from '../types';
+export interface AiChatPanelProps {
+    editor: Editor;
+    pluginOptions: AiChatOptions;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Uses AI SDK v6 patterns with DefaultChatTransport and sendMessage.
+ * Composed of AiChatHeader, AiChatMessages, and AiChatInput subcomponents.
+ */
+export declare function AiChatPanel({ editor, pluginOptions, style, className }: AiChatPanelProps): import("react/jsx-runtime").JSX.Element;
+export default AiChatPanel;

package/dist/aiChat/components/index.d.ts

@@ -0,0 +1,41 @@
+import { Editor } from 'grapesjs';
+import { AiChatOptions } from '../types';
+import { AiChatEmptyStateProps } from './AiChatEmptyState';
+import { AiChatErrorProps } from './AiChatError';
+import { AiChatHeaderProps } from './AiChatHeader';
+import { AiChatInputProps } from './AiChatInput';
+import { AiChatLoadingStateProps } from './AiChatLoadingState';
+import { AiChatMessageProps } from './AiChatMessage';
+import { AiChatPanelProps } from './AiChatPanel';
+export type { AiChatEmptyStateProps } from './AiChatEmptyState';
+export type { AiChatErrorProps } from './AiChatError';
+export type { AiChatHeaderProps } from './AiChatHeader';
+export type { AiChatInputProps } from './AiChatInput';
+export type { AiChatMessageProps } from './AiChatMessage';
+export type { AiChatMessagesProps } from './AiChatMessages';
+declare module '@studio/editor/src/types' {
+    interface CustomLayoutComponentsRegistry {
+        aiChatPanel: Pick<AiChatPanelProps, 'className' | 'style'> & {
+            type: 'aiChatPanel';
+        };
+        aiChatHeader: Pick<AiChatHeaderProps, 'className' | 'style' | 'chatContext'> & {
+            type: 'aiChatHeader';
+        };
+        aiChatError: Pick<AiChatErrorProps, 'className' | 'style' | 'chatContext'> & {
+            type: 'aiChatError';
+        };
+        aiChatLoadingState: Pick<AiChatLoadingStateProps, 'className' | 'style' | 'chatContext'> & {
+            type: 'aiChatLoadingState';
+        };
+        aiChatInput: Pick<AiChatInputProps, 'className' | 'style' | 'chatContext' | 'maxImages' | 'uploadProjectAssets'> & {
+            type: 'aiChatInput';
+        };
+        aiChatEmptyState: Pick<AiChatEmptyStateProps, 'className' | 'style' | 'chatContext' | 'suggestions'> & {
+            type: 'aiChatEmptyState';
+        };
+        aiChatMessage: Pick<AiChatMessageProps, 'className' | 'style' | 'chatContext' | 'message' | 'isStreaming'> & {
+            type: 'aiChatMessage';
+        };
+    }
+}
+export declare const registerLayoutComponents: (editor: Editor, options: AiChatOptions) => () => void;

package/dist/aiChat/components/utils.d.ts

@@ -0,0 +1,34 @@
+import { Component, Editor } from 'grapesjs';
+import { StudioLayoutComponentsConfig } from '../../types';
+import { ProjectContext } from '../types';
+export declare const getProjectContext: (editor: Editor, { withPageContent, imageUrls }?: {
+    withPageContent?: boolean;
+    imageUrls?: string[];
+}) => ProjectContext;
+export declare const renderLayoutComponent: (editor: Editor, components: StudioLayoutComponentsConfig) => any;
+export declare function clearGeneratedCode(code: string): string;
+export declare const updateDomWithStreamContent: (content?: string, el?: HTMLElement, opts?: {
+    skipScroll?: boolean;
+}) => void;
+export declare const getComponentCodeWithIds: (component?: Component) => string;
+export declare function setContentStreamStart(editor: Editor): void;
+export declare function setContentStreamEnd(editor: Editor): void;
+export declare const createToolError: (props: {
+    error: any;
+    msg: string;
+    abortMsg: string;
+}) => {
+    error: string;
+    abortedByUser: boolean | undefined;
+};
+export declare function getPageContentWithStyles(editor: Editor): string;
+export interface UpdatesFromStream {
+    cmp?: Component;
+    cmpEl?: HTMLElement;
+    newNode: Element;
+}
+export declare const createUpdatesFromStream: (editor: Editor) => {
+    cleanup(): void;
+    update: (content: string) => Map<string, UpdatesFromStream>;
+};
+export declare const replaceComponentWithHTML: (cmp: Component, content: string) => void;

package/dist/aiChat/index.d.ts

@@ -0,0 +1,4 @@
+import { SDKPluginWithAiChat } from './types';
+declare const aiChatPlugin: SDKPluginWithAiChat;
+export default aiChatPlugin;
+export type * from './types';

package/dist/aiChat/server/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * AI Chat Server Utilities
+ *
+ * This module provides utilities for creating AI chat endpoints that work
+ * with the ai-sdk and integrate with the GrapesJS Studio SDK.
+ *
+ * @example
+ * ```ts
+ * // In your API route (e.g., Next.js)
+ * import {
+ *   createStreamResponse,
+ *   createModel,
+ *   createTool,
+ *   createToolsWeb,
+ *   getSystemPromptChatPM
+ * } from '@grapesjs/studio-sdk-plugins/dist/aiChat/server';
+ *
+ * export const POST = async (request: Request) => {
+ *   const body = await request.json();
+ *
+ *   const model = await createModel('openai/gpt-4', {
+ *     apiKey: process.env.OPENAI_API_KEY
+ *   });
+ *
+ *   return createStreamResponse({
+ *     model,
+ *     systemPrompt: getSystemPromptChatPM({
+ *       projectContext: body.projectContext
+ *     }),
+ *     messages: body.messages,
+ *     tools: {
+ *       ...createToolsWeb(),
+ *       // Add custom tools
+ *       myCustomTool: createTool({
+ *         description: 'Description for the LLM',
+ *         inputSchema: z.object({
+ *           input: z.string()
+ *         }),
+ *         execute: async ({ input }) => {
+ *           // Custom logic
+ *           return { result: 'success' };
+ *         }
+ *       })
+ *     }
+ *   });
+ * };
+ * ```
+ */
+export { streamText } from 'ai';
+export * from './stream';
+export * from './models';
+export * from './tools';
+export * from './prompts';
+export * from './types';

package/dist/aiChat/server/models.d.ts

@@ -0,0 +1,15 @@
+import { LanguageModelV3 } from '@ai-sdk/provider';
+import { CreateModelOptions } from './types';
+/**
+ * Create a model instance based on the provider and model name.
+ *
+ * Supports all native AI SDK providers:
+ * @see https://ai-sdk.dev/docs/foundations/providers-and-models
+ *
+ * @example
+ * // OpenAI
+ * const model = await createModel('openai/gpt-4', { apiKey: 'sk-...' });
+ * // Anthropic
+ * const model = await createModel('anthropic/claude-3-opus', { apiKey: 'sk-ant-...' });
+ */
+export declare function createModel(modelString: string, options?: CreateModelOptions): Promise<LanguageModelV3>;

package/dist/aiChat/server/prompts.d.ts

@@ -0,0 +1,23 @@
+import { ProjectContext } from '../types';
+/**
+ * Get the base system prompt for the Product Manager AI assistant
+ */
+export declare function getSystemPromptChat(projectContext: ProjectContext): string;
+export declare function getSystemPromptGenerateProject(projectContext: ProjectContext): string;
+export declare function getSystemPromptGenerateProjectWeb(projectContext: ProjectContext): string;
+export declare function getSystemPromptGenerateProjectEmail(projectContext: ProjectContext): string;
+export declare function getSystemPromptAddPage(projectContext: ProjectContext): string;
+/**
+ * Get system prompt for adding components
+ */
+export declare function getSystemPromptAddComponent(projectContext: ProjectContext): string;
+export declare function getSystemPromptAddComponentWeb(projectContext: ProjectContext): string;
+export declare function getSystemPromptAddComponentEmail(projectContext: ProjectContext): string;
+export declare function getSystemPromptEditComponent(projectContext: ProjectContext): string;
+/**
+ * Get system prompt for editing components
+ */
+export declare function getSystemPromptEditComponentWeb(projectContext: ProjectContext): string;
+export declare function getSystemPromptEditComponentEmail(projectContext: ProjectContext): string;
+export declare function getPromptHintCurrentSiteCode({ selectedPage }: ProjectContext): string;
+export declare function getTailwindInstructions(): string;

package/dist/aiChat/server/stream-utils.d.ts

@@ -0,0 +1,16 @@
+import { ModelMessage } from 'ai';
+import { ToolCallInfo } from './types';
+export declare function injectImagesIntoMessages(messages: ModelMessage[], imageUrls: string[]): ModelMessage[];
+export declare function handleTextChunk(chunk: {
+    type: 'text-delta';
+    text?: string;
+}, onText?: (text: string) => void | Promise<void>): Promise<void>;
+export declare function handleToolCallChunk(chunk: {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+}, toolCalls: ToolCallInfo[], onToolCall?: (toolCall: ToolCallInfo) => void | Promise<void>): Promise<void>;
+export declare function processStreamChunk(chunk: {
+    type: string;
+}, toolCalls: ToolCallInfo[], onText?: (text: string) => void | Promise<void>, onToolCall?: (toolCall: ToolCallInfo) => void | Promise<void>): Promise<void>;

package/dist/aiChat/server/stream.d.ts

@@ -0,0 +1,21 @@
+import { CreateStreamResponseOptions, CreateStreamTextResponseOptions } from './types';
+/**
+ * Create a streaming response for AI chat.
+ *
+ * This is a wrapper around ai-sdk's streamText.
+ * Uses AI SDK v6 UIMessage stream architecture.
+ * When `tools` is a function `(opts) => Record`, uses createUIMessageStream so tools can use the writer.
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+ * @see https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data
+ */
+export declare function createStreamResponse(options: CreateStreamResponseOptions): Promise<Response>;
+/**
+ * Create a text streaming response for AI chat.
+ *
+ * This is a wrapper around ai-sdk's streamText that uses toTextStreamResponse
+ * instead of toUIMessageStreamResponse. Useful for simpler sub-agent calls
+ * that don't need the full UI message stream architecture.
+ *
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-core/stream-text
+ */
+export declare function createStreamTextResponse(options: CreateStreamTextResponseOptions): Promise<Response>;

package/dist/aiChat/server/tools.d.ts

@@ -0,0 +1,90 @@
+import { LanguageModelV3 } from '@ai-sdk/provider';
+import { createUIMessageStream, Tool, tool, UIMessageStreamWriter } from 'ai';
+import { z } from 'zod';
+import { ProjectContext } from '../types';
+import { AgentCodeOptions } from './types';
+interface BuildDefaultToolsOptions {
+    writer: Parameters<Parameters<typeof createUIMessageStream>[0]['execute']>[0]['writer'];
+    agentCode?: AgentCodeOptions;
+    abortSignal?: AbortSignal;
+}
+interface CreateToolOptions extends Omit<Parameters<typeof tool>[0], 'inputSchema'> {
+    inputSchema: z.ZodTypeAny;
+}
+export declare function createTool<T extends CreateToolOptions>(options: T): Tool<unknown, unknown>;
+export declare const toolAddNewComponent: Tool<unknown, unknown>;
+export interface CreateToolAgentCodeProps {
+    writer: UIMessageStreamWriter;
+    projectContext: ProjectContext;
+    model: LanguageModelV3;
+    abortSignal?: AbortSignal;
+}
+/**
+ * Returns addNewComponent tool that runs on the server and uses the stream writer
+ * to send data-tool-status (in-progress, streaming, done) for real-time UI updates.
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+ */
+export declare function createToolAddComponent(props: CreateToolAgentCodeProps): Tool<unknown, unknown>;
+export declare const toolEditComponent: Tool<unknown, unknown>;
+/**
+ * Returns editComponent tool that runs on the server and uses the stream writer
+ * to send data-tool-status (in-progress, streaming, done) for real-time UI updates.
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+ */
+export declare function createToolEditComponent(props: CreateToolAgentCodeProps): Tool<unknown, unknown>;
+export declare const toolRemoveComponent: Tool<unknown, unknown>;
+export declare const toolMoveComponent: Tool<unknown, unknown>;
+export declare const toolGetPageContent: Tool<unknown, unknown>;
+export declare const toolListPages: Tool<unknown, unknown>;
+export declare const toolFetchWebsite: Tool<unknown, unknown>;
+export declare const toolAddNewPage: Tool<unknown, unknown>;
+/**
+ * Returns addNewPage tool that runs on the server and uses the stream writer
+ * to send data-tool-status (in-progress, streaming, done) for real-time UI updates.
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+ */
+export declare function createToolAddPage(props: CreateToolAgentCodeProps): Tool<unknown, unknown>;
+export declare const toolAddNewProjectPage: Tool<unknown, unknown>;
+/**
+ * Returns addNewProjectPage tool that runs on the server and uses the stream writer
+ * to send data-tool-status (in-progress, streaming, done) for real-time UI updates.
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+ */
+export declare function createToolAddProjectPage(props: CreateToolAgentCodeProps): Tool<unknown, unknown>;
+export declare const toolShowPanel: Tool<unknown, unknown>;
+export declare const toolsNewProject: {
+    addNewProjectPage: Tool<unknown, unknown>;
+    fetchWebsite: Tool<unknown, unknown>;
+};
+export declare const toolsWeb: {
+    addNewPage: Tool<unknown, unknown>;
+    addNewComponent: Tool<unknown, unknown>;
+    removeComponent: Tool<unknown, unknown>;
+    moveComponent: Tool<unknown, unknown>;
+    editComponent: Tool<unknown, unknown>;
+    getPageContent: Tool<unknown, unknown>;
+    listPages: Tool<unknown, unknown>;
+    showPanel: Tool<unknown, unknown>;
+    fetchWebsite: Tool<unknown, unknown>;
+};
+export declare const toolsEmail: {
+    addNewComponent: Tool<unknown, unknown>;
+    editComponent: Tool<unknown, unknown>;
+    removeComponent: Tool<unknown, unknown>;
+    moveComponent: Tool<unknown, unknown>;
+    getPageContent: Tool<unknown, unknown>;
+};
+export declare function getDefaultProjectTools({ isEmail, isNewProject }?: Partial<ProjectContext> & {
+    isNewProject?: boolean;
+}): {
+    addNewProjectPage: Tool<unknown, unknown>;
+    fetchWebsite: Tool<unknown, unknown>;
+} | {
+    addNewComponent: Tool<unknown, unknown>;
+    editComponent: Tool<unknown, unknown>;
+    removeComponent: Tool<unknown, unknown>;
+    moveComponent: Tool<unknown, unknown>;
+    getPageContent: Tool<unknown, unknown>;
+};
+export declare function buildDefaultTools(options: BuildDefaultToolsOptions): Record<string, Tool>;
+export {};

package/dist/aiChat/server/types.d.ts

@@ -0,0 +1,165 @@
+import { LanguageModelV3 } from '@ai-sdk/provider';
+import { ModelMessage, Tool, UIMessage, UIMessageStreamOptions, UIMessageStreamWriter, streamText } from 'ai';
+import { JSONSchema7 } from 'json-schema';
+import { ProjectContext } from '../types';
+export type StreamTextOptions = Parameters<typeof streamText>[0];
+/**
+ * Options for configuring an agent that generates code (e.g., add/edit components).
+ */
+export interface AgentCodeOptions {
+    /**
+     * The AI model to use for code generation.
+     */
+    model: LanguageModelV3;
+    /**
+     * Project context containing information about the current project
+     */
+    projectContext: ProjectContext;
+}
+/**
+ * Options passed to the tools callback function
+ */
+export interface ToolsCallbackOptions {
+    /**
+     * Stream writer for tools that need to write data-tool-status or merge sub-streams
+     */
+    writer: UIMessageStreamWriter;
+    /**
+     * Default tools based on project context.
+     */
+    defaultTools: Record<string, Tool>;
+    /**
+     * Abort signal passed from the request, useful for cancelling long-running tool operations
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Options for creating a streaming response
+ */
+export interface CreateStreamResponseOptions extends Pick<StreamTextOptions, 'toolChoice' | 'providerOptions'> {
+    /**
+     * The AI model to use
+     */
+    model: LanguageModelV3;
+    /**
+     * Messages from the conversation
+     */
+    messages: UIMessage[];
+    /**
+     * System prompt for the chat
+     */
+    systemPrompt?: string;
+    /**
+     * Abort signal for cancelling the stream and tool operations
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Configuration for the code generation agent.
+     * When provided, default tools will be automatically constructed and passed to the tools callback.
+     */
+    agentCode?: AgentCodeOptions;
+    /**
+     * Tools available to the AI. Can be a function that receives options including
+     * the stream writer, default tools (when agentCode is provided), and abort signal.
+     * @see https://ai-sdk.dev/docs/reference/ai-sdk-ui/create-ui-message-stream
+     * @see https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data
+     */
+    tools?: Record<string, Tool> | ((options: ToolsCallbackOptions) => Record<string, Tool>);
+    /**
+     * Image URLs to add to the last user message
+     * These will be formatted as image content parts for vision models
+     */
+    imageUrls?: string[];
+    /**
+     * Additional stream text options
+     */
+    streamOptions?: Partial<Omit<StreamTextOptions, 'toolChoice' | 'providerOptions' | 'model' | 'messages' | 'prompt' | 'tools' | 'onText' | 'onToolCall' | 'abortSignal'>>;
+    /**
+     * Additional response options
+     */
+    responseOptions?: Partial<UIMessageStreamOptions<UIMessage>>;
+}
+/**
+ * Options for creating a text streaming response (using toTextStreamResponse)
+ * Similar to CreateStreamResponseOptions but excludes responseOptions and uses prompt instead of messages
+ */
+export interface CreateStreamTextResponseOptions extends Pick<StreamTextOptions, 'toolChoice' | 'providerOptions' | 'abortSignal' | 'onFinish' | 'onAbort' | 'onError'> {
+    /**
+     * The AI model to use
+     */
+    model: LanguageModelV3;
+    /**
+     * System prompt for the chat
+     */
+    system?: string;
+    /**
+     * User prompt (single string instead of messages array)
+     */
+    prompt: string;
+    /**
+     * Tools available to the AI
+     */
+    tools?: Record<string, Tool>;
+    /**
+     * Additional stream text options
+     */
+    streamOptions?: Partial<Omit<StreamTextOptions, 'toolChoice' | 'providerOptions' | 'model' | 'system' | 'prompt' | 'messages' | 'tools' | 'abortSignal' | 'onFinish' | 'onAbort' | 'onError'>>;
+}
+export interface StreamFinishResult {
+    text: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    model: string;
+    /**
+     * Uses AI SDK's official type to ensure compatibility
+     * Extracted from streamText's onFinish callback parameter type
+     */
+    finishReason: Parameters<NonNullable<Parameters<typeof streamText>[0]['onFinish']>>[0]['finishReason'];
+    toolCalls?: ToolCallInfo[];
+}
+export interface ToolCallInfo {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export interface CreateModelOptions {
+    apiKey?: string;
+    baseURL?: string;
+    [key: string]: unknown;
+}
+export interface ToolDefinition<TArgs = Record<string, unknown>, TResult = unknown> {
+    description: string;
+    /**
+     * JSON schema for the tool's input parameters (ai-sdk v6)
+     */
+    inputSchema: JSONSchema7;
+    execute?: (args: TArgs, context: ToolExecuteContext) => Promise<TResult>;
+}
+export interface ToolExecuteContext {
+    toolCallId: string;
+    messages: ModelMessage[];
+    abortSignal?: AbortSignal;
+}
+/**
+ * Options for creating the chat system prompt
+ */
+export interface CreateSystemPromptChatOptions {
+    /**
+     * Project context from the client
+     */
+    projectContext?: ProjectContext;
+}
+export interface PromptConfig {
+    currentSiteCode?: string;
+    currentSelectedCode?: string;
+    userPrompt?: string;
+    projectType?: 'web' | 'email';
+    globalStyles?: string;
+    devices?: ProjectContext['devices'];
+    availablePages?: ProjectContext['availablePages'];
+    installedPlugins?: ProjectContext['installedPlugins'];
+    imageUrls?: string[];
+}