@superatomai/sdk-node 0.0.8 → 0.0.10

package/dist/index.js

@@ -8,9 +8,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,404 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/dotenv/package.json
-var require_package = __commonJS({
-  "node_modules/dotenv/package.json"(exports2, module2) {
-    module2.exports = {
-      name: "dotenv",
-      version: "17.2.3",
-      description: "Loads environment variables from .env file",
-      main: "lib/main.js",
-      types: "lib/main.d.ts",
-      exports: {
-        ".": {
-          types: "./lib/main.d.ts",
-          require: "./lib/main.js",
-          default: "./lib/main.js"
-        },
-        "./config": "./config.js",
-        "./config.js": "./config.js",
-        "./lib/env-options": "./lib/env-options.js",
-        "./lib/env-options.js": "./lib/env-options.js",
-        "./lib/cli-options": "./lib/cli-options.js",
-        "./lib/cli-options.js": "./lib/cli-options.js",
-        "./package.json": "./package.json"
-      },
-      scripts: {
-        "dts-check": "tsc --project tests/types/tsconfig.json",
-        lint: "standard",
-        pretest: "npm run lint && npm run dts-check",
-        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
-        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
-        prerelease: "npm test",
-        release: "standard-version"
-      },
-      repository: {
-        type: "git",
-        url: "git://github.com/motdotla/dotenv.git"
-      },
-      homepage: "https://github.com/motdotla/dotenv#readme",
-      funding: "https://dotenvx.com",
-      keywords: [
-        "dotenv",
-        "env",
-        ".env",
-        "environment",
-        "variables",
-        "config",
-        "settings"
-      ],
-      readmeFilename: "README.md",
-      license: "BSD-2-Clause",
-      devDependencies: {
-        "@types/node": "^18.11.3",
-        decache: "^4.6.2",
-        sinon: "^14.0.1",
-        standard: "^17.0.0",
-        "standard-version": "^9.5.0",
-        tap: "^19.2.0",
-        typescript: "^4.8.4"
-      },
-      engines: {
-        node: ">=12"
-      },
-      browser: {
-        fs: false
-      }
-    };
-  }
-});
-
-// node_modules/dotenv/lib/main.js
-var require_main = __commonJS({
-  "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    "use strict";
-    var fs8 = require("fs");
-    var path7 = require("path");
-    var os4 = require("os");
-    var crypto2 = require("crypto");
-    var packageJson = require_package();
-    var version = packageJson.version;
-    var TIPS = [
-      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
-      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
-      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
-      "\u{1F4E1} add observability to secrets: https://dotenvx.com/ops",
-      "\u{1F465} sync secrets across teammates & machines: https://dotenvx.com/ops",
-      "\u{1F5C2}\uFE0F backup and recover secrets: https://dotenvx.com/ops",
-      "\u2705 audit secrets and track compliance: https://dotenvx.com/ops",
-      "\u{1F504} add secrets lifecycle management: https://dotenvx.com/ops",
-      "\u{1F511} add access controls to secrets: https://dotenvx.com/ops",
-      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
-      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
-      "\u2699\uFE0F  enable debug logging with { debug: true }",
-      "\u2699\uFE0F  override existing env vars with { override: true }",
-      "\u2699\uFE0F  suppress all logs with { quiet: true }",
-      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
-      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
-    ];
-    function _getRandomTip() {
-      return TIPS[Math.floor(Math.random() * TIPS.length)];
-    }
-    function parseBoolean(value) {
-      if (typeof value === "string") {
-        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
-      }
-      return Boolean(value);
-    }
-    function supportsAnsi() {
-      return process.stdout.isTTY;
-    }
-    function dim(text) {
-      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
-    }
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-    function parse(src) {
-      const obj = {};
-      let lines = src.toString();
-      lines = lines.replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) != null) {
-        const key = match[1];
-        let value = match[2] || "";
-        value = value.trim();
-        const maybeQuote = value[0];
-        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-        if (maybeQuote === '"') {
-          value = value.replace(/\\n/g, "\n");
-          value = value.replace(/\\r/g, "\r");
-        }
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _parseVault(options) {
-      options = options || {};
-      const vaultPath = _vaultPath(options);
-      options.path = vaultPath;
-      const result = DotenvModule.configDotenv(options);
-      if (!result.parsed) {
-        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err.code = "MISSING_DATA";
-        throw err;
-      }
-      const keys = _dotenvKey(options).split(",");
-      const length = keys.length;
-      let decrypted;
-      for (let i = 0; i < length; i++) {
-        try {
-          const key = keys[i].trim();
-          const attrs = _instructions(result, key);
-          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-          break;
-        } catch (error) {
-          if (i + 1 >= length) {
-            throw error;
-          }
-        }
-      }
-      return DotenvModule.parse(decrypted);
-    }
-    function _warn(message) {
-      console.error(`[dotenv@${version}][WARN] ${message}`);
-    }
-    function _debug(message) {
-      console.log(`[dotenv@${version}][DEBUG] ${message}`);
-    }
-    function _log(message) {
-      console.log(`[dotenv@${version}] ${message}`);
-    }
-    function _dotenvKey(options) {
-      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-        return options.DOTENV_KEY;
-      }
-      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-        return process.env.DOTENV_KEY;
-      }
-      return "";
-    }
-    function _instructions(result, dotenvKey) {
-      let uri;
-      try {
-        uri = new URL(dotenvKey);
-      } catch (error) {
-        if (error.code === "ERR_INVALID_URL") {
-          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        }
-        throw error;
-      }
-      const key = uri.password;
-      if (!key) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environment = uri.searchParams.get("environment");
-      if (!environment) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-      const ciphertext = result.parsed[environmentKey];
-      if (!ciphertext) {
-        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err;
-      }
-      return { ciphertext, key };
-    }
-    function _vaultPath(options) {
-      let possibleVaultPath = null;
-      if (options && options.path && options.path.length > 0) {
-        if (Array.isArray(options.path)) {
-          for (const filepath of options.path) {
-            if (fs8.existsSync(filepath)) {
-              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-            }
-          }
-        } else {
-          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
-        }
-      } else {
-        possibleVaultPath = path7.resolve(process.cwd(), ".env.vault");
-      }
-      if (fs8.existsSync(possibleVaultPath)) {
-        return possibleVaultPath;
-      }
-      return null;
-    }
-    function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path7.join(os4.homedir(), envPath.slice(1)) : envPath;
-    }
-    function _configVault(options) {
-      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (debug || !quiet) {
-        _log("Loading env from encrypted .env.vault");
-      }
-      const parsed = DotenvModule._parseVault(options);
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsed, options);
-      return { parsed };
-    }
-    function configDotenv(options) {
-      const dotenvPath = path7.resolve(process.cwd(), ".env");
-      let encoding = "utf8";
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (options && options.encoding) {
-        encoding = options.encoding;
-      } else {
-        if (debug) {
-          _debug("No encoding is specified. UTF-8 is used by default");
-        }
-      }
-      let optionPaths = [dotenvPath];
-      if (options && options.path) {
-        if (!Array.isArray(options.path)) {
-          optionPaths = [_resolveHome(options.path)];
-        } else {
-          optionPaths = [];
-          for (const filepath of options.path) {
-            optionPaths.push(_resolveHome(filepath));
-          }
-        }
-      }
-      let lastError;
-      const parsedAll = {};
-      for (const path8 of optionPaths) {
-        try {
-          const parsed = DotenvModule.parse(fs8.readFileSync(path8, { encoding }));
-          DotenvModule.populate(parsedAll, parsed, options);
-        } catch (e) {
-          if (debug) {
-            _debug(`Failed to load ${path8} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      const populated = DotenvModule.populate(processEnv, parsedAll, options);
-      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-      if (debug || !quiet) {
-        const keysCount = Object.keys(populated).length;
-        const shortPaths = [];
-        for (const filePath of optionPaths) {
-          try {
-            const relative = path7.relative(process.cwd(), filePath);
-            shortPaths.push(relative);
-          } catch (e) {
-            if (debug) {
-              _debug(`Failed to load ${filePath} ${e.message}`);
-            }
-            lastError = e;
-          }
-        }
-        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
-      }
-      if (lastError) {
-        return { parsed: parsedAll, error: lastError };
-      } else {
-        return { parsed: parsedAll };
-      }
-    }
-    function config(options) {
-      if (_dotenvKey(options).length === 0) {
-        return DotenvModule.configDotenv(options);
-      }
-      const vaultPath = _vaultPath(options);
-      if (!vaultPath) {
-        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
-        return DotenvModule.configDotenv(options);
-      }
-      return DotenvModule._configVault(options);
-    }
-    function decrypt(encrypted, keyStr) {
-      const key = Buffer.from(keyStr.slice(-64), "hex");
-      let ciphertext = Buffer.from(encrypted, "base64");
-      const nonce = ciphertext.subarray(0, 12);
-      const authTag = ciphertext.subarray(-16);
-      ciphertext = ciphertext.subarray(12, -16);
-      try {
-        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
-        aesgcm.setAuthTag(authTag);
-        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-      } catch (error) {
-        const isRange = error instanceof RangeError;
-        const invalidKeyLength = error.message === "Invalid key length";
-        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-        if (isRange || invalidKeyLength) {
-          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        } else if (decryptionFailed) {
-          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err.code = "DECRYPTION_FAILED";
-          throw err;
-        } else {
-          throw error;
-        }
-      }
-    }
-    function populate(processEnv, parsed, options = {}) {
-      const debug = Boolean(options && options.debug);
-      const override = Boolean(options && options.override);
-      const populated = {};
-      if (typeof parsed !== "object") {
-        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err.code = "OBJECT_REQUIRED";
-        throw err;
-      }
-      for (const key of Object.keys(parsed)) {
-        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-          if (override === true) {
-            processEnv[key] = parsed[key];
-            populated[key] = parsed[key];
-          }
-          if (debug) {
-            if (override === true) {
-              _debug(`"${key}" is already defined and WAS overwritten`);
-            } else {
-              _debug(`"${key}" is already defined and was NOT overwritten`);
-            }
-          }
-        } else {
-          processEnv[key] = parsed[key];
-          populated[key] = parsed[key];
-        }
-      }
-      return populated;
-    }
-    var DotenvModule = {
-      configDotenv,
-      _configVault,
-      _parseVault,
-      config,
-      decrypt,
-      parse,
-      populate
-    };
-    module2.exports.configDotenv = DotenvModule.configDotenv;
-    module2.exports._configVault = DotenvModule._configVault;
-    module2.exports._parseVault = DotenvModule._parseVault;
-    module2.exports.config = DotenvModule.config;
-    module2.exports.decrypt = DotenvModule.decrypt;
-    module2.exports.parse = DotenvModule.parse;
-    module2.exports.populate = DotenvModule.populate;
-    module2.exports = DotenvModule;
-  }
-});
-
 // src/userResponse/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -861,7 +460,7 @@ var UserPromptSuggestionsMessageSchema = import_zod3.z.object({
   payload: UserPromptSuggestionsPayloadSchema
 });
 var ComponentPropsSchema = import_zod3.z.object({
-  query: import_zod3.z.string().optional(),
+  query: import_zod3.z.string().or(import_zod3.z.object({})).optional(),
   title: import_zod3.z.string().optional(),
   description: import_zod3.z.string().optional(),
   config: import_zod3.z.record(import_zod3.z.unknown()).optional(),
@@ -2060,7 +1659,7 @@ function sendDataResponse3(id, res, sendMessage, clientId) {
 }
 
 // src/userResponse/groq.ts
-var import_dotenv = __toESM(require_main());
+var import_dotenv = __toESM(require("dotenv"));
 
 // src/userResponse/base-llm.ts
 init_utils();
@@ -2688,6 +2287,7 @@ When the user asks about data
 
 After analyzing the query results, you MUST suggest appropriate dashboard components for displaying the data. Use this format:
 
+<DashboardComponents>
 **Dashboard Components:**
 Format: \`{number}.{component_type} : {clear reasoning}\`
 
@@ -2696,9 +2296,9 @@ Format: \`{number}.{component_type} : {clear reasoning}\`
 1. Analyze the query results structure and data type
 2. Suggest components that would best visualize the data
 3. Each component suggestion must be on a new line
+</DashboardComponents>
 
-
-IMPORTANT: Always include the **Dashboard Components:** section with at least one component suggestion when data is returned.
+IMPORTANT: Always wrap component suggestions with <DashboardComponents> tags and include at least one component suggestion when data is returned.
 
 ## Output Format
 
@@ -2706,7 +2306,7 @@ Respond with plain text that includes:
 
 1. **Query Analysis** (if applicable): Brief explanation of what data was fetched
 2. **Results Summary**: Present the data in a clear, readable format
-3. **Dashboard Components**: List suggested components in the c1:type format
+3. **Dashboard Components**: List suggested components wrapped in <DashboardComponents> tags
 
 
 **CRITICAL:**
@@ -2783,39 +2383,22 @@ You will receive a text response containing:
 3. **Dashboard Components:** suggestions (1:component_type : reasoning format)
 
 Your job is to:
-1. **DISCOVER and SELECT the best dashboard layout component** from the available components list
-2. Parse the component suggestions from the text response
-3. Match each suggestion with an actual component from the available list
-4. Generate the RIGHT NUMBER of components to fit the selected layout perfectly (based on the layout component's description)
-5. Generate proper props to **visualize the analysis results** that were already fetched
-6. **Generate intelligent follow-up questions (actions)** that the user might naturally ask next based on the data analysis
+1. **Parse the component suggestions** from the text response (format: 1:component_type : reasoning)
+2. **Match each suggestion with an actual component** from the available list
+3. **Generate proper props** for each matched component to **visualize the analysis results** that were already fetched
+4. **SELECT the best dashboard layout component** that can accommodate all the matched components
+5. **Generate intelligent follow-up questions (actions)** that the user might naturally ask next based on the data analysis
 
 **CRITICAL GOAL**: Create dashboard components that display the **same data that was already analyzed** - NOT new data. The queries already ran and got results. You're just creating different visualizations of those results.
 
-
-
-## Layout Component Discovery
-**Find layout components** by looking for components with \`type: "DashboardLayout"\`
-
-## Layout Selection Logic
-1. **Read each layout's description** to understand:
-   - What structure it provides
-   - When it's best used (e.g., comprehensive analysis vs focused analysis)
-   - The exact number and types of components it requires
-2. **Select the best layout** based on:
-   - Which layout structure best fits the analysis needs
-   - The component suggestions from the text response
-   - The user question and data complexity
-3. **Generate EXACTLY the components specified** in the selected layout's description
-
-**IMPORTANT:** Always prefer structured dashboard layouts when available. The layout component's description will tell you exactly what components to generate.
+**APPROACH**: First match all the components suggested in the text response, THEN find the layout that best fits those components.
 
 ## Available Components
 
 {{AVAILABLE_COMPONENTS}}
 
-## Component Matching Rules
-For each component suggestion (c1, c2, c3, etc.):
+## Component Matching Rules (STEP 1)
+For each component suggestion (c1, c2, c3, etc.) from the text response:
 
 1. **Match by type**: Find components whose \`type\` matches the suggested component type
 2. **Refine by relevance**: If multiple components match, choose based on:
@@ -2823,6 +2406,24 @@ For each component suggestion (c1, c2, c3, etc.):
    - Best fit for the data being visualized
 3. **Fallback**: If no exact type match, find the closest alternative
 
+## Layout Selection Logic (STEP 2 - After Matching Components)
+
+**After you have matched all components**, select the best dashboard layout:
+
+1. **Find layout components** by looking for components with \`type: "DashboardLayout"\` in the available components list
+2. **Read each layout's description** to understand:
+   - What structure it provides
+   - When it's best used (e.g., comprehensive analysis vs focused analysis)
+   - The number and types of components it can accommodate
+3. **Select the best layout** based on:
+   - Which layout can best display ALL the matched components
+   - The layout's capacity (how many components it supports)
+   - The types of matched components (KPI, charts, tables, etc.)
+   - The user question and data complexity
+4. **If no specific layout fits**, fall back to "MultiComponentContainer" as the default layout
+
+**IMPORTANT:** The layout should be chosen to FIT the matched components, not the other way around. Don't force components to fit a layout - find a layout that accommodates your components.
+
 ## Props Generation Rules
 
 For each matched component, generate complete props:
@@ -2935,7 +2536,6 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 \`\`\`json
 {
-  "selectedLayout": "Name of the selected layout component from available components",
   "selectedLayoutId": "id_of_the_selected_layout_component",
   "layoutReasoning": "Why this layout was selected based on its description and the analysis needs",
   "matchedComponents": [
@@ -2967,13 +2567,14 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 \`\`\`
 
 **CRITICAL:**
-- \`selectedLayout\` MUST be the NAME of a layout component from the available components list (must have type "DashboardLayout")
-- \`selectedLayoutId\` MUST be the ID of the selected layout component
+- \`matchedComponents\` MUST include ALL components suggested in the text response (match them first!)
+- \`selectedLayoutId\` MUST be the ID of the selected layout component (must have type "DashboardLayout")
 - \`layoutReasoning\` MUST explain:
   - Why you chose this specific layout component
-  - How its structure (from its description) matches the analysis needs
-  - What components it requires based on its description
-- \`matchedComponents\` array length and types MUST match what the selected layout's description specifies
+  - How many components you matched (e.g., "Matched 3 components: 1 KPI, 1 chart, 1 table")
+  - Why this layout is the best fit for displaying these specific matched components
+  - What makes this layout appropriate for the component types and count
+- The layout selection happens AFTER component matching - don't force components to fit a pre-selected layout
 - \`actions\` MUST be an array of 4-5 intelligent follow-up questions based on the analysis
 - Return ONLY valid JSON (no markdown code blocks, no text before/after)
 - Generate complete props for each component
@@ -3169,6 +2770,7 @@ var promptLoader = new PromptLoader({
 // src/llm.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_groq_sdk = __toESM(require("groq-sdk"));
+var import_jsonrepair = require("jsonrepair");
 var LLM = class {
   /* Get a complete text response from an LLM (Anthropic or Groq) */
   static async text(messages, options = {}) {
@@ -3290,65 +2892,110 @@ var LLM = class {
     let finalText = "";
     while (iterations < maxIterations) {
       iterations++;
-      const response = await client.messages.create({
+      const stream = await client.messages.create({
         model: modelName,
         max_tokens: options.maxTokens || 4e3,
         temperature: options.temperature,
         system: messages.sys,
         messages: conversationMessages,
-        tools
+        tools,
+        stream: true
+        // Enable streaming
       });
-      if (response.stop_reason === "end_turn") {
-        const textBlock = response.content.find((block) => block.type === "text");
-        if (textBlock && textBlock.type === "text") {
-          finalText = textBlock.text;
-          if (options.partial) {
-            options.partial(finalText);
+      let stopReason = null;
+      const contentBlocks = [];
+      let currentTextBlock = "";
+      let currentToolUse = null;
+      for await (const chunk of stream) {
+        if (chunk.type === "message_start") {
+          contentBlocks.length = 0;
+          currentTextBlock = "";
+          currentToolUse = null;
+        }
+        if (chunk.type === "content_block_start") {
+          if (chunk.content_block.type === "text") {
+            currentTextBlock = "";
+          } else if (chunk.content_block.type === "tool_use") {
+            currentToolUse = {
+              type: "tool_use",
+              id: chunk.content_block.id,
+              name: chunk.content_block.name,
+              input: {}
+            };
+          }
+        }
+        if (chunk.type === "content_block_delta") {
+          if (chunk.delta.type === "text_delta") {
+            const text = chunk.delta.text;
+            currentTextBlock += text;
+            if (options.partial) {
+              options.partial(text);
+            }
+          } else if (chunk.delta.type === "input_json_delta" && currentToolUse) {
+            currentToolUse.inputJson = (currentToolUse.inputJson || "") + chunk.delta.partial_json;
           }
         }
+        if (chunk.type === "content_block_stop") {
+          if (currentTextBlock) {
+            contentBlocks.push({
+              type: "text",
+              text: currentTextBlock
+            });
+            finalText = currentTextBlock;
+            currentTextBlock = "";
+          } else if (currentToolUse) {
+            try {
+              currentToolUse.input = currentToolUse.inputJson ? JSON.parse(currentToolUse.inputJson) : {};
+            } catch (error) {
+              currentToolUse.input = {};
+            }
+            delete currentToolUse.inputJson;
+            contentBlocks.push(currentToolUse);
+            currentToolUse = null;
+          }
+        }
+        if (chunk.type === "message_delta") {
+          stopReason = chunk.delta.stop_reason || stopReason;
+        }
+        if (chunk.type === "message_stop") {
+          break;
+        }
+      }
+      if (stopReason === "end_turn") {
         break;
       }
-      if (response.stop_reason === "tool_use") {
-        const toolUses = response.content.filter((block) => block.type === "tool_use");
+      if (stopReason === "tool_use") {
+        const toolUses = contentBlocks.filter((block) => block.type === "tool_use");
         if (toolUses.length === 0) {
           break;
         }
         conversationMessages.push({
           role: "assistant",
-          content: response.content
+          content: contentBlocks
         });
         const toolResults = {
           role: "user",
           content: []
         };
         for (const toolUse of toolUses) {
-          if (toolUse.type === "tool_use") {
-            try {
-              const result = await toolHandler(toolUse.name, toolUse.input);
-              toolResults.content.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: typeof result === "string" ? result : JSON.stringify(result)
-              });
-            } catch (error) {
-              toolResults.content.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: error instanceof Error ? error.message : String(error),
-                is_error: true
-              });
-            }
+          try {
+            const result = await toolHandler(toolUse.name, toolUse.input);
+            toolResults.content.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: typeof result === "string" ? result : JSON.stringify(result)
+            });
+          } catch (error) {
+            toolResults.content.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: error instanceof Error ? error.message : String(error),
+              is_error: true
+            });
           }
         }
         conversationMessages.push(toolResults);
       } else {
-        const textBlock = response.content.find((block) => block.type === "text");
-        if (textBlock && textBlock.type === "text") {
-          finalText = textBlock.text;
-          if (options.partial) {
-            options.partial(finalText);
-          }
-        }
         break;
       }
     }
@@ -3411,9 +3058,9 @@ var LLM = class {
   // ============================================================
   /**
    * Parse JSON string, handling markdown code blocks and surrounding text
-   * Enhanced version from anthropic.ts implementation
+   * Enhanced version with jsonrepair to handle malformed JSON from LLMs
    * @param text - Text that may contain JSON wrapped in ```json...``` or with surrounding text
-   * @returns Parsed JSON object
+   * @returns Parsed JSON object or array
    */
   static _parseJSON(text) {
     let jsonText = text.trim();
@@ -3423,11 +3070,29 @@ var LLM = class {
       jsonText = jsonText.replace(/^```\s*\n?/, "").replace(/\n?```\s*$/, "");
     }
     const firstBrace = jsonText.indexOf("{");
+    const firstBracket = jsonText.indexOf("[");
     const lastBrace = jsonText.lastIndexOf("}");
-    if (firstBrace !== -1 && lastBrace !== -1 && firstBrace < lastBrace) {
-      jsonText = jsonText.substring(firstBrace, lastBrace + 1);
+    const lastBracket = jsonText.lastIndexOf("]");
+    let startIdx = -1;
+    let endIdx = -1;
+    if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+      startIdx = firstBrace;
+      endIdx = lastBrace;
+    } else if (firstBracket !== -1) {
+      startIdx = firstBracket;
+      endIdx = lastBracket;
+    }
+    if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+      jsonText = jsonText.substring(startIdx, endIdx + 1);
+    }
+    try {
+      const repairedJson = (0, import_jsonrepair.jsonrepair)(jsonText);
+      return JSON.parse(repairedJson);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}
+
+Original text: ${jsonText.substring(0, 200)}...`);
     }
-    return JSON.parse(jsonText);
   }
 };
 
@@ -4040,7 +3705,7 @@ var BaseLLM = class {
       logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
       logger.file("\n=============================\nmatch text components system prompt:", prompts.system);
       logCollector?.info("Matching components from text response...");
-      const rawResponse = await LLM.stream(
+      const result = await LLM.stream(
         {
           sys: prompts.system,
           user: prompts.user
@@ -4051,60 +3716,12 @@ var BaseLLM = class {
           temperature: 0.2,
           apiKey: this.getApiKey(apiKey)
         },
-        false
-        // Don't parse as JSON yet, get raw response
+        true
+        // Parse as JSON
       );
-      logger.debug(`[${this.getProviderName()}] Raw component matching response length: ${rawResponse?.length || 0}`);
-      let result;
-      try {
-        let cleanedResponse = rawResponse || "";
-        cleanedResponse = cleanedResponse.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-        const jsonMatch = cleanedResponse.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-          cleanedResponse = jsonMatch[0];
-        }
-        result = JSON.parse(cleanedResponse);
-      } catch (parseError) {
-        logger.error(`[${this.getProviderName()}] Failed to parse component matching JSON response`);
-        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
-        const posMatch = errorMsg.match(/position (\d+)/);
-        const errorPos = posMatch ? parseInt(posMatch[1]) : -1;
-        if (errorPos > 0 && rawResponse) {
-          const start = Math.max(0, errorPos - 200);
-          const end = Math.min(rawResponse.length, errorPos + 200);
-          logger.debug(`[${this.getProviderName()}] Error context (position ${errorPos}):`);
-          logger.debug(rawResponse.substring(start, end));
-          logger.debug(" ".repeat(Math.min(200, errorPos - start)) + "^--- Error here");
-        }
-        logger.debug(`[${this.getProviderName()}] Raw response (first 2000 chars):`, rawResponse?.substring(0, 2e3));
-        logger.debug(`[${this.getProviderName()}] Parse error:`, parseError);
-        logCollector?.error(`Failed to parse component matching response: ${errorMsg}`);
-        try {
-          logger.info(`[${this.getProviderName()}] Attempting aggressive JSON cleanup...`);
-          let aggressive = rawResponse || "";
-          aggressive = aggressive.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-          const match = aggressive.match(/\{[\s\S]*\}/);
-          if (match) {
-            aggressive = match[0];
-          }
-          aggressive = aggressive.replace(/,(\s*[}\]])/g, "$1");
-          result = JSON.parse(aggressive);
-          logger.info(`[${this.getProviderName()}] Aggressive cleanup succeeded!`);
-        } catch (secondError) {
-          logger.error(`[${this.getProviderName()}] Aggressive cleanup also failed`);
-          return {
-            components: [],
-            selectedLayout: "MultiComponentContainer",
-            selectedLayoutId: "",
-            selectedLayoutComponent: null,
-            layoutReasoning: "No layout selected",
-            actions: []
-          };
-        }
-      }
+      logger.debug(`[${this.getProviderName()}] Component matching response parsed successfully`);
       const matchedComponents = result.matchedComponents || [];
-      const selectedLayout = result.selectedLayout || "MultiComponentContainer";
-      const selectedLayoutId = result.selectedLayoutId || "";
+      const selectedLayoutId = result.selectedLayoutId || "multi-component-container";
       const layoutReasoning = result.layoutReasoning || "No layout reasoning provided";
       const rawActions = result.actions || [];
       const actions = convertQuestionsToActions(rawActions);
@@ -4116,11 +3733,11 @@ var BaseLLM = class {
         }
       }
       logger.info(`[${this.getProviderName()}] Matched ${matchedComponents.length} components from text response`);
