@j-o-r/hello-dave 0.0.2 → 0.0.3

package/README.md.backup

@@ -0,0 +1,269 @@
+# @j-o-r/hello-dave
+
+[![npm version](https://badge.fury.io/js/%40j-o-r%2Fhello-dave.svg)](https://www.npmjs.com/package/%40j-o-r%2Fhello-dave)
+[![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Node.js >=20](https://img.shields.io/badge/Node.js-%3E=20-green.svg)](https://nodejs.org/)
+
+## Table of Contents
+
+- [Description](#description)
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+- [Examples](#examples)
+- [Development](#development)
+- [Changelog](#changelog)
+- [Contributing](#contributing)
+- [License](#license)
+- [TODO Alignment](#todo-alignment)
+
+## Description
+
+**@j-o-r/hello-dave** is a lightweight, ESM-only Node.js framework for building intelligent AI agents powered by large language models (LLMs) such as xAI Grok, Anthropic Claude, or OpenAI GPT. It simplifies the creation of custom agents with features like the central `AgentManager` class, WebSocket-based client/server support for networked agents, seamless tool integration (e.g., bash execution, web search), customizable system prompts, and robust session management supporting large context windows (up to millions of tokens).
+
+The framework emphasizes ease of use, allowing developers and non-experts alike to rapidly prototype and deploy specialized agents. Core integrations include unified xAI Grok API access, WebSocket (WS) networking with secret-based authentication, and direct CLI/cron messaging (no heartbeat/ping mechanism required). Example scripts like `readmeDave`, `todoDave`, and others have been reorganized into the `examples/` folder for clarity.
+
+Whether you're building a code reviewer, a research assistant, or a creative collaborator, `@j-o-r/hello-dave` abstracts away API complexities, providing a unified interface across providers. It's alpha-stage but production-ready for personal projects, with persistence for sessions and logs in NDJSON format.
+
+## Features
+
+- **Unified LLM Access**: Seamless integration with xAI Grok API, Anthropic Claude, and OpenAI GPT via a single API.
+- **AgentManager Class**: Core orchestrator for prompts, tools, sessions, and interactions (CLI, direct calls, WebSocket).
+- **Tool Integration**: Built-in tools for bash scripting, web search, JavaScript execution, and more; easily extensible.
+- **WebSocket Networking with Secrets**: Agents can act as servers or clients with optional secret authentication, enabling secure distributed agent networks across machines.
+- **Direct CLI/Cron Messaging**: Simplified interactions without needing heartbeat mechanisms—ideal for scheduled tasks.
+- **Customizable Prompts**: Tailor agent behavior with system prompts for specialized tasks (e.g., music production, code analysis).
+- **Session Management**: Persistent conversations with large context windows; automatic truncation and history search.
+- **CLI Utilities**: Core tool at `bin/dave.js` for cache management, WS connections, and interactive queries; plus agent generator.
+- **Lightweight & TypeScript-Friendly**: ESM-only, no heavy deps; full types included.
+
+## Installation
+
+Install as a dependency in your Node.js project (requires Node.js >= 20 with `"type": "module"` in `package.json`):
+
+```bash
+npm install @j-o-r/hello-dave
+```
+
+For global access to CLI tools (including `dave` from `bin/dave.js`):
+
+```bash
+npm install -g @j-o-r/hello-dave
+```
+
+Set your API keys via environment variables (only set what you need):
+- `XAIKEY` for xAI Grok
+- `ANTHKEY` for Anthropic Claude
+- `OPENAIKEY` for OpenAI GPT
+- `BRAVESEARCHKEY` for web search (optional)
+
+Create a cache directory for sessions:
+```bash
+mkdir .cache
+```
+
+## Quick Start
+
+1. Set an API key (e.g., for Grok):
+   ```bash
+   export XAIKEY=your_xai_api_key
+   ```
+
+2. Use the core CLI utility `bin/dave.js` for interactive queries or management:
+   ```bash
+   npx @j-o-r/hello-dave dave --ask
+   ```
+   - Launches an interactive agent session. Use `Alt+d` to exit, `Alt+r` to reset.
+   - Example: Ask questions about anything; it uses xAI Grok by default with web search and X search tools.
+
+3. For one-shot queries via piped input:
+   ```bash
+   echo "Explain quantum computing" | npx @j-o-r/hello-dave dave --ask --model grok-4
+   ```
+   - Provides a direct response using the specified model (e.g., `--model grok-4`).
+
+4. Connect to a WebSocket server (e.g., for networked agents):
+   ```bash
+   npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret your_secret
+   ```
+
+5. Generate a custom agent using the spawner (snippet from `bin/dave.js` integration):
+   ```bash
+   npx @j-o-r/hello-dave spawnDave
+   ```
+   - Interactive: Follow prompts to create a new agent script in `bin/`.
+
+`bin/dave.js` also supports cache operations like `--list` (list sessions), `--search "query"`, `--clear`, and `--inspect path/to/log.ndjson`.
+
+## Usage
+
+### Core CLI via `bin/dave.js`
+
+`bin/dave.js` provides essential utilities and examples for agent spawning, WS interactions, and basic querying. Key commands:
+
+- **Ask Mode** (Interactive or Piped One-Shot):
+  ```bash
+  # Interactive
+  npx @j-o-r/hello-dave dave --ask --model grok-4 --temperature 0.2
+
+  # Piped one-shot
+  echo "What is quantum computing?" | npx @j-o-r/hello-dave dave --ask --model grok-4
+  ```
+  - Note: Piped input triggers a direct response via `directCall`; without pipe, it launches an interactive CLI session.
+  - `--model` option works for both modes (e.g., `grok-4`, `grok-4-1-fast-reasoning`).
+  - Uses `AgentManager` with xAI Grok API integration, adds tools like `web_search`, `x_search`, `open_link`, `send_email`, `history_search`.
+  - System prompt emphasizes brief, direct responses with step-by-step reasoning.
+
+- **WebSocket Client Mode** (with secrets for secure networking):
+  ```bash
+  # Interactive connection
+  npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+
+  # Piped one-shot (direct CLI/cron messaging, no heartbeat needed)
+  echo "Predict the weather" | npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+  echo "user_reset" | npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+  ```
+
+- **Cache Management**:
+  ```bash
+  npx @j-o-r/hello-dave dave --list  # List sessions
+  npx @j-o-r/hello-dave dave --search "AI agents"  # Search history
+  npx @j-o-r/hello-dave dave --clear  # Clear cache
+  ```
+
+For custom agents, use `AgentManager` programmatically (see Examples).
+
+### Programmatic Usage with AgentManager
+
+```javascript
+import AgentManager from '@j-o-r/hello-dave';
+
+const agent = new AgentManager({ name: 'MyAgent', secret: 'optional_secret' });
+agent.setup({
+  prompt: 'You are a helpful assistant...',
+  api: 'xai',  // Uses unified xAI Grok API access
+  options: { model: 'grok-4', temperature: 0.7, tools: [{ type: 'web_search' }] },
+  toolsetMode: 'auto',
+  contextWindow: 500000
+});
+
+agent.addGenericToolcall('execute_bash_script');  // Post-setup generics
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('write_file');
+
+await agent.start();  // Interactive CLI
+// Or: await agent.start(undefined, 8000, undefined, 'Intro', 'toolName', 'desc');  // WS server
+// Or: const response = await agent.directCall('Query');  // One-shot
+```
+
+Direct CLI/cron: Pipe inputs to custom scripts for non-interactive use. WS supports secrets for authentication; no heartbeat required due to event-driven messaging.
+
+## Examples
+
+Example scripts (e.g., `readmeDave.js` for README management, `todoDave.js` for task handling, `spawnDave.js` for agent creation) are now organized in the `examples/` folder. These demonstrate specialized agents using `AgentManager`, xAI Grok API integration, and tools.
+
+- **Link to Examples Folder**: Explore [examples/](examples/) for full scripts like `daisy.js` (music agent), `codeDave.js` (code review), `npmDave.js` (NPM inspector).
+
+### Snippet: Spawning Agents (from `examples/spawnDave.js` integration via `bin/dave.js`)
+
+`spawnDave` uses `AgentManager` to interactively generate new agent scripts:
+
+```javascript
+// Core setup in spawnDave
+const agent = new AgentManager({ name: 'spawn_dave', secret });
+agent.setup({
+  prompt: 'You are AgentCreator... [detailed prompt for portability, validation]',
+  api: 'xai',
+  options: { model: 'grok-4-fast-reasoning', tools: [{ type: 'web_search' }], reasoning: { effort: 'high' } },
+  toolsetMode: 'auto',
+  contextWindow: 500000
+});
+agent.addGenericToolcall('execute_bash_script');  // For project inspection
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('write_file');  // For generating bin/ scripts
+
+await agent.start();  // Guides user to create e.g., bin/myagent.js
+```
+
+- Validates generated ESM code with `node --check` and tool rules (xAI natives pre-setup, generics post-setup).
+- Ensures absolute imports for portability.
+
+### Snippet: Using xAI Grok API Integration
+
+The unified xAI Grok API access supports options like reasoning and tools:
+
+```javascript
+// In AgentManager setup
+const options = {
+  model: 'grok-4-1-fast-reasoning',
+  temperature: 0.8,
+  tools: [{ type: 'web_search' }, { type: 'x_search', from_date: '2024-01-01' }],  // Native xAI tools
+  reasoning: { effort: 'medium', summary: 'auto' }  // Chain-of-thought support
+};
+```
+
+Detailed examples for xAI integration (e.g., advanced tool calls, reasoning) are planned (see TODO).
+
+### Running Examples
+
+```bash
+# Music agent (examples/daisy.js)
+chmod +x examples/daisy.js
+./examples/daisy.js "Generate lyrics for a pop song"
+
+# TODO manager (examples/todoDave.js)
+./examples/todoDave.js --connect ws://localhost:8080 --secret "secret"
+
+# Server setup for networked examples
+npx @j-o-r/hello-dave dave --ask --serve 8080  # Expose as WS server
+```
+
+## Development
+
+- **Scripts**: `npm test` (runs scenarios/grok.js), `npm run types` (generate TypeScript defs), `npm run release` (pack for release).
+- **Structure**: Core in `lib/` (AgentManager.js, wsCli.js, etc.), API integrations in `lib/API/`, examples in `examples/`, utils in `utils/`.
+- **Testing**: Basic validation via `npm test`. Unit tests for xAI integration planned (see TODO).
+- **Prep for v0.0.4**: Focus on spawnDave enhancements and release testing.
+
+## Changelog
+
+### v0.0.4 (Prep - March 2026)
+- Reorganized examples to `examples/` folder (readmeDave, todoDave, etc.).
+- Enhanced `bin/dave.js` for core utilities: spawning, WS with secrets, direct messaging.
+- Improved xAI Grok API integration; added native tools/reasoning support.
+- Removed heartbeat needs; direct CLI/cron support.
+- Added piped one-shot support to dave --ask.
+- TODO alignment: High-priority items noted (release prep, spawnDave enhancements).
+
+### v0.0.3 (Previous)
+- Initial WS secrets, generic tools, AgentManager refinements.
+
+Full history in git tags.
+
+## Contributing
+
+Contributions are welcome! Fork the repo at [https://codeberg.org/duin/hello-dave](https://codeberg.org/duin/hello-dave), create a feature branch, and submit a pull request.
+
+1. Install deps: `npm install`
+2. Self dep `npm run link-self`
+3. Run tests: `npm test`
+4. Generate types: `npm run types`
+5. Report issues: [https://codeberg.org/duin/hello-dave/issues](https://codeberg.org/duin/hello-dave/issues)
+
+Follow the [Code of Conduct](CODE_OF_CONDUCT.md) and Apache-2.0 license.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) for details.
+
+## TODO Alignment
+
+This README aligns with high-priority items from [TODO.md](TODO.md):
+- **v0.0.4 Prep**: Changelog snippet added; release testing emphasized in Development.
+- **spawnDave Enhancements**: Highlighted in Examples with portability notes.
+- xAI integration tests/examples: Deferred to later (general enhancements).
+- Documentation tasks (e.g., AgentManager internals) integrated into Usage/Examples.
+- Deferred: Other xAI features to later; focus on core release and spawnDave.
+
+For full TODO, see [TODO.md](TODO.md).

package/bin/dave.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env -S node
+import path from 'node:path';
+import cli from '@j-o-r/cli';
+import wsCli from '../lib/wsCli.js';
+import wsIO from '../lib/wsIO.js';
+import { AgentManager } from '@j-o-r/hello-dave';
+import { SH, parseArgs, readIn, bashEscape } from '@j-o-r/sh';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pipedInput = await readIn();
+const args = parseArgs();
+
+function printHelp(exitCode = 0) {
+	console.log(`
+FLAGS:
+--help : Show this help
+--clear : Removes the entire 'hello-dave' cache (chat history etc.)
+--search "[search_query_or_regex]" : Search in cache history
+--list : List all agent sessions in this folder
+--inspect "[path_to_ndjson_log]" : Inspect, Format and output a ndjson log file
+--connect [ws://url][--secret "..."] : Connect to Agent websocket server
+  Interactive: bin/dave.js --connect 'ws://localhost:8080' --secret '123'
+  Piped actions:
+    echo "predict the weather" | bin/dave.js --connect 'ws://...' --secret '123'  # user_request
+    echo "user_info" | bin/dave.js --connect 'ws://...' --secret '123'           # user_info
+    echo "user_reset" | bin/dave.js --connect 'ws://...' --secret '123'          # user_reset
+--ask : Launches a CLI and ask questions about whatever is on your mind
+        XAIKEY required: export XAIKEY=xai-...
+`);
+	process.exit(exitCode)
+}
+
+// Make sure an action is defined
+const keys = Object.keys(args);
+if (
+	!(
+		keys.indexOf('help') > 0 ||
+		keys.indexOf('clear') > 0 ||
+		keys.indexOf('search') > 0 ||
+		keys.indexOf('list') > 0 ||
+		keys.indexOf('inspect') > 0 ||
+		keys.indexOf('connect') > 0 ||
+		keys.indexOf('ask') > 0
+	)
+) {
+	printHelp(1);
+}
+
+if (args.help) {
+	printHelp();
+}
+
+if (args.clear) {
+	const clear_sessions = path.resolve(__dirname, '..', 'utils', 'clear_sessions.sh')
+	const y = await cli.yesNo('Delete entire cache? (y/n) ');
+	if (y) {
+		console.log(clear_sessions);
+	  const res = await SH`${clear_sessions}`.run()
+	  console.log(res);
+	}
+	process.exit();
+} else if (args.search) {
+	const history_search = path.resolve(__dirname, '..', 'utils', 'search_sessions.sh')
+	if (typeof args.search !== 'string') {
+		printHelp(1)
+	}
+	const res = await SH`${history_search} "${bashEscape(args.search)}"`.run();
+	console.log(res);
+	process.exit();
+} else if (args.list) {
+	const list = path.resolve(__dirname, '..', 'utils', 'list_sessions.sh');
+	const res = await SH`${list}`.run();
+	console.log(res);
+	process.exit();
+} else if (args.inspect) {
+	const format = path.resolve(__dirname, '..', 'utils', 'format_log.js')
+	if (typeof args.inspect !== 'string') {
+		printHelp(1)
+	}
+	try {
+		const res = await SH`${format} "${bashEscape(args.inspect)}"`.run();
+		console.log(res);
+	} catch (e) {
+		console.error(e);
+		process.exit(1);
+	}
+} else if (args.connect) {
+	let secret = args.secret ? args.secret : '';
+
+	if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
+		// Piped input mode: use wsIO for one-shot actions
+		let action, input;
+		const trimmed = pipedInput.trim();
+		if (trimmed === 'user_info' || trimmed === 'user_reset') {
+			action = trimmed;
+			input = '';
+		} else {
+			action = 'user_request';
+			input = trimmed;
+		}
+
+		try {
+			const response = await wsIO(args.connect, secret, action, input);
+			console.log(response.content);
+		} catch (e) {
+			console.error(`Error: ${e.message}`);
+			process.exit(1);
+		}
+	} else {
+		// No piped input: interactive wsCli mode
+		wsCli(args.connect, secret);
+	}
+} else if (args.ask) {
+	const name = 'ask_dave';
+	const api = 'xai';
+	let secret = '';
+	const contextWindow = 1900000;
+	const toolsetMode = 'auto';
+	/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+	const options = {
+		tools: []
+	};
+	options.tools.push({ type: 'web_search' });
+	options.tools.push({ type: 'x_search' });
+	options.model = args.model || args['model'] || 'grok-4-1-fast-reasoning';
+	options.temperature = 0.2;
+	options.reasoning = { effort: 'medium', summary: 'auto' };
+
+	const prompt = `
+Respond briefly and directly, using minimal words. Reason step-by-step first. Focus solely on core point; avoid elaboration or follow-ups. If unclear, ask clarifying questions before proceeding.
+	`.trim();
+
+	const agent = new AgentManager({ name, secret });
+	agent.setup({
+		prompt,
+		api,
+		options,
+		toolsetMode,
+		contextWindow
+	});
+	agent.addGenericToolcall('open_link');
+	agent.addGenericToolcall('send_email');
+	agent.addGenericToolcall('history_search');
+
+	const cliIntro = `
+${name} ${options.model}.
+- context: ${contextWindow}
+	`.trim();
+	const description = `Ask dave, he knows.`.trim();
+
+	// Support piped one-shot (like --connect), else interactive CLI
+	if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
+		try {
+			const response = await agent.directCall(pipedInput.trim());
+			console.log(response);
+		} catch (e) {
+			console.error(`Error: ${e.message}`);
+			process.exit(1);
+		}
+	} else {
+		await agent.start(undefined, undefined, cliIntro, name, description);
+	}
+}

package/examples/CodeServer

@@ -0,0 +1,43 @@
+#!/bin/bash
+if [ $# -lt 1 ] || [ $# -gt 2 ]; then
+  echo "Usage: $0 <PORT> [SECRET]  # PORT: 1024-65535, SECRET: optional (defaults to '123')"
+  exit 1
+fi
+
+PORT="$1"
+SECRET="${2:-123}"
+
+if [ -z "$SECRET" ] || [ ${#SECRET} -lt 3 ]; then
+  echo "Error: SECRET must be at least 3 characters: '$SECRET'"
+  exit 1
+fi
+
+if ! [[ "$PORT" =~ ^[0-9]+$ ]] || [ "$PORT" -lt 1024 ] || [ "$PORT" -gt 65535 ]; then
+  echo "Error: Invalid port number: $PORT. Must be between 1024 and 65535."
+  exit 1
+fi
+
+# Compute paths relative to THIS script's location (portable from anywhere)
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_DIR="$( cd "$( dirname "${SCRIPT_DIR}" )" && pwd )"
+FOLDER=$(basename "$PROJECT_DIR")
+
+echo "Starting CodeServer on port ${PORT} in folder '${FOLDER}' (SCRIPT_DIR: ${SCRIPT_DIR}) with SECRET '${SECRET}'..."
+
+# Delete existing processes with folder_port suffix
+pm2 delete "${FOLDER}_code_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_todo_agent_${PORT}"  2>/dev/null || true
+pm2 delete "${FOLDER}_readme_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_npm_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_docs_agent_${PORT}" 2>/dev/null || true
+
+# Spawn main Agent / server (absolute paths to scripts)
+pm2 start "${SCRIPT_DIR}/codeDave.js" --name "${FOLDER}_code_agent_${PORT}" -- --serve "${PORT}" --tools javascript --secret "${SECRET}"
+# Attach clients
+pm2 start "${SCRIPT_DIR}/todoDave.js"   --name "${FOLDER}_todo_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/readmeDave.js" --name "${FOLDER}_readme_agent_${PORT}" -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/npmDave.js"    --name "${FOLDER}_npm_agent_${PORT}"    -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/docsDave.js"   --name "${FOLDER}_docs_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+
+echo "CodeServer processes spawned with prefix '${FOLDER}_' and suffix _${PORT}. Check with: pm2 list | grep '${FOLDER}_${PORT}'"
+echo "dave --connect ws://127.0.0.1:${PORT}/ws --secret '$SECRET'"

package/{bin/hdAsk.js → examples/askDave.js}

@@ -1,37 +1,51 @@
 #!/usr/bin/env node
-import AgentManager from '../lib/AgentManager.js';
-import { parseArgs, readIn } from '@j-o-r/sh';
+import { AgentManager }  from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
 
-const name = 'hdAsk';
-const api = 'grok';
+const name = 'ask_dave';
+const api = 'xai';
+let secret = '';
 
-const input = await readIn();
+// const input = await readIn();
 const args = parseArgs();
 const help = args['help'] || false;
 const connect = args['connect'] ? args['connect'] : undefined;
 const serve = args['serve'] ? parseInt(args['serve']) : undefined;
 
-/** @type {import('lib/API/x.ai/text.js').XOptions} */
-const options = {}
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = {
+	tools: []
+}
+options.tools.push({
+	type: 'web_search'
+});
+options.tools.push({
+	type: 'x_search'
+});
+
+if (args['secret']) { // model gets default value
+	secret = args['secret'];
+}
 // Set properties only if provided via command line (except model which has default)
 if (args['model'] || true) { // model gets default value
-	// @ts-ignore
-	options.model = args['model'] || 'grok-4-fast';
+	// @ts-ignore   || grok-4-1-fast-non-reasoning
+	options.model = args['model'] || 'grok-4-1-fast-reasoning';
 }
 if (args['temperature']) {
 	options.temperature = parseFloat(args['temperature']);
 }
 if (args['tokens']) {
-	options.max_completion_tokens = parseInt(args['tokens']);
+	options.max_output_tokens = parseInt(args['tokens']);
 }
 if (args['top_p']) {
 	options.top_p = parseFloat(args['top_p']);
 }
-options.search_parameters = { mode: 'auto' }
-const reasoning = args['reasoning'] ? args['reasoning'] : null;
+const reasoning = true // args['reasoning'] ? args['reasoning'] : null;
 if (reasoning) {
-	// @ts-ignore
-	options.reasoning_effort = reasoning
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
 }
 // Large context on grok-4-fast
 const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
@@ -45,12 +59,15 @@ OPTIONS:
 --tokens [number]: max generated tokens 
 --context [number] : truncate message history to context-windows size default 130000
 --temperature [float] : -2 / +2
---model [grok-4|grok-3|grok-3-mini|grok-3-mini-fast|grok-code-fast-1]
+--model ['grok-4-1-fast-reasoning'|'grok-4-1-fast-non-reasoning'|'grok-code-fast-1'|'grok-4-fast-reasoning'|'grok-4-fast-non-reasoning']
 --top_p [float]: number > 0, 0.1 means no top_p
 --reasoning [low|high]
 --tools [javascript,bash] comma seperated list
-e.g.
-grok.js --model grok-3-mini --tokens 4000 --context 10000
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
 
 `);
 	process.exit()
@@ -61,11 +78,9 @@ if (help) {
 
 const prompt = `
 Respond briefly and directly, using minimal words. Reason step-by-step first. Focus solely on core point; avoid elaboration or follow-ups. If unclear, ask clarifying questions before proceeding.
-- open_link: [url] — open in local browser.
-- send_email: send to [email_address]; message: [message].
  `.trim();
 
-const agent = new AgentManager({ name });
+const agent = new AgentManager({ name, secret });
 agent.setup({
 	prompt,
 	api,
@@ -73,31 +88,27 @@ agent.setup({
 	toolsetMode,
 	contextWindow
 });
-	agent.addGenericToolcall('open_link');
-	agent.addGenericToolcall('send_email');
+agent.addGenericToolcall('open_link');
+agent.addGenericToolcall('send_email');
+agent.addGenericToolcall('history_search');
 
+const addTools = (args['tools']) ? args['tools'].split(',') : ['bash'];
+if (addTools.includes('javascript')) {
+	agent.addGenericToolcall('javascript_interpreter');
+}
+if (addTools.includes('bash')) {
+	agent.addGenericToolcall('execute_bash_script');
+}
+if (addTools.includes('ssh')) {
+	agent.addGenericToolcall('execute_remote_script');
+}
 const cliIntro = `
 ${name} ${options.model}.
-- search  ${options.search_parameters.mode}
 - context: ${contextWindow}
 `.trim();
 const description = `
 Guide for this smart online AI Agent:
-- query: Formulate ONE efficient, comprehensive search query in natural language, combining multiple sources/subjects/domains; mention optional sources if needed. Avoid multiple queries—conso
-lidate into a single one.
-- open_link: [URL] — Open in local browser.
-- send_email: Send to [email_address]; Message: [message].
+- query: Formulate ONE efficient, comprehensive search query in natural language, combining multiple sources/subjects/domains; mention optional sources if needed. Avoid multiple queries—consolidate into a single one.
 `.trim();
 
-if (input === '' && serve) {
-	agent.enableServer(name, description, serve);
-}
-if (input !== '') {
-	// Direct input output
-	const res = await agent.directCall(input);
-	console.log(res);
-} else if(connect) {
-	agent.attach('online_agent', description, connect)
-} else {
-	agent.startCli(cliIntro);
-}
+await agent.start(serve, connect, cliIntro, "search_agent", description);