@superblocksteam/vite-plugin-file-sync 2.0.34 → 2.0.35-next.1

package/dist/ai-service/agent/tools.d.ts

@@ -0,0 +1,262 @@
+import type { Clark } from "../state-machine/clark-fsm.js";
+import type { ClarkStateHandlerParams } from "../state-machine/clark-fsm.js";
+import type { PromptContext } from "@superblocksteam/library-shared/types";
+export declare const buildTools: (clark: Clark, services: ClarkStateHandlerParams, promptContext: PromptContext | undefined, logRef: {
+    content: string;
+}, disabledTools?: string[]) => {
+    study_currentAppState: import("ai").Tool<{}, {
+        appScopeId: string | undefined;
+        appComponentSemantics: import("../context/app-context.js").ComponentSemanticInfo[];
+        currentPageName: string | undefined;
+        entitiesSelectedByUser: import("@superblocksteam/library-shared/types").PromptContextEntity[] | undefined;
+        isEssentiallyBlank: boolean;
+        pageNames: string[];
+        pagesInfo: {
+            pageName: string;
+            pageScopeId: string | undefined;
+            isEssentiallyBlank: boolean;
+            numberOfComponents: number;
+            componentSemantics: import("../context/app-context.js").ComponentSemanticInfo[];
+            entityNames: string[] | undefined;
+        }[];
+    }>;
+    build_createPage: import("ai").Tool<{
+        name: string;
+        route: string;
+    }, {
+        pageScopeId: string;
+        pageName: string;
+        route: string;
+        message: string;
+    }>;
+    build_listAvailableComponents: import("ai").Tool<{}, {
+        components: {
+            tagName: string | undefined;
+            docsMarkdown: string | null;
+            pathToSource: string;
+        }[];
+    }>;
+    build_addStateVar: import("ai").Tool<{
+        scopeId: string;
+        entityName: string;
+        defaultValue?: any;
+    }, {
+        scopeId: string;
+        entityName: string;
+        entityType: string;
+        attributes: {
+            defaultValue: any;
+            persistence: import("@superblocksteam/library-shared/types").StateVarPersistence;
+        };
+        message: string;
+    }>;
+    build_addTimer: import("ai").Tool<{
+        intervalMs: number;
+        entityName: string;
+        pageScopeId: string;
+        startOnPageLoad?: boolean | undefined;
+    }, {
+        scopeId: string;
+        entityName: string;
+        entityType: string;
+        attributes: {
+            intervalMs: number;
+            startOnPageLoad: boolean | undefined;
+        };
+        message: string;
+    }>;
+    build_addEvent: import("ai").Tool<{
+        entityName: string;
+        pageScopeId: string;
+        payload?: string | undefined;
+    }, {
+        scopeId: string;
+        entityName: string;
+        entityType: string;
+        attributes: {
+            payload: string | undefined;
+        };
+        message: string;
+    }>;
+    build_updateStateVar: import("ai").Tool<{
+        scopeId: string;
+        entityName: string;
+        changes: {
+            defaultValue?: string | undefined;
+        };
+    }, {
+        scopeId: string;
+        entityName: string;
+        entityType: string;
+        attributes: {
+            defaultValue?: string | undefined;
+        };
+        message: string;
+    }>;
+    build_registerComponentName: import("ai").Tool<{
+        pageName: string;
+        componentName: string;
+    }, {
+        pageName: string;
+        componentName: string;
+        message: string;
+    }>;
+    build_writeFile: import("ai").Tool<{
+        filePath: string;
+        content: string;
+    }, {
+        filePath: string;
+        contentLength: number;
+        message: string;
+    }>;
+    build_editFile: import("ai").Tool<{
+        filePath: string;
+        oldString: string;
+        newString: string;
+        replaceAll?: boolean | undefined;
+    }, {
+        filePath: string;
+        diff: string;
+        oldStringLength: number;
+        newStringLength: number;
+        replaceAll: boolean;
+        message: string;
+    } | {
+        filePath: string;
+        diff: string;
+        message: string;
+    }>;
+    build_multiEditFile: import("ai").Tool<{
+        filePath: string;
+        edits: {
+            oldString: string;
+            newString: string;
+            replaceAll?: boolean | undefined;
+        }[];
+    }, {
+        filePath: string;
+        diff: string;
+        editsApplied: number;
+        originalLength: number;
+        finalLength: number;
+        message: string;
+    }>;
+    build_readFiles: import("ai").Tool<{
+        filePaths: string[];
+    }, Record<string, string>>;
+    build_listFiles: import("ai").Tool<{}, {
+        files: string[];
+    }>;
+    build_renamePage: import("ai").Tool<{
+        oldName: string;
+        newName: string;
+    }, {
+        oldName: string;
+        newName: string;
+        message: string;
+    }>;
+    build_getValidIcons: import("ai").Tool<{
+        iconNames: string[];
+    }, {
+        summary: {
+            totalChecked: number;
+            valid: number;
+            invalid: number;
+            totalAvailableIcons: number;
+            validationMethod: string;
+        };
+        results: {
+            requested: string;
+            isValid: boolean;
+            suggestions: string[];
+            validationMethod: string;
+            importExample: string | null;
+            componentExample: string | null;
+        }[];
+        message: string;
+        commonPatterns: string[];
+        note: string;
+    }>;
+    build_installPackages: import("ai").Tool<{}, {
+        output: string;
+        message: string;
+    }>;
+    build_generateApiSource: import("ai").Tool<{
+        pageName: string;
+        apiName: string;
+        prompt: string;
+    }, {
+        message: string;
+        apiName: string;
+        pageName: string;
+    }>;
+    build_manageChecklist: import("ai").Tool<{
+        action: "add" | "get" | "update";
+        content?: string | undefined;
+        status?: "pending" | "in_progress" | "completed" | "cancelled" | undefined;
+        itemId?: string | undefined;
+    }, {
+        success: boolean;
+        action: string;
+        item: import("./tools/build-manage-checklist.js").ChecklistItem;
+        message: string;
+        totalItems: number;
+        completedItems?: undefined;
+        items?: undefined;
+        lastUpdated?: undefined;
+    } | {
+        success: boolean;
+        action: string;
+        item: import("./tools/build-manage-checklist.js").ChecklistItem;
+        message: string;
+        completedItems: number;
+        totalItems: number;
+        items?: undefined;
+        lastUpdated?: undefined;
+    } | {
+        success: boolean;
+        action: string;
+        items: import("./tools/build-manage-checklist.js").ChecklistItem[];
+        completedItems: number;
+        totalItems: number;
+        lastUpdated: string;
+        message: string;
+        item?: undefined;
+    }>;
+    build_debug: import("ai").Tool<{}, import("./tools/debug-cache.js").DebugResult>;
+    build_finalize: import("ai").Tool<{
+        summary: string;
+        relevantFilePaths?: string[] | undefined;
+        goals?: string[] | undefined;
+        decisions?: string[] | undefined;
+        adviceToAgents?: string | undefined;
+    }, {
+        status: string;
+        message: string;
+        instruction: string;
+        pendingTasks: import("./tools/build-manage-checklist.js").ChecklistItem[];
+        summary?: undefined;
+        relevantFilePaths?: undefined;
+        goals?: undefined;
+        decisions?: undefined;
+    } | {
+        status: string;
+        message: string;
+        instruction: string;
+        pendingTasks?: undefined;
+        summary?: undefined;
+        relevantFilePaths?: undefined;
+        goals?: undefined;
+        decisions?: undefined;
+    } | {
+        status: string;
+        summary: string;
+        relevantFilePaths: string[] | undefined;
+        goals: string[] | undefined;
+        decisions: string[] | undefined;
+        message?: undefined;
+        instruction?: undefined;
+        pendingTasks?: undefined;
+    }>;
+};
+//# sourceMappingURL=tools.d.ts.map