-      logger.info(`[${this.getProviderName()}] Selected layout: ${selectedLayout} (ID: ${selectedLayoutId})`);
+      logger.info(`[${this.getProviderName()}] Selected layout: (ID: ${selectedLayoutId})`);
       logger.info(`[${this.getProviderName()}] Layout reasoning: ${layoutReasoning}`);
       logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions`);
       if (matchedComponents.length > 0) {
-        logCollector?.info(`Matched ${matchedComponents.length} components for visualization using ${selectedLayout}`);
+        logCollector?.info(`Matched ${matchedComponents.length} components for visualization `);
         logCollector?.info(`Layout reasoning: ${layoutReasoning}`);
         matchedComponents.forEach((comp, idx) => {
           logCollector?.info(`  ${idx + 1}. ${comp.componentName} (${comp.componentType}): ${comp.reasoning}`);
@@ -4155,7 +3772,6 @@ var BaseLLM = class {
       }).filter(Boolean);
       return {
         components: finalComponents,
-        selectedLayout,
         selectedLayoutId,
         selectedLayoutComponent,
         layoutReasoning,
@@ -4163,15 +3779,13 @@ var BaseLLM = class {
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error matching components from text response: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Component matching error details:`, error);
-      logCollector?.error(`Error matching components: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] Error matching components: ${errorMsg}`);
+      logCollector?.error(`Failed to match components: ${errorMsg}`);
       return {
         components: [],
-        selectedLayout: "MultiComponentContainer",
         selectedLayoutId: "",
         selectedLayoutComponent: null,
-        layoutReasoning: "Error occurred during component matching",
+        layoutReasoning: "Failed to match components due to parsing error",
         actions: []
       };
     }
