@j-o-r/hello-dave 0.0.10 → 0.1.0

package/README.md

@@ -30,6 +30,7 @@ The project emphasizes modular agent management, tool integration (e.g., web sea
 - **Agent Scripts**: Specialized agents for code, docs, npm, todo, readme, memory, and more.
 - **WebSocket Support**: Connect to remote agent servers for interactive or one-shot interactions.
 - **Toolsets**: Built-in tools for search, file I/O, email, and custom toolcalls.
+- **Music Toolsets**: Dedicated Stability AI (Stable Audio 3) and Minimax (Music 2.6/Cover) toolsets for text-to-music, audio transformation, inpainting, covers, lyrics, and more. See [docs/music-toolsets.md](docs/music-toolsets.md) for full details, tools, and agent examples.
 - **Session Management**: Cache history, search sessions, reset, and inspect logs.
 - **ESM-First**: Modern Node.js modules with TypeScript definitions.
 - **Portable Agent Spawning**: `spawn_agent.js` enables creating and deploying agents anywhere (project dirs or fresh `/tmp`). Supports auto-deploy in existing projects (detects `./agents/*.js`), manual code+bash in isolated setups. Tools adapt to CWD for portability. Hybrid modes combine server/client for chaining. See [docs/prompt/spawn_agent.md](docs/prompt/spawn_agent.md) for blueprint and validation.
@@ -63,6 +64,7 @@ The project emphasizes modular agent management, tool integration (e.g., web sea
 - **types/**: TypeScript definitions.
 - **utils/**: Utility scripts (e.g., session management, testing).
 - **docs/**: Additional documentation, including agent blueprints (e.g., [prompt/spawn_agent.md](docs/prompt/spawn_agent.md)) and multi-agent guides (e.g., [multi-agent-clusters.md](docs/multi-agent-clusters.md)).
+  - New: [music-toolsets.md](docs/music-toolsets.md) — Documentation for Stability and Minimax MusicToolsets with usage examples from agents/stability.js and agents/minimax.js.
 - **release/**: Build artifacts.
 
 Other files: `package.json`, `CHANGELOG.md`, `TODO.md`, `LICENSE`.

package/README.md.bak.1779452127

@@ -0,0 +1,240 @@
+# hello-dave
+
+[![License: 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/)
+[![Version: v0.0.8](https://img.shields.io/badge/Version-v0.0.8-green.svg)](https://codeberg.org/duin/hello-dave)
+[![PM2 Compatible](https://img.shields.io/badge/PM2-Compatible-orange.svg)](https://pm2.keymetrics.io/)
+
+## Table of Contents
+
+- [Description](#description)
+- [Features](#features)
+- [Folder Structure](#folder-structure)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Usage Examples](#usage-examples)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Description
+
+**hello-dave** is an ESM (ECMAScript Modules) toolkit for building AI agents with unified access to endpoints from Grok (xAI), OpenAI, and Anthropic. It provides CLI tools for interacting with agents locally or via WebSocket servers, along with pre-built agent scripts for various tasks like code generation, documentation, testing, and more.
+
+The project emphasizes modular agent management, tool integration (e.g., web search, file operations), and session handling with memory and caching. With v0.0.8, enhanced portability allows spawning agents in isolated environments like `/tmp` while maintaining tool functionality relative to the current working directory (CWD).
+
+## Features
+
+- **Unified API Access**: Seamless integration with xAI (Grok), OpenAI, and Anthropic models.
+- **CLI Tools**: `dave` for querying agents, `agentDave` for spawning servers, `codeDave` for code servers.
+- **Agent Scripts**: Specialized agents for code, docs, npm, todo, readme, memory, and more.
+- **WebSocket Support**: Connect to remote agent servers for interactive or one-shot interactions.
+- **Toolsets**: Built-in tools for search, file I/O, email, and custom toolcalls.
+- **Session Management**: Cache history, search sessions, reset, and inspect logs.
+- **ESM-First**: Modern Node.js modules with TypeScript definitions.
+- **Portable Agent Spawning**: `spawn_agent.js` enables creating and deploying agents anywhere (project dirs or fresh `/tmp`). Supports auto-deploy in existing projects (detects `./agents/*.js`), manual code+bash in isolated setups. Tools adapt to CWD for portability. Hybrid modes combine server/client for chaining. See [docs/prompt/spawn_agent.md](docs/prompt/spawn_agent.md) for blueprint and validation.
+- **Multi-Agent Clusters**: PM2-powered CodeServer for scalable, clustered agent deployments (e.g., code_agent + todo_agent). Defaults to port 9000/secret '123'. See [docs/multi-agent-clusters.md](docs/multi-agent-clusters.md) for configuration.
+
+## Folder Structure
+
+- **bin/**: Executables for CLI tools.
+  - `dave.js`: Main CLI for asking agents or connecting to WebSocket servers.
+  - `spawn_agent.js`: Spawns agent instances (binary: `agentDave`).
+  - `codeDave`: Launches code servers (via PM2 clusters). References [docs/multi-agent-clusters.md](docs/multi-agent-clusters.md) for setup and scaling.
+
+- **agents/**: Agent scripts (`*_agent.js`) for specific tasks. These can be run directly with `node agents/<script>.js`.
+  - `ask_agent.js`: General query agent.
+  - `code_agent.js`: Code generation and execution agent (serves as main server in code clusters).
+  - `daisy_agent.js`: Specialized agent (details in script).
+  - `docs_agent.js`: Documentation-focused agent.
+  - `gpt_agent.js`: OpenAI GPT integration agent.
+  - `grok_agent.js`: xAI Grok-specific agent.
+  - `memory_agent.js`: Agent with enhanced memory and context handling.
+  - `npm_agent.js`: NPM package management agent.
+  - `prompt_agent.js`: Prompt engineering and testing agent.
+  - `readme_agent.js`: README.md management agent.
+  - `spawn_agent.js`: Agent spawner (also in bin/). Creates portable CLI/WS agents + PM2 launchers. Validates/tests/deploys to `./agents/<name>.js`. Supports hybrid server/client modes. Portable to `/tmp` (tools follow CWD). Blueprint: [docs/prompt/spawn_agent.md](docs/prompt/spawn_agent.md).
+  - `test_agent.js`: Testing and validation agent.
+  - `todo_agent.js`: TODO list and task management agent.
+  - `codeserver.sh`: Shell script for launching PM2-based code server clusters (uses agents above). See [docs/multi-agent-clusters.md](docs/multi-agent-clusters.md).
+
+- **lib/**: Core library modules (e.g., `index.js`, `wsCli.js`, `wsIO.js`, API integrations).
+- **scenarios/**: Test and example scenarios (e.g., toolset tests, integration scripts).
+- **types/**: TypeScript definitions.
+- **utils/**: Utility scripts (e.g., session management, testing).
+- **docs/**: Additional documentation, including agent blueprints (e.g., [prompt/spawn_agent.md](docs/prompt/spawn_agent.md)) and multi-agent guides (e.g., [multi-agent-clusters.md](docs/multi-agent-clusters.md)).
+- **release/**: Build artifacts.
+
+Other files: `package.json`, `CHANGELOG.md`, `TODO.md`, `LICENSE`.
+
+## Installation
+
+1. **Prerequisites**: Node.js >= 20. PM2 for multi-agent clusters: `npm install -g pm2`.
+
+2. **Local Development**:
+   ```bash
+   git clone https://codeberg.org/duin/hello-dave.git
+   cd hello-dave
+   npm install
+   ```
+
+3. **Global CLI Installation** (for `dave`, `agentDave`, `codeDave`):
+   ```bash
+   npm install -g .
+   # Or link for dev: npm run link-self
+   ```
+
+4. **API Keys**: Set environment variables (e.g., `XAIKEY` for xAI, `OPENAI_API_KEY` for OpenAI).
+
+## Usage
+
+### CLI Tools
+
+- **dave**: Interact with agents locally or remotely.
+  - Local query: `dave --ask "Predict the weather"`
+  - One-shot remote: `echo "Hello" | dave --connect 'ws://127.0.0.1:8080' --secret '123'`
+  - Interactive remote: `dave --connect 'ws://127.0.0.1:8080' --secret '123'`
+  - Other: `dave --list` (sessions), `dave --clear` (cache), `dave --help`.
+
+- **agentDave**: Spawn an agent server (powered by `spawn_agent.js`).
+  ```bash
+  agentDave --serve 8080 --secret '123'  # Starts WebSocket server
+  ```
+
+- **codeDave**: Launch a PM2 code server cluster.
+  ```bash
+  codeDave 8080 --secret '123'  # Or: dave --code 8080 --secret '123'
+  ```
+
+### Running Agents
+
+Run agent scripts directly:
+```bash
+node agents/spawn_agent.js --serve 8080 --secret '123'  # Spawn server
+node agents/code_agent.js --connect 'ws://127.0.0.1:8080' --secret '123'  # Client mode
+```
+
+For full options, see script headers or run with `--help`.
+
+### Programmatic Usage
+
+Import and use in your Node.js app:
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+// Setup and run agent...
+```
+
+### spawn_agent.js Specifics (v0.0.8 Portability Ready)
+
+`spawn_agent.js` (executable as `agentDave`) creates and deploys portable agents in CLI, WebSocket server, client, or **hybrid** modes (server + client for tool chaining). It fetches live prompts from [docs/prompt/spawn_agent.md](docs/prompt/spawn_agent.md) and validates new agents via blueprint (temp files, syntax checks, grep for modes/tools).
+
+- **Modes**:
+  - **Direct (One-Shot)**: Positional input, e.g., `node agents/spawn_agent.js "Create a tester"`.
+  - **Interactive CLI**: No input; runs REPL-like session.
+  - **Server**: `--serve <port>` – Exposes as remote tool (e.g., for other agents to call `spawn_agent`).
+  - **Client**: `--connect <ws_url>` – Connects to remote server for tool access.
+  - **Hybrid**: `--serve <port> --connect <ws_url>` – Serves locally while using remote tools.
+
+- **Portability**:
+  - **In Project**: Auto-deploys to `./agents/<name>.js` if `./agents/*.js` exist (uses existing structure).
+  - **Fresh /tmp**: Manual code generation + bash setup (e.g., `mkdir /tmp/myproj/agents; cd /tmp/myproj; node spawn_agent.js ...`). Tools (e.g., `read_file`) follow CWD, ensuring isolation without fixed paths.
+  - Works in any dir; no repo deps beyond Node.js + npm installs.
+
+- **Custom Tools**: Specify in prompt, e.g., "name=coderev, tools=read_file,web_search,execute_bash_script".
+
+For validation/testing: See blueprint in [docs/prompt/spawn_agent.md](docs/prompt/spawn_agent.md) (includes bash examples like `node agents/NEW_AGENT.js --help` or server connect tests).
+
+### CodeServer & PM2 Multi-Agent (v0.0.8)
+
+CodeServer (via `bin/codeDave` or `agents/codeserver.sh`) launches scalable, PM2-clustered multi-agent environments for collaborative tasks (e.g., code generation + task management). It deploys agents like `code_agent`, `todo_agent`, and `readme_agent` on a WebSocket server, enabling chaining and load balancing.
+
+- **Defaults**: Port 9000, secret '123' (customizable via args).
+- **Prerequisites**: Install PM2 globally (`npm install -g pm2`).
+- **Quickstart**:
+  ```bash
+  codeDave 9000 --secret 123  # Launches PM2 cluster on ws://127.0.0.1:9000/ws
+  pm2 list  # Verify processes (e.g., code_agent, todo_agent instances)
+  echo "task" | bin/dave.js --connect ws://127.0.0.1:9000/ws --secret 123  # One-shot query to cluster
+  ```
+  This starts the cluster, lists running agents, and sends a test task (response routed to available agents).
+
+- **Scaling & Management**: Use PM2 commands (e.g., `pm2 scale <app> 4`, `pm2 stop all`). For ecosystem config, PM2 JSON files, or agent orchestration, see the [full guide in docs/multi-agent-clusters.md](docs/multi-agent-clusters.md).
+
+- **Integration**: Combine with `spawn_agent.js` for dynamic agent addition to clusters (e.g., spawn new agents and connect via `--connect ws://127.0.0.1:9000/ws`).
+
+## Usage Examples
+
+- **Direct Spawn (Project)**:
+  ```bash
+  cd hello-dave  # Or any project with ./agents/
+  node agents/spawn_agent.js "Create code-review agent: name=coderev, desc=Git diff analyzer, tools=read_file,execute_bash_script,web_search"
+  # Deploys to ./agents/coderev_agent.js; test: node agents/coderev_agent.js "Review this diff"
+  ```
+
+- **/tmp Workflow (Portable, Fresh Setup)**:
+  ```bash
+  mkdir -p /tmp/myportable/agents
+  cd /tmp/myportable
+  # Copy or fetch spawn_agent.js (e.g., curl from repo or npm install @j-o-r/hello-dave)
+  npm init -y && npm i @j-o-r/hello-dave @j-o-r/sh
+  node spawn_agent.js "Create todo agent: name=todo, desc=Task manager, tools=read_file,write_file"
+  # Deploys to ./agents/todo_agent.js; tools use /tmp/myportable as CWD
+  node agents/todo_agent.js --serve 8081 --secret abc  # Test server mode
+  ```
+
+- **Hybrid Mode with Custom Tools**:
+  ```bash
+  node agents/spawn_agent.js --serve 8081 --connect ws://127.0.0.1:8080/ws --secret abc "Spawn a docs agent with custom email tool"
+  # Serves on 8081 (exposes new agent), connects to 8080 (gains remote tools like email)
+  # Test: In another term, node agents/spawn_agent.js --connect ws://127.0.0.1:8081/ws --secret abc "Use the new docs agent"
+  ```
+
+- **Spawn a Server**:
+  ```bash
+  node agents/spawn_agent.js --serve 8080 --secret '123'
+  # Then connect: echo "Task" | dave --connect 'ws://127.0.0.1:8080' --secret '123'
+  ```
+
+- **Launch Code Cluster** (includes multiple agents):
+  ```bash
+  node agents/codeserver.sh 9000 '123'  # Or use codeDave 9000 --secret 123
+  # Connects code_agent, todo_agent, readme_agent, etc., to the server on ws://127.0.0.1:9000/ws.
+  # Test: pm2 list; echo "Optimize this code" | dave --connect ws://127.0.0.1:9000/ws --secret 123
+  # For advanced config: See [docs/multi-agent-clusters.md](docs/multi-agent-clusters.md).
+  ```
+
+- **Local Agent Query** (no server):
+  ```bash
+  dave --ask --model 'grok-4-1-fast-reasoning' "Write a function"
+  ```
+
+- **Custom Agent**:
+  ```bash
+  node agents/docs_agent.js --connect 'ws://127.0.0.1:8080' --secret '123'
+  ```
+
+See `scenarios/` for more test scenarios.
+
+## Development
+
+- **Build Types**: `npm run types`
+- **Test**: `npm run tests` (runs `utils/test.sh`)
+- **Release**: `npm run release` then `npm run publish`
+- **Local Linking**: `npm run link-self` / `npm run unlink-self`
+
+Use `git status` and `ls` to inspect changes. Ensure ESM compatibility.
+
+## Contributing
+
+Contributions welcome! Fork the repo, create a branch, and submit a pull request to https://codeberg.org/duin/hello-dave.
+
+- Report bugs: https://codeberg.org/duin/hello-dave/issues
+- Follow Apache-2.0 license.
+
+## License
+
+This project is licensed under the Apache-2.0 License - see the [LICENSE](LICENSE) file for details.
+
+---
+*Repository: https://codeberg.org/duin/hello-dave*
+---

package/TODO.md

@@ -1,13 +1,35 @@
-## TODO (high priority pending)
-(none)
+## High Priority Pending
+- [ ] 2026-05-04: Create simple event-based unified WebSocket architecture. Remove complicated streaming plan. Focus on live reasoning in CLI/WS, unify user/agent client handling in AgentServer.js, make Prompt events broadcast consistently to user WS connections. Make code more readable and logical. Reference: docs/plans/simple-event-driven-websocket.md.
+  - [ ] Review current WebSocket protocol and Prompt event emitters.
+  - [ ] In AgentServer.js: Centralize event listeners for Prompt, add unified broadcast method for user WS, unify user/agent client handling.
+  - [ ] Update lib/wsIO.js for CLI to handle events similarly to WS.
+  - [ ] Refactor code for readability and logical flow.
+  - [ ] Test end-to-end: Event flow from Prompt to user display in CLI and WS.
+  - [ ] Update docs/websocket-protocol.md with new architecture.
 
-## In Progress
-(none)
+- [ ] 2026-05-04: Implement unified lib/Agent.js that treats users and agents symmetrically. Key rules: No 'final response' concept. Use Prompt 'ready' event as completion signal. Agents can send 'function_call' requests to user connections (user acts as expert/tool). Update message protocol to be fully event-driven with 'ready' as end marker. Reference: docs/plans/unified-agent-architecture.md.
+  - [ ] Review current Agent.js, AgentServer.js, and Prompt event system.
+  - [ ] Refactor lib/Agent.js to unify user and agent handling: shared methods for event emission, listening, and protocol adherence.
+  - [ ] Integrate Prompt 'ready' event as the primary completion hook across agents and user interactions.
+  - [ ] Add support for agents to emit 'function_call' events to user WS connections.
+  - [ ] Update message protocol: Define event types, ensure 'ready' is broadcast consistently.
+  - [ ] Test symmetry: Verify bidirectional flows (agent-to-user function calls, user-to-agent events) in CLI/WS.
+  - [ ] Document in docs/websocket-protocol.md and update any related docs.
 
-## Later (future tasks)
-(none)
+## Prompt & Agent Quality (High Priority)
+- [ ] 2026-04-25: Review all prompts (in agents, spawn_agent, memory protocol, etc.) to prevent over-complicating implementations by adding unrequested requirements (e.g. backward compatibility when user explicitly says the project is BETA v0.0.x and does not need it).
+
+## Multi-modal
+- [ ] 2026-04-25: Implement multi-modal (audio, images, video) capabilities to the CLI.
+
+## Agent Improvements
+- [ ] 2026-04-25: Teach/instruct the spawn_agent to test and improve agents in a 'server' setting.
+
+## Input Handling
+- [ ] 2026-04-25: Create a 'smart' pre-evaluation agent that assesses user input for clarity before the main agent starts work. It should check: Is the task clear? Are the necessary tools present? Guess context from previous messages if input seems incomplete (e.g. accidental early enter).
+
+## API Capabilities
+- [ ] 2026-04-25: Ensure 'hello-dave' is fully capable of implementing/improving other APIs following the exact structure and patterns of this project (tools, agents, memory protocol, etc.).
 
 ## Done
 (none - all archived to docs/todo-archive-v0.1.0.md on 2026-04-24)
-
-Archive notes: All tasks completed and archived as of 2026-04-24. Previous archives: docs/todo-archive-v0.0.9.md (2026-04-20), docs/todo-archive-v0.0.8.md (2026-04-15), docs/todo-archive.md (2026-04-13), docs/todo-archive-infra-2026-04-21.md (2026-04-21).

package/agents/code_agent.js

@@ -24,7 +24,7 @@ if (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.20-reasoning';
+	options.model = args['model'] || 'grok-4.3';
 }
 // if (args['temperature']) {
 	options.temperature = 0.2;
@@ -37,11 +37,11 @@ if (args['top_p']) {
 }
 // const reasoning = args['reasoning'] ? args['reasoning'] : 'medium';
 // if (reasoning) {
-// 	options.reasoning = {
-// 		// @ts-ignore
-// 		effort:reasoning,
-// 		summary: 'auto'
-// 	}
+options.reasoning = {
+ 		// @ts-ignore
+ 		effort:'high',
+ 		summary: 'auto'
+ 	}
 // }
 const toolsetMode = 'auto';
 const contextWindow = args['context'] ? parseInt(args['context']) : 2565000;

package/agents/daisy_agent.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { AgentManager } from '@j-o-r/hello-dave';
+import { AgentManager, API, CdnToolset } from '@j-o-r/hello-dave';
+import * as test from '@j-o-r/hello-dave';
 import { parseArgs } from '@j-o-r/sh';
 
 const name = 'daisy_agent';
@@ -101,10 +102,11 @@ const tool_call_name = 'daisy_agent';
 const tool_call_description = `
 Daisy Music Assistant:
 - "Lyrics for [theme]" → Generate lyrics.
-- "Suno prompt: [style]" → Optimized Suno prompt.
+- "Music minimax prompt: [style]" → Optimized prompt.
 - "ffmpeg [task] on file.wav" → Bash script to run.
 - web_search: Research chords/lyrics.
 - execute_bash_script: Processes your local files safely.
+- Create music 
 `.trim();
 
 const prompt = `
@@ -112,7 +114,7 @@ You are ${name}, a helpful music creation and editing assistant for the user's c
 
 Core expertise:
 - Generate lyrics: Creative, structured (verses, chorus), themed, rhyming.
-- Suno AI prompts: Detailed, vivid descriptions (genre, mood, instruments, structure, vocals).
+- niMAx 2.6 AI prompts: Detailed, vivid descriptions (genre, mood, instruments, structure, vocals).
 - Local audio editing: Use execute_bash_script with ffmpeg/sox commands. Provide exact bash snippets first, confirm before running. Examples:
   * Trim: ffmpeg -i input.mp3 -ss 00:00:30 -t 00:01:00 output.mp3
   * Concat: echo "file 'a.mp3'" > list.txt; ffmpeg -f concat -i list.txt out.mp3
@@ -129,7 +131,7 @@ Behavior:
 - Output ready-to-copy bash for ffmpeg/sox.
 - List files if unclear: Use ls *.wav *.mp3 etc. via bash.
 
-Current env: Ubuntu, ffmpeg & sox installed, cwd: /home/jd/devpri/js/hello-dave
+Current env: Ubuntu, ffmpeg & sox installed
 
 Respond concisely but completely. Use markdown for code/lyrics/prompts.
 `.trim();
@@ -143,9 +145,10 @@ agent.setup({
 	contextWindow
 });
 const toolset = agent.getToolset();
+toolset?.borrow(API.minimax.musicToolset);
+toolset?.borrow(CdnToolset);
 if (toolset) {
 	agent.addGenericToolcall('open_link');
-	agent.addGenericToolcall('send_email');
 	agent.addGenericToolcall('execute_bash_script');
 	agent.addGenericToolcall('read_file');
 	agent.addGenericToolcall('write_file');
@@ -156,7 +159,7 @@ ${name} ${options.model} ready! (temp: ${options.temperature}, context: ${contex
 
 Ask me to:
 - Write lyrics
-- Craft Suno prompts
+- Craft Music prompts
 - Edit audio: "fade out my track.mp3" → I'll give ffmpeg cmd
 Type /help for more.
 ${tool_call_name}
@@ -167,4 +170,4 @@ if (input) {
 	console.log(RES);
 } else {
 	await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);
-}
+}

package/agents/minimax.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { AgentManager, API, CdnToolset } from '@j-o-r/hello-dave';
+import * as test from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'minimaxi';
+const api = 'xai';
+let secret = '';
+
+const args = parseArgs();
+
+let input;
+if (args._.length === 1 && typeof args._[0] === 'string' && args._[0].trim() !== '') {
+	input = args._[0].trim();
+}
+
+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/responses.js').XAIOptions} */
+const options = { tools: [] };
+options.tools.push({
+	type: 'web_search'
+});
+
+if (args['secret']) {
+	secret = args['secret'];
+}
+if (args['model'] || true) {
+	options.model = args['model'] || 'grok-4-fast-reasoning';
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+} else {
+	options.temperature = 0.8;
+}
+if (args['tokens']) {
+	options.max_output_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+const reasoning = true;
+if (reasoning) {
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
+}
+const toolsetMode = 'auto';
+const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
+
+function printHelp() {
+	console.log(`
+'${name} --help' You are looking at it.
+
+## USAGE MODES:
+
+### 1. Direct Call (One-Shot, Positional ONLY):
+./agents/${name}.js "Generate lyrics for pop song" [--options]
+
+### 2. Interactive CLI (no positional arg):
+./agents/${name}.js [--options]
+
+### 3. WS Server (no positional arg):
+./agents/${name}.js --serve 8080 [--secret mysecret] [--options]
+
+### 4. WS Client (no positional arg):
+./agents/${name}.js --connect ws://127.0.0.1:8080/ws --secret mysecret [--options]
+
+### 5. Hybrid (Server + Client, no positional arg):
+./agents/${name}.js --serve 8081 --connect ws://other:8080/ws [--secret ...] [--options]
+
+## SERVER OPTIONS EXPLAINED:
+--serve [port]: Starts WebSocket SERVER at ws://127.0.0.1:[port]/ws. Allows other agents (--connect) to connect and use this agent as a remote TOOL (e.g., 'daisy_agent'). Runs indefinitely until Ctrl+C.
+
+--connect [ws_url]: Connects as CLIENT to remote WS server at [ws_url] (e.g., ws://127.0.0.1:8080/ws). Gains access to remote agent's tools. Interactive CLI available.
+
+--secret [string]: SHARED AUTH TOKEN (min 3 chars). SERVER rejects clients without matching --secret. CLIENTS must provide server's secret to connect. Use same secret for chains.
+
+Note: Server/Client/Hybrid IGNORES positional input arg (use CLI modes instead). Hybrid: This agent serves AND uses remote tools.
+
+## OPTIONS:
+--model [grok-4-fast-reasoning|...] (default: grok-4-fast-reasoning)
+--temperature [float] (-2 to +2, default 0.8 for creativity)
+--tokens [number] (max output tokens)
+--top_p [float]
+--context [number] (default: 1900000)
+
+## SERVER TOOLS (when no input):
+Exposes as 'daisy_agent' tool for chaining.
+`);
+	process.exit();
+}
+
+if (help) {
+	printHelp();
+}
+
+const tool_call_name = 'daisy_agent';
+const tool_call_description = `
+Daisy Music Assistant:
+- "Lyrics for [theme]" → Generate lyrics.
+- "Music minimax prompt: [style]" → Optimized prompt.
+- "ffmpeg [task] on file.wav" → Bash script to run.
+- web_search: Research chords/lyrics.
+- execute_bash_script: Processes your local files safely.
+- Create music 
+`.trim();
+
+const prompt = `
+You are ${name}, a helpful music creation and editing assistant for the user's computer.
+
+Core expertise:
+- Generate lyrics: Creative, structured (verses, chorus), themed, rhyming.
+- niMAx 2.6 AI prompts: Detailed, vivid descriptions (genre, mood, instruments, structure, vocals).
+- Local audio editing: Use execute_bash_script with ffmpeg/sox commands. Provide exact bash snippets first, confirm before running. Examples:
+  * Trim: ffmpeg -i input.mp3 -ss 00:00:30 -t 00:01:00 output.mp3
+  * Concat: echo "file 'a.mp3'" > list.txt; ffmpeg -f concat -i list.txt out.mp3
+  * Sox effects: sox input.wav output.wav fade 0 3 2 norm
+  * Convert: ffmpeg -i video.mp4 audio.aac
+- Music theory: Chords, scales, BPM, EQ tips.
+- Workflows: Step-by-step for mixing, mastering, layering tracks.
+
+Behavior:
+- Be creative & enthusiastic!
+- Step-by-step: Explain, provide code, suggest files in current dir.
+- Safety: Quote bash commands; ask confirmation for destructive ops (e.g., overwrite).
+- Use web_search for inspiration/lyrics if needed.
+- Output ready-to-copy bash for ffmpeg/sox.
+- List files if unclear: Use ls *.wav *.mp3 etc. via bash.
+
+Current env: Ubuntu, ffmpeg & sox installed
+
+Respond concisely but completely. Use markdown for code/lyrics/prompts.
+`.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+const toolset = agent.getToolset();
+toolset?.borrow(API.minimax.musicToolset);
+toolset?.borrow(CdnToolset);
+if (toolset) {
+	agent.addGenericToolcall('open_link');
+	agent.addGenericToolcall('execute_bash_script');
+	agent.addGenericToolcall('read_file');
+	agent.addGenericToolcall('write_file');
+}
+
+const cliIntro = `
+${name} ${options.model} ready! (temp: ${options.temperature}, context: ${contextWindow})
+
+Ask me to:
+- Write lyrics
+- Craft Music prompts
+- Edit audio: "fade out my track.mp3" → I'll give ffmpeg cmd
+Type /help for more.
+${tool_call_name}
+`.trim();
+
+if (input) {
+	const RES = await agent.directCall(input);
+	console.log(RES);
+} else {
+	await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);
+}