package/dist/ai-service/agent/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/ai-service/agent/tools.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AA6C3E,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,UAAU,uBAAuB,EACjC,eAAe,aAAa,GAAG,SAAS,EACxC,QAAQ;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAC3B,gBAAgB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6IzB,CAAC"}

package/dist/ai-service/agent/tools.js

@@ -0,0 +1,102 @@
+import { OperationQueue } from "../../util/operation-queue.js";
+import { profileTool, } from "../profiler/tool-profiler.js";
+import { generateApiSourceSubagent } from "./apis.js";
+import { createStudyCurrentAppStateTool, createBuildCreatePageTool, createBuildInstallPackagesTool, createBuildListAvailableComponentsTool, createBuildAddStateVarTool, createBuildUpdateStateVarTool, createBuildAddTimerTool, createBuildAddEventTool, createBuildRegisterComponentNameTool, createBuildWriteFileTool, createBuildEditFileTool, createBuildMultiEditFileTool, createBuildReadFilesTool, multiFileToolConfig, createBuildListFilesTool, createBuildRenamePageTool, createBuildValidateIconsTool, createBuildDebugTool, createBuildFinalizeTool, createBuildManageChecklistTool, } from "./tools/index.js";
+const fileToolConfig = {
+    extractDisplayName: (parameters) => {
+        const params = parameters;
+        if (params.filePath && typeof params.filePath === "string") {
+            const fileName = params.filePath.split("/").pop() || params.filePath;
+            return `:${fileName}`;
+        }
+        return "";
+    },
+    extractMetadata: (parameters) => {
+        const params = parameters;
+        return {
+            filePath: params.filePath,
+            hasOldString: "oldString" in params,
+            hasNewString: "newString" in params,
+            hasContent: "content" in params,
+        };
+    },
+};
+const componentToolConfig = {
+    extractDisplayName: (parameters) => {
+        const params = parameters;
+        if (params.componentName && typeof params.componentName === "string") {
+            return `:${params.componentName}`;
+        }
+        if (params.name && typeof params.name === "string") {
+            return `:${params.name}`;
+        }
+        return "";
+    },
+    extractMetadata: (parameters) => {
+        const params = parameters;
+        return {
+            componentName: params.componentName,
+            name: params.name,
+            varName: params.varName,
+            eventName: params.eventName,
+            timerName: params.timerName,
+        };
+    },
+};
+export const buildTools = (clark, services, promptContext, logRef, disabledTools) => {
+    const scopeUpdateQueue = new OperationQueue();
+    const build_generateApiSource = generateApiSourceSubagent(clark, services, scopeUpdateQueue, promptContext, logRef);
+    const study_currentAppState = createStudyCurrentAppStateTool(services, promptContext);
+    const build_createPage = createBuildCreatePageTool(clark, services);
+    const build_installPackages = createBuildInstallPackagesTool(clark, services);
+    const build_listAvailableComponents = createBuildListAvailableComponentsTool(services);
+    const build_addStateVar = createBuildAddStateVarTool(clark, services, scopeUpdateQueue);
+    const build_updateStateVar = createBuildUpdateStateVarTool(services);
+    const build_addTimer = createBuildAddTimerTool(clark, services, scopeUpdateQueue);
+    const build_addEvent = createBuildAddEventTool(clark, services, scopeUpdateQueue);
+    const build_registerComponentName = createBuildRegisterComponentNameTool(clark, services, scopeUpdateQueue);
+    const build_writeFile = createBuildWriteFileTool(clark, services);
+    const build_editFile = createBuildEditFileTool(clark, services);
+    const build_multiEditFile = createBuildMultiEditFileTool(clark, services);
+    const build_readFiles = createBuildReadFilesTool(clark, services);
+    const build_listFiles = createBuildListFilesTool(services);
+    const build_renamePage = createBuildRenamePageTool(services);
+    const build_getValidIcons = createBuildValidateIconsTool(services);
+    const build_debug = createBuildDebugTool(clark, services);
+    const build_finalize = createBuildFinalizeTool(clark, services);
+    const build_manageChecklist = createBuildManageChecklistTool(clark, services);
+    const allTools = {
+        study_currentAppState: profileTool("study_currentAppState", study_currentAppState),
+        build_createPage: profileTool("build_createPage", build_createPage),
+        build_listAvailableComponents: profileTool("build_listAvailableComponents", build_listAvailableComponents),
+        build_addStateVar: profileTool("build_addStateVar", build_addStateVar, componentToolConfig),
+        build_addTimer: profileTool("build_addTimer", build_addTimer, componentToolConfig),
+        build_addEvent: profileTool("build_addEvent", build_addEvent, componentToolConfig),
+        build_updateStateVar: profileTool("build_updateStateVar", build_updateStateVar),
+        build_registerComponentName: profileTool("build_registerComponentName", build_registerComponentName, componentToolConfig),
+        build_writeFile: profileTool("build_writeFile", build_writeFile, fileToolConfig),
+        build_editFile: profileTool("build_editFile", build_editFile, fileToolConfig),
+        build_multiEditFile: profileTool("build_multiEditFile", build_multiEditFile, fileToolConfig),
+        build_readFiles: profileTool("build_readFiles", build_readFiles, multiFileToolConfig),
+        build_listFiles: profileTool("build_listFiles", build_listFiles),
+        build_renamePage: profileTool("build_renamePage", build_renamePage),
+        build_getValidIcons: profileTool("build_getValidIcons", build_getValidIcons),
+        build_installPackages: profileTool("build_installPackages", build_installPackages),
+        build_generateApiSource: profileTool("build_generateApiSource", build_generateApiSource),
+        build_manageChecklist: profileTool("build_manageChecklist", build_manageChecklist),
+        build_debug: profileTool("build_debug", build_debug),
+        build_finalize: profileTool("build_finalize", build_finalize),
+    };
+    // Filter out disabled tools if any are specified
+    if (disabledTools && disabledTools.length > 0) {
+        const enabledTools = {};
+        for (const [key, value] of Object.entries(allTools)) {
+            if (!disabledTools.includes(key)) {
+                enabledTools[key] = value;
+            }
+        }
+        return enabledTools;
+    }
+    return allTools;
+};
+//# sourceMappingURL=tools.js.map