@@ -4438,7 +4052,7 @@ ${errorMsg}
           container_componet = {
             ...selectedLayoutComponent,
             id: `${selectedLayoutComponent.id}_${Date.now()}`,
-            description: layoutReasoning,
+            // Make ID unique for each instance
             props: {
               ...selectedLayoutComponent.props,
               config: {
@@ -4807,7 +4421,7 @@ var GroqLLM = class extends BaseLLM {
 var groqLLM = new GroqLLM();
 
 // src/userResponse/anthropic.ts
-var import_dotenv2 = __toESM(require_main());
+var import_dotenv2 = __toESM(require("dotenv"));
 import_dotenv2.default.config();
 var AnthropicLLM = class extends BaseLLM {
   constructor(config) {
@@ -4826,7 +4440,7 @@ var AnthropicLLM = class extends BaseLLM {
 var anthropicLLM = new AnthropicLLM();
 
 // src/userResponse/index.ts
-var import_dotenv3 = __toESM(require_main());
+var import_dotenv3 = __toESM(require("dotenv"));
 import_dotenv3.default.config();
 function getLLMProviders() {
   const envProviders = process.env.LLM_PROVIDERS;
@@ -7285,7 +6899,7 @@ var SuperatomSDK = class {
         url.searchParams.set("projectId", this.projectId);
         url.searchParams.set("userId", this.userId);
         url.searchParams.set("type", this.type);
-        logger.info(`Connecting to WebSocket: ${url.host}`);
+        logger.info(`Connecting to WebSocket: ${url.toString()}`);
         this.ws = createWebSocket(url.toString());
         this.ws.addEventListener("open", () => {
           this.connected = true;