localsage 1.0.0 → 1.0.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026
+Copyright (c) 2026 susheelhbti
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,25 +1,126 @@
-# localsage
+# 🧙 LocalSage
 
-A simple Hello World npm package.
+**Your local, offline AI assistant that knows your documents.**
+
+LocalSage runs a Qwen language model entirely on your machine (via Transformers.js) and answers questions using your own PDF, TXT, and Markdown files. Pure Node.js — no Python, no API keys, no data leaving your computer.
+
+## Features
+
+- 🤖 Runs AI locally via Transformers.js (ONNX) — no cloud, no API costs
+- 📚 Chat with your PDF, TXT, and MD files
+- 🔒 100% private — everything stays on your machine
+- 💾 Conversation history saved automatically
+- 🔧 Customizable model, knowledge folder, and generation settings
+- 📦 Pure Node.js — no Python required
 
 ## Installation
 
 ```bash
-npm install localsage
+npm install -g localsage
+```
+
+## Quick Start
+
+1. Go to any folder that contains your documents (PDF, TXT, MD) — or create a `knowledge` subfolder for them:
+
+```bash
+cd my-documents
+```
+
+2. Start LocalSage right there:
+
+```bash
+localsage
+```
+
+LocalSage picks the knowledge source automatically:
+1. the path you pass with `-k / --knowledge`, if given
+2. otherwise a `knowledge/` subfolder in the current directory, if it exists
+3. otherwise **the current directory itself** — so you can just `cd` into your docs folder and run `localsage`
+
+The first run downloads the model (~500 MB) to your Hugging Face cache. After that, it works fully offline.
+
+3. Ask questions about your documents!
+
+## Commands
+
+- `exit` — save history and quit
+- `clear` — clear conversation history
+- `history` — show number of stored messages
+
+## Options
+
+```bash
+localsage [options]
+
+  -m, --model <model>      Model to use (default: "onnx-community/Qwen2.5-0.5B-Instruct")
+  -k, --knowledge <path>   Knowledge folder path (default: ./knowledge if it
+                           exists, else the current directory)
+  --no-pdf                 Disable PDF support
+  --max-tokens <number>    Max tokens for response (default: 200)
+  --temperature <number>   Temperature for generation (default: 0.7)
+  -h, --help               Show help
+  -V, --version            Show version
+```
+
+> **Important:** the model must be a repo that ships ONNX weights, e.g. the
+> `onnx-community/...` mirrors. Plain `Qwen/Qwen2.5-*` repos will NOT load
+> in Transformers.js.
+
+### Examples
+
+```bash
+# Use a bigger model
+localsage --model onnx-community/Qwen2.5-1.5B-Instruct
+
+# Custom knowledge folder
+localsage --knowledge ./my_docs
+
+# Adjust generation
+localsage --max-tokens 300 --temperature 0.8
 ```
 
-## Usage
+## Programmatic Usage
 
 ```javascript
-const { hello } = require("localsage");
+const LocalSage = require('localsage');
 
-console.log(hello());
-// Hello, World!
+async function main() {
+  const assistant = new LocalSage({
+    model: 'onnx-community/Qwen2.5-0.5B-Instruct',
+    knowledgePath: './knowledge',
+    maxTokens: 200,
+    temperature: 0.7,
+  });
 
-console.log(hello("Susheel"));
-// Hello, Susheel!
+  await assistant.initialize();
+  const response = await assistant.chat('What is the capital of France?');
+  console.log(response);
+}
+
+main();
 ```
 
+## How It Works
+
+1. **Knowledge loading** — reads all TXT, MD, and PDF files from the resolved knowledge folder (explicit `-k` path → `./knowledge` subfolder → current directory), plus an optional `knowledge.txt` in the working directory
+2. **AI processing** — runs the Qwen model locally with `@huggingface/transformers`
+3. **History** — saves the conversation to `history.json` in the working directory
+
+## Requirements
+
+- Node.js 18+
+- 4 GB+ RAM recommended
+- ~1–2 GB free disk space for model files
+
+## Model Storage
+
+Models are cached by Transformers.js on first run. Override the cache location with the `LOCALSAGE_MODEL_DIR` environment variable.
+
+## 💼 Open to Work
+
+Built by a developer available for freelance and full-time opportunities. Got a project? Let's talk — 📧 [susheelhbti@gmail.com](mailto:susheelhbti@gmail.com)
+
 ## License
 
 MIT

package/bin/localsage

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Wrapper that runs the LocalSage CLI
+require('../cli.js');

package/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { program } = require('commander');
+const LocalSage = require('./index');
+
+program
+  .name('localsage')
+  .version('1.0.0')
+  .description('LocalSage — local, offline AI assistant with PDF & document knowledge')
+  .option('-m, --model <model>', 'Model name', 'onnx-community/Qwen2.5-0.5B-Instruct')
+  .option(
+    '-k, --knowledge <path>',
+    'Knowledge folder path (default: ./knowledge if it exists, else the current directory)'
+  )
+  .option('--no-pdf', 'Disable PDF support')
+  .option('--max-tokens <number>', 'Max tokens for response', '200')
+  .option('--temperature <number>', 'Temperature for generation', '0.7')
+  .parse(process.argv);
+
+const options = program.opts();
+
+async function runCLI() {
+  const assistant = new LocalSage({
+    model: options.model,
+    knowledgePath: options.knowledge,
+    maxTokens: parseInt(options.maxTokens, 10),
+    temperature: parseFloat(options.temperature),
+    pdfSupport: options.pdf !== false,
+  });
+
+  await assistant.initialize();
+
+  console.log(chalk.blue('='.repeat(60)));
+  console.log(chalk.green.bold(' 🧙 LocalSage — your local AI assistant '));
+  console.log(chalk.blue('='.repeat(60)));
+  console.log(chalk.gray(` Model: ${options.model}`));
+  console.log(chalk.gray(` Knowledge: ${assistant.getResolvedKnowledgePath()}`));
+  console.log(chalk.gray(` PDF Support: ${options.pdf !== false ? 'Enabled' : 'Disabled'}`));
+  console.log(chalk.blue('='.repeat(60)));
+  console.log(chalk.gray(' Commands:'));
+  console.log(chalk.gray('   exit     - Save and exit'));
+  console.log(chalk.gray('   clear    - Clear conversation history'));
+  console.log(chalk.gray('   history  - Show number of stored messages'));
+  console.log(chalk.blue('='.repeat(60)));
+  console.log(
+    chalk.magenta(' 💼 Open to Work — built by a developer available for freelance')
+  );
+  console.log(
+    chalk.magenta('    and full-time opportunities. Got a project? Let\'s talk —')
+  );
+  console.log(chalk.magenta.bold('    📧 susheelhbti@gmail.com'));
+  console.log(chalk.blue('='.repeat(60)));
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    try {
+      const { input } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'input',
+          message: 'You',
+          prefix: '',
+          validate: (v) => v.trim().length > 0 || 'Please enter a message',
+        },
+      ]);
+
+      const trimmed = input.trim();
+      const cmd = trimmed.toLowerCase();
+
+      if (cmd === 'exit') {
+        await assistant.saveHistory();
+        console.log(chalk.green('\n✓ History Saved'));
+        console.log(chalk.blue('Bye!'));
+        console.log(
+          chalk.magenta('💼 Need a developer? 📧 susheelhbti@gmail.com')
+        );
+        process.exit(0);
+      }
+
+      if (cmd === 'clear') {
+        await assistant.clearHistory();
+        console.log(chalk.green('\n✓ History Cleared'));
+        continue;
+      }
+
+      if (cmd === 'history') {
+        console.log(chalk.yellow(`\nStored Messages : ${assistant.getHistoryCount()}`));
+        continue;
+      }
+
+      process.stdout.write(chalk.cyan('\nAI : '));
+      const response = await assistant.chat(trimmed);
+      console.log(chalk.green(response));
+      console.log('');
+    } catch (error) {
+      // inquirer throws when the prompt stream is closed (e.g. Ctrl+C / EOF)
+      if (
+        error?.message?.includes('closed') ||
+        error?.name === 'ExitPromptError' ||
+        error?.isTtyError
+      ) {
+        await assistant.saveHistory().catch(() => {});
+        console.log(chalk.blue('\nBye!'));
+        break;
+      }
+      console.error(chalk.red('Error:'), error.message);
+    }
+  }
+}
+
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Uncaught Error:'), error.message);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  console.error(chalk.red('Unhandled Rejection:'), reason);
+});
+
+if (require.main === module) {
+  runCLI().catch((error) => {
+    console.error(chalk.red('Fatal Error:'), error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = runCLI;

package/index.js

@@ -1,7 +1,99 @@
-function hello(name = "World") {
-  return `Hello, ${name}!`;
+const QwenModel = require('./src/model');
+const KnowledgeManager = require('./src/knowledge');
+const HistoryManager = require('./src/history');
+
+class LocalSage {
+  constructor(options = {}) {
+    this.options = {
+      model: options.model || 'onnx-community/Qwen2.5-0.5B-Instruct',
+      // null = auto-resolve: ./knowledge if it exists, else the current
+      // working directory the user ran the command from
+      knowledgePath: options.knowledgePath || null,
+      maxTokens: options.maxTokens || 200,
+      temperature: options.temperature || 0.7,
+      topP: options.topP || 0.9,
+      pdfSupport: options.pdfSupport !== false,
+      ...options,
+    };
+
+    this.model = new QwenModel({
+      model: this.options.model,
+      maxTokens: this.options.maxTokens,
+      temperature: this.options.temperature,
+      topP: this.options.topP,
+    });
+
+    this.knowledge = new KnowledgeManager(this.options.knowledgePath);
+    this.history = new HistoryManager('history.json', 34);
+    this.isInitialized = false;
+  }
+
+  async initialize() {
+    if (this.isInitialized) return;
+    await this.model.load();
+    await this.knowledge.loadKnowledge();
+    await this.history.loadHistory();
+    this.isInitialized = true;
+  }
+
+  async chat(message) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    const knowledge = this.knowledge.getKnowledge(true, 4000);
+    const systemPrompt = `You are a helpful AI assistant.
+
+Answer only using the information below whenever possible.
+
+If the answer is not found in the knowledge, you may answer using your general knowledge, but clearly mention that it is not from the provided knowledge.
+
+Knowledge:
+
+${knowledge}`;
+
+    // FIX: add the user's message BEFORE generating,
+    // otherwise the model never sees the current question.
+    this.history.addMessage('user', message);
+
+    const response = await this.model.generateResponse(
+      systemPrompt,
+      this.history.getHistory()
+    );
+
+    this.history.addMessage('assistant', response);
+    await this.history.saveHistory();
+
+    return response;
+  }
+
+  async saveHistory() {
+    await this.history.saveHistory();
+  }
+
+  async clearHistory() {
+    await this.history.clear();
+  }
+
+  getHistoryCount() {
+    return this.history.getCount();
+  }
+
+  getHistory() {
+    return this.history.getHistory();
+  }
+
+  getKnowledge() {
+    return this.knowledge.getKnowledge();
+  }
+
+  getResolvedKnowledgePath() {
+    return this.knowledge.getResolvedPath();
+  }
+
+  async reloadKnowledge() {
+    await this.knowledge.loadKnowledge();
+  }
 }
 
-module.exports = {
-  hello
-};
+module.exports = LocalSage;

package/package.json

@@ -1,10 +1,56 @@
 {
   "name": "localsage",
-  "version": "1.0.0",
-  "description": "A simple hello world package.",
+  "version": "1.0.2",
+  "description": "LocalSage — a local, offline AI assistant with PDF & document knowledge. Powered by Qwen via Transformers.js. Pure Node.js, no Python.",
   "main": "index.js",
-  "type": "commonjs",
-  "keywords": ["hello", "localsage"],
-  "author": "Your Name",
-  "license": "MIT"
+  "bin": {
+    "localsage": "bin/localsage"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "setup": "node scripts/setup.js"
+  },
+  "keywords": [
+    "ai",
+    "assistant",
+    "local-ai",
+    "offline",
+    "qwen",
+    "llm",
+    "chatbot",
+    "pdf",
+    "rag",
+    "transformers",
+    "chat-with-docs"
+  ],
+  "author": "susheelhbti <susheelhbti@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@huggingface/transformers": "^3.3.1",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.6",
+    "pdf-parse": "^1.1.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/susheelhbti/localsage.git"
+  },
+  "bugs": {
+    "url": "https://github.com/susheelhbti/localsage/issues"
+  },
+  "homepage": "https://github.com/susheelhbti/localsage#readme",
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "index.js",
+    "cli.js",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/scripts/setup.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Optional helper: run `npm run setup` to scaffold a knowledge folder
+// in the CURRENT directory.
+// NOTE: intentionally NOT a postinstall hook — postinstall runs inside
+// node_modules and would fail / pollute the wrong directory.
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+console.log(chalk.cyan('Setting up LocalSage...'));
+
+async function setup() {
+  const knowledgePath = path.join(process.cwd(), 'knowledge');
+  if (!(await fs.pathExists(knowledgePath))) {
+    await fs.mkdir(knowledgePath);
+    console.log(chalk.green('✓ Created knowledge folder'));
+  }
+
+  const sampleFile = path.join(knowledgePath, 'sample.txt');
+  if (!(await fs.pathExists(sampleFile))) {
+    await fs.writeFile(
+      sampleFile,
+      'This is a sample knowledge file.\n\n' +
+        'You can add your own text files or PDFs here.\n' +
+        'The AI will use this information to answer questions.\n\n' +
+        'Example:\n' +
+        'The capital of France is Paris.\n' +
+        'Water boils at 100 degrees Celsius.\n'
+    );
+    console.log(chalk.green('✓ Created sample knowledge file'));
+  }
+
+  console.log(chalk.green('\n✓ Setup complete!'));
+  console.log(chalk.blue('\nTo start the assistant:'));
+  console.log('  localsage');
+  console.log(chalk.gray('\nOr with options:'));
+  console.log(
+    '  localsage --model onnx-community/Qwen2.5-1.5B-Instruct --knowledge ./my_knowledge'
+  );
+}
+
+setup().catch((error) => {
+  console.error(chalk.red('Setup error:'), error.message);
+  process.exit(1);
+});

package/src/history.js

@@ -0,0 +1,66 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class HistoryManager {
+  constructor(historyFile = 'history.json', maxHistory = 34) {
+    this.historyFile = historyFile;
+    // keep an even number so user/assistant pairs stay intact
+    this.maxHistory = maxHistory % 2 === 0 ? maxHistory : maxHistory + 1;
+    this.messages = [];
+  }
+
+  filePath() {
+    return path.join(process.cwd(), this.historyFile);
+  }
+
+  async loadHistory() {
+    if (await fs.pathExists(this.filePath())) {
+      try {
+        const data = await fs.readFile(this.filePath(), 'utf-8');
+        this.messages = JSON.parse(data);
+        if (!Array.isArray(this.messages)) this.messages = [];
+        console.log(`History Loaded. ${this.messages.length} messages.\n`);
+      } catch (error) {
+        console.error('Error loading history:', error.message);
+        this.messages = [];
+      }
+    } else {
+      this.messages = [];
+    }
+    return this.messages;
+  }
+
+  async saveHistory() {
+    try {
+      await fs.writeJson(this.filePath(), this.messages, { spaces: 2 });
+    } catch (error) {
+      console.error('Error saving history:', error.message);
+    }
+  }
+
+  addMessage(role, content) {
+    this.messages.push({ role, content });
+    if (this.messages.length > this.maxHistory) {
+      this.messages = this.messages.slice(-this.maxHistory);
+      // never let the trimmed history start with an assistant message
+      if (this.messages[0]?.role === 'assistant') {
+        this.messages.shift();
+      }
+    }
+  }
+
+  async clear() {
+    this.messages = [];
+    await this.saveHistory();
+  }
+
+  getHistory() {
+    return this.messages;
+  }
+
+  getCount() {
+    return this.messages.length;
+  }
+}
+
+module.exports = HistoryManager;

package/src/knowledge.js

@@ -0,0 +1,139 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class KnowledgeManager {
+  /**
+   * @param {string|null} knowledgePath - explicit path from the user, or null
+   *        to auto-resolve: use ./knowledge if it exists, otherwise the
+   *        current working directory itself.
+   */
+  constructor(knowledgePath = null) {
+    this.requestedPath = knowledgePath;
+    this.knowledgePath = null; // resolved in loadKnowledge()
+    this.knowledge = '';
+  }
+
+  resolvePath() {
+    if (this.requestedPath) {
+      return path.resolve(this.requestedPath);
+    }
+    const sub = path.join(process.cwd(), 'knowledge');
+    if (fs.pathExistsSync(sub)) {
+      return sub;
+    }
+    // Fall back to the directory the user ran the command from
+    return process.cwd();
+  }
+
+  async loadKnowledge() {
+    this.knowledgePath = this.resolvePath();
+    let combinedKnowledge = '';
+
+    // Load a standalone knowledge.txt from the working directory —
+    // but only if it isn't already inside the folder we're about to scan
+    // (avoids loading it twice when knowledgePath === cwd).
+    const txtFile = path.join(process.cwd(), 'knowledge.txt');
+    if (
+      path.dirname(txtFile) !== this.knowledgePath &&
+      (await fs.pathExists(txtFile))
+    ) {
+      try {
+        combinedKnowledge += await fs.readFile(txtFile, 'utf-8');
+        console.log('Knowledge loaded from knowledge.txt');
+      } catch (error) {
+        console.error('Error loading knowledge.txt:', error.message);
+      }
+    }
+
+    if (await fs.pathExists(this.knowledgePath)) {
+      console.log(`Loading knowledge from: ${this.knowledgePath}`);
+      const folderKnowledge = await this.loadFolder(this.knowledgePath);
+      if (folderKnowledge) {
+        if (combinedKnowledge) {
+          combinedKnowledge += '\n\n' + '='.repeat(50) + '\n\n';
+        }
+        combinedKnowledge += folderKnowledge;
+      }
+    } else {
+      console.log(`Knowledge path not found: ${this.knowledgePath}`);
+    }
+
+    this.knowledge = combinedKnowledge;
+
+    if (!this.knowledge.trim()) {
+      console.log('Warning: No knowledge loaded. Using general knowledge only.\n');
+    } else {
+      console.log(`Total knowledge loaded: ${this.knowledge.length} characters\n`);
+    }
+
+    return this.knowledge;
+  }
+
+  async loadFolder(folderPath) {
+    let combined = '';
+    const files = await fs.readdir(folderPath);
+
+    for (const file of files) {
+      const filePath = path.join(folderPath, file);
+
+      let stat;
+      try {
+        stat = await fs.stat(filePath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) continue;
+
+      const ext = path.extname(file).toLowerCase();
+
+      try {
+        if (ext === '.txt' || ext === '.md') {
+          const content = await fs.readFile(filePath, 'utf-8');
+          combined += `\n\n--- Content from ${file} ---\n\n${content}`;
+          console.log(`Loaded: ${file}`);
+        } else if (ext === '.pdf') {
+          console.log(`Reading PDF: ${file}`);
+          const content = await this.extractPDF(filePath);
+          if (content.trim()) {
+            combined += `\n\n--- Content from ${file} ---\n\n${content}`;
+            console.log(`Loaded: ${file}`);
+          } else {
+            console.log(`Warning: No text extracted from ${file}`);
+          }
+        }
+      } catch (error) {
+        console.error(`Error reading ${file}:`, error.message);
+      }
+    }
+
+    return combined;
+  }
+
+  async extractPDF(filePath) {
+    try {
+      const pdfParse = require('pdf-parse');
+      const dataBuffer = await fs.readFile(filePath);
+      const data = await pdfParse(dataBuffer);
+      return data.text || '';
+    } catch (error) {
+      console.error(`Error extracting PDF ${filePath}:`, error.message);
+      return '';
+    }
+  }
+
+  getResolvedPath() {
+    return this.knowledgePath || this.resolvePath();
+  }
+
+  getKnowledge(truncate = true, maxLength = 4000) {
+    if (!truncate || this.knowledge.length <= maxLength) {
+      return this.knowledge;
+    }
+    return (
+      this.knowledge.substring(0, maxLength) +
+      '\n\n[Knowledge truncated due to length]'
+    );
+  }
+}
+
+module.exports = KnowledgeManager;

package/src/model.js

@@ -0,0 +1,99 @@
+const path = require('path');
+
+// @huggingface/transformers is an ES Module — load it via dynamic import
+// so this package stays CommonJS-friendly.
+let transformersPromise = null;
+function loadTransformers() {
+  if (!transformersPromise) {
+    transformersPromise = import('@huggingface/transformers');
+  }
+  return transformersPromise;
+}
+
+class QwenModel {
+  constructor(options = {}) {
+    // NOTE: must be a repo that ships ONNX weights.
+    // "Qwen/Qwen2.5-0.5B-Instruct" does NOT — "onnx-community/..." does.
+    this.modelName = options.model || 'onnx-community/Qwen2.5-0.5B-Instruct';
+    this.maxTokens = options.maxTokens || 200;
+    this.temperature = options.temperature || 0.7;
+    this.topP = options.topP || 0.9;
+    this.repetitionPenalty = options.repetitionPenalty || 1.1;
+    this.pipeline = null;
+    this.isLoaded = false;
+  }
+
+  async load() {
+    if (this.isLoaded) return;
+
+    console.log('Loading AI Model (first run downloads ~500MB, please wait)...');
+
+    try {
+      const { pipeline, env } = await loadTransformers();
+
+      // Cache models inside the user's home cache dir (default behaviour),
+      // but allow override via LOCALSAGE_MODEL_DIR.
+      if (process.env.LOCALSAGE_MODEL_DIR) {
+        env.cacheDir = path.resolve(process.env.LOCALSAGE_MODEL_DIR);
+      }
+
+      this.pipeline = await pipeline('text-generation', this.modelName, {
+        dtype: 'q4', // quantized for speed / low RAM
+      });
+
+      this.isLoaded = true;
+      console.log('Model Loaded Successfully.\n');
+    } catch (error) {
+      console.error('Error loading model:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * @param {string} systemPrompt
+   * @param {Array<{role:string, content:string}>} messages - full chat history,
+   *        MUST already include the latest user message.
+   */
+  async generateResponse(systemPrompt, messages = []) {
+    if (!this.isLoaded) {
+      await this.load();
+    }
+
+    try {
+      const chat = [
+        { role: 'system', content: systemPrompt },
+        ...(Array.isArray(messages) ? messages : []),
+      ];
+
+      const result = await this.pipeline(chat, {
+        max_new_tokens: this.maxTokens,
+        temperature: this.temperature,
+        top_p: this.topP,
+        repetition_penalty: this.repetitionPenalty,
+        do_sample: true,
+        return_full_text: false,
+      });
+
+      // With chat (messages) input, generated_text is the message list;
+      // the assistant reply is the last entry. With return_full_text: false
+      // some versions return just the new text — handle both shapes.
+      const generated = result?.[0]?.generated_text;
+
+      if (typeof generated === 'string') {
+        return generated.trim() || "I'm sorry, I couldn't generate a response.";
+      }
+      if (Array.isArray(generated)) {
+        const last = generated[generated.length - 1];
+        const text = typeof last === 'string' ? last : last?.content;
+        return (text || '').trim() || "I'm sorry, I couldn't generate a response.";
+      }
+
+      return "I'm sorry, I couldn't generate a response.";
+    } catch (error) {
+      console.error('Error generating response:', error.message);
+      return "I'm sorry, I encountered an error while generating a response.";
+    }
+  }
+}
+
+module.exports = QwenModel;