package/dist/ai-service/agent/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../src/ai-service/agent/tools.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/agent/utils.d.ts

@@ -0,0 +1,34 @@
+import { type PromptContext } from "@superblocksteam/library-shared/types";
+import type { Clark, ClarkStateHandlerParams } from "../state-machine/clark-fsm.js";
+import type { TextStreamPart, ToolSet } from "ai";
+export declare const getAppState: (services: ClarkStateHandlerParams, promptContext?: PromptContext) => Promise<{
+    appScopeId: string | undefined;
+    appComponentSemantics: import("../context/app-context.js").ComponentSemanticInfo[];
+    currentPageName: string | undefined;
+    entitiesSelectedByUser: import("@superblocksteam/library-shared/types").PromptContextEntity[] | undefined;
+    isEssentiallyBlank: boolean;
+    pageNames: string[];
+    pagesInfo: {
+        pageName: string;
+        pageScopeId: string | undefined;
+        isEssentiallyBlank: boolean;
+        numberOfComponents: number;
+        componentSemantics: import("../context/app-context.js").ComponentSemanticInfo[];
+        entityNames: string[] | undefined;
+    }[];
+}>;
+export declare const getFilesChangedInDraftState: (services: ClarkStateHandlerParams) => Promise<string[]>;
+export declare const ensureScopeFileDraft: ({ identifier, type, scopeFilePath, }: {
+    identifier?: string;
+    type?: "name" | "id";
+    scopeFilePath?: string;
+}, services: ClarkStateHandlerParams) => Promise<void>;
+export declare function getPageEntitiesFiltered(pageName: string, entityTypes: ("StateVar" | "Component")[], services: ClarkStateHandlerParams): {
+    name: string;
+    type: "StateVar" | "Component";
+}[];
+export declare const normalizeToBlockStatement: (value: any) => string;
+export declare const processStreamChunk: (chunk: TextStreamPart<ToolSet>, clark: Clark, logRef: {
+    content: string;
+}) => Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ai-service/agent/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ai-service/agent/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,uCAAuC,CAAC;AAO/C,OAAO,KAAK,EACV,KAAK,EACL,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAElD,eAAO,MAAM,WAAW,GACtB,UAAU,uBAAuB,EACjC,gBAAgB,aAAa;;;;;;;;;;;;;;;EAkC9B,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,UAAU,uBAAuB,sBAIlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,sCAIG;IACD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,EACD,UAAU,uBAAuB,kBAsBlC,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,EAAE,EACzC,QAAQ,EAAE,uBAAuB,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,GAAG,WAAW,CAAA;CAAE,EAAE,CA8CpD;AAED,eAAO,MAAM,yBAAyB,GAAI,OAAO,GAAG,KAAG,MAmFtD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,cAAc,CAAC,OAAO,CAAC,EAC9B,OAAO,KAAK,EACZ,QAAQ;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,KAC1B,OAAO,CAAC,IAAI,CAqEd,CAAC"}

package/dist/ai-service/agent/utils.js

@@ -0,0 +1,242 @@
+import path from "node:path";
+import { parse } from "@babel/parser";
+import { SbEntityType, } from "@superblocksteam/library-shared/types";
+import { fromNodeToEntity } from "../../parsing/scope.js";
+import { getFunctionExpressionBody, parseExpression, } from "../../parsing/util.js";
+import { getToolCallMessage } from "./tool-message-utils.js";
+export const getAppState = async (services, promptContext) => {
+    const pageNames = services.appContextStore.getPageNames();
+    const componentCountByPage = services.appContextStore.getComponentCountByPage();
+    // Get page-specific information for all pages
+    const pagesInfo = pageNames.map((pageName) => {
+        const scope = services.fileSystemInterface.getScopeDefinitionForPage(pageName);
+        const pageComponents = services.appContextStore.getComponentsForPage(pageName);
+        const isPageBlank = services.appContextStore.isPageEssentiallyBlank(pageName);
+        return {
+            pageName,
+            pageScopeId: scope?.id,
+            isEssentiallyBlank: isPageBlank,
+            numberOfComponents: componentCountByPage[pageName] || 0,
+            componentSemantics: pageComponents,
+            entityNames: scope?.entityNames,
+        };
+    });
+    return {
+        appScopeId: services.appContextStore.appScopeId,
+        appComponentSemantics: services.appContextStore.getComponentsForApp(),
+        currentPageName: promptContext?.currentPageName,
+        entitiesSelectedByUser: promptContext?.entities,
+        isEssentiallyBlank: services.appContextStore.isEssentiallyBlank(),
+        pageNames,
+        pagesInfo,
+    };
+};
+export const getFilesChangedInDraftState = async (services) => {
+    const { edits, additions } = await services.draftInterface.getDraftChanges();
+    return [...edits, ...additions];
+};
+export const ensureScopeFileDraft = async ({ identifier, type, scopeFilePath, }, services) => {
+    if (!scopeFilePath && identifier && type) {
+        const { filePath } = services.fileSystemInterface
+            .getSourceTracker()
+            .getScopeDefinitionAndFilePathByNameOrId({
+            identifier,
+            type,
+        });
+        scopeFilePath = filePath;
+    }
+    if (!scopeFilePath) {
+        throw new Error(`Scope file not found for scope ${identifier ?? scopeFilePath}`);
+    }
+    await services.draftInterface.createDraftMarkerOnly(path.relative(services.appRootDirPath, scopeFilePath));
+};
+export function getPageEntitiesFiltered(pageName, entityTypes, services) {
+    const scopeDefinition = services.fileSystemInterface
+        .getSourceTracker()
+        .getScopeDefinitionForPage(pageName);
+    if (!scopeDefinition) {
+        return [];
+    }
+    const results = [];
+    // Get StateVar entities from scopeEntities
+    if (entityTypes.includes("StateVar") && scopeDefinition.scopeEntities) {
+        scopeDefinition.scopeEntities.get("properties").forEach((property) => {
+            if (property.isObjectProperty()) {
+                const entity = fromNodeToEntity(property);
+                if (entity && entity.type === SbEntityType.VARIABLE) {
+                    results.push({
+                        name: entity.name,
+                        type: "StateVar",
+                    });
+                }
+            }
+        });
+    }
+    // Get Component entities from scopeComponents
+    if (entityTypes.includes("Component") && scopeDefinition.scopeComponents) {
+        scopeDefinition.scopeComponents.get("members").forEach((member) => {
+            if (member.isTSPropertySignature()) {
+                const key = member.get("key");
+                if (key.isIdentifier()) {
+                    const componentName = key.node.name;
+                    results.push({
+                        name: componentName,
+                        type: "Component",
+                    });
+                }
+            }
+        });
+    }
+    return results;
+}
+export const normalizeToBlockStatement = (value) => {
+    if (!value) {
+        return "{ return undefined; }";
+    }
+    // If it's not a string, convert to JSON and wrap
+    if (typeof value !== "string") {
+        return `{ return ${JSON.stringify(value)}; }`;
+    }
+    const trimmedValue = value.trim();
+    // If it's already a block statement, return as-is
+    if (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) {
+        return trimmedValue;
+    }
+    try {
+        // Try to parse as an arrow function first
+        const arrowFunctionPattern = /^\s*\([^)]*\)\s*=>\s*/;
+        if (arrowFunctionPattern.test(trimmedValue)) {
+            // Parse the arrow function and extract its body
+            const ast = parse(trimmedValue, {
+                sourceType: "module",
+                plugins: ["typescript", "jsx"],
+            });
+            const expression = ast.program.body[0];
+            if (expression?.type === "ExpressionStatement" &&
+                expression.expression.type === "ArrowFunctionExpression") {
+                const functionBody = getFunctionExpressionBody(expression.expression);
+                const trimmedBody = functionBody.trim();
+                // Check if this is a block statement vs an object expression
+                // Block statements typically contain: return, var/let/const, if/for/while, semicolons
+                const blockStatementPatterns = [
+                    /\breturn\b/,
+                    /\b(var|let|const)\b/,
+                    /\b(if|for|while|switch|try)\b/,
+                    /;/,
+                ];
+                const hasBlockStatementPatterns = blockStatementPatterns.some((pattern) => pattern.test(trimmedBody));
+                // If it contains block statement patterns, it's likely a block body that was extracted
+                // from an arrow function, so we need to wrap it in braces
+                if (hasBlockStatementPatterns) {
+                    // Check if it already has braces (complete block)
+                    if (trimmedBody.startsWith("{") && trimmedBody.endsWith("}")) {
+                        return trimmedBody;
+                    }
+                    else {
+                        // Block content without braces, wrap it
+                        return `{\n${trimmedBody}\n}`;
+                    }
+                }
+                // For object expressions or simple expressions, check if it needs braces
+                if (trimmedBody.startsWith("{") && trimmedBody.endsWith("}")) {
+                    // It's an object expression, wrap in return
+                    return `{ return ${trimmedBody}; }`;
+                }
+                // Otherwise, wrap in return statement
+                return `{ return ${functionBody}; }`;
+            }
+        }
+        // Try to parse as a regular expression and wrap in return
+        const parsedExpression = parseExpression(trimmedValue);
+        if (parsedExpression) {
+            return `{ return ${trimmedValue}; }`;
+        }
+    }
+    catch (_) {
+        // If parsing fails, treat as string literal
+        return `{ return ${JSON.stringify(trimmedValue)}; }`;
+    }
+    // Fallback: wrap in return statement
+    return `{ return ${trimmedValue}; }`;
+};
+export const processStreamChunk = async (chunk, clark, logRef) => {
+    switch (chunk.type) {
+        case "text-delta":
+            void clark.context.peer?.call.aiPushMessage({
+                type: "text",
+                text: chunk.text,
+            });
+            break;
+        case "tool-call": {
+            const toolMessage = await getToolCallMessage(chunk.toolName, chunk.input, clark);
+            void clark.context.peer?.call.aiPushMessage({
+                type: "tool",
+                name: chunk.toolName,
+                label: toolMessage.label,
+                text: toolMessage.content ?? "",
+                displayType: toolMessage.displayType,
+            });
+            break;
+        }
+        case "reasoning-delta": {
+            void clark.context.peer?.call.aiPushMessage({
+                type: "reasoning",
+                text: chunk.text,
+            });
+            break;
+        }
+        case "error": {
+            const errorMessage = formatStreamError(chunk.error);
+            logRef.content += `[ERROR] ${errorMessage}\n`;
+            void clark.context.peer?.call.aiPushMessage({
+                type: "text",
+                text: `❌ ${errorMessage}`,
+            });
+            break;
+        }
+        case "finish": {
+            if (chunk.finishReason === "content-filter") {
+                const errorMessage = "The response was filtered due to content policy violations.";
+                logRef.content += `[CONTENT_FILTER] ${errorMessage}\n`;
+                void clark.context.peer?.call.aiPushMessage({
+                    type: "text",
+                    text: `❌ ${errorMessage}`,
+                });
+            }
+            else if (chunk.finishReason === "length") {
+                const warningMessage = "Response was truncated due to length limits.";
+                logRef.content += `[LENGTH_WARNING] ${warningMessage}\n`;
+                void clark.context.peer?.call.aiPushMessage({
+                    type: "text",
+                    text: `⚠️ ${warningMessage}`,
+                });
+            }
+            break;
+        }
+        case "abort": {
+            const abortMessage = "The request was aborted.";
+            logRef.content += `[ABORT] ${abortMessage}\n`;
+            void clark.context.peer?.call.aiPushMessage({
+                type: "text",
+                text: `❌ ${abortMessage}`,
+            });
+            break;
+        }
+    }
+};
+const formatStreamError = (error) => {
+    if (typeof error === "object" &&
+        error !== null &&
+        "type" in error &&
+        typeof error.type === "string") {
+        return `The LLM provider returned an error: ${error.type}`;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "An unknown error occurred during streaming.";
+};
+//# sourceMappingURL=utils.js.map