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

package/lib/index.js

@@ -1,11 +1,12 @@
 import {request as gpt} from './API/openai.com/reponses/text.js';
-import {request as grok} from './API/x.ai/text.js';
+import {request as xai} from './API/x.ai/responses.js';
 import {request as claude} from './API/anthropic.com/text.js';
 import {request as brave} from './API/brave.com/search.js';
 
 import { env, GLOBAL } from './fafs.js';
 import ToolSet from './ToolSet.js';
 import AgentServer from './AgentServer.js';
+import AgentManager from './AgentManager.js';
 import AgentClient from './AgentClient.js';
 import Session from './Session.js';
 import Prompt from './Prompt.js';
@@ -14,7 +15,7 @@ import Cli from './Cli.js';
 const API = {
 	text:{
 	 gpt,
-	 grok,
+	 xai,
 	 claude
   },
   search: {
@@ -22,6 +23,7 @@ const API = {
   },
 }
 export {
+	AgentManager,
   AgentServer,
   AgentClient,
   Prompt,

package/lib/wsCli.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env -S node
+/*
+ * WebSocket client for a hello-dave server with auto-reconnect and improved structure.
+ * user CLI 
+ */
+import cli from '@j-o-r/cli';
+import { WebSocketClient } from "@j-o-r/apiserver";
+import { SH } from '@j-o-r/sh';
+
+const OPEN = 1; // WebSocket.OPEN
+
+
+/**
+ * Copy text to the clipboard using xclip.
+ * @param {string} text
+ * @returns {Promise<void>}
+ */
+const copyToClipboard = async (text) => {
+	if (typeof text !== 'string') return;
+	if (text === '') text = ' ';
+	const prams = ['-selection', 'clipboard'];
+	await SH`xclip ${prams}`.options({ stdio: 'inherit' }).run(text);
+};
+/**
+* Launch a CLI to an Agent Server
+* @param {string} connectUrl - Websocket server endpoint to connect to
+* @param {string} [secret] - Secret websocket connection key
+*/
+export default (connectUrl, secret = '') => {
+	console.log('START');
+	let ws;
+	let busy = false;
+	let lastMessage = '';
+	const pendingRequests = new Map();
+	if (secret !== '') {
+		secret = Buffer.from(secret).toString('base64');
+	}
+
+	/**
+	 * Connect to the WebSocket server (with handlers).
+	 * Sets up reconnection on close.
+	 */
+	const connect = () => {
+		if (ws && ws.readyState === OPEN) {
+			console.log('Already connected');
+			return;
+		}
+		const url = connectUrl + '?wssrc_id=' + secret;
+		console.log(`Connecting to ${url}`);
+		ws = new WebSocketClient(url);
+
+		ws.onopen = () => {
+			console.log('Connected to server');
+			// Send introduction (no pending request for this)
+			const id = Date.now();
+			ws.send(JSON.stringify({
+				action: 'user_introduction',
+				content: '',
+				id
+			}));
+			cli.focus('user', true);
+		};
+
+		ws.onmessage = (m) => {
+			try {
+				const data = JSON.parse(m.data);
+				const msgId = data.id;
+				if (msgId && pendingRequests.has(msgId)) {
+					const { resolve, timeout } = pendingRequests.get(msgId);
+					clearTimeout(timeout);
+					pendingRequests.delete(msgId);
+					resolve(data);
+				}
+				// Ignore unsolicited messages for now
+			} catch (e) {
+				console.error('Error parsing WebSocket message:', e, m.data);
+			}
+		};
+
+		ws.onclose = (event) => {
+			console.log('Connection closed (reconnecting in 5s):', event.code, event.reason || 'No reason');
+			// Reject all pending requests
+			for (const [id, { reject, timeout }] of pendingRequests) {
+				clearTimeout(timeout);
+				reject(new Error(`Connection closed (${event.code})`));
+				pendingRequests.delete(id);
+			}
+			// Auto-reconnect
+			setTimeout(connect, 5000);
+		};
+
+		ws.onerror = (event) => {
+			console.error('WebSocket error:', event.toString());
+		};
+	};
+
+	/**
+	 * Send a message and await response.
+	 * Handles response actions and UI updates.
+	 * @param {Object} message - Message object (action, content)
+	 * @returns {Promise<Object>} Response data
+	 */
+	const sendMessage = async (message) => {
+		if (!ws || ws.readyState !== OPEN) {
+			throw new Error('WebSocket not connected');
+		}
+
+		const id = Date.now();
+		message.id = id;
+		busy = true;
+		cli.startSpinner();
+
+		const promise = new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				if (pendingRequests.has(id)) {
+					pendingRequests.delete(id);
+					reject(new Error('Request timeout (12 hours)'));
+				}
+			}, 1000 * 60 * 60 * 12); // 12 hours
+			pendingRequests.set(id, { resolve, reject, timeout });
+		});
+
+		try {
+			ws.send(JSON.stringify(message));
+			const response = await promise;
+
+			// Handle specific response actions
+			if (response.action === 'server_response') {
+				cli.focus('assistant');
+				cli.write(response.content);
+				lastMessage = response.content;
+			} else if (response.action === 'server_info') {
+				cli.focus('util');
+				cli.write(response.content);
+			} else if (response.action === 'server_reset') {
+				cli.clear();
+			} else if (response.action === 'server_sessionlist') {
+				const list = response.content;
+				const selected = await cli.select('Select your session: ', list);
+				if (selected && selected !== 'NONE') {
+					await sendMessage({ action: 'user_loadsession', content: selected });
+				}
+			} else if (response.action === 'server_sessionloaded') {
+				cli.clear();
+				const messages = response.content;
+				messages.forEach((msg) => {
+					cli.focus(msg.role);
+					cli.write(msg.content);
+					lastMessage = msg.content;
+				});
+			}
+			// Other actions ignored
+			return response;
+		} catch (e) {
+			console.error('Request error:', e.message);
+		} finally {
+			if (pendingRequests.has(id)) {
+				const { timeout } = pendingRequests.get(id);
+				clearTimeout(timeout);
+				pendingRequests.delete(id);
+			}
+			busy = false;
+			cli.stopSpinner();
+			cli.focus('user', true);
+		}
+	};
+
+	// Register key mappings
+	cli.registerKeyMappings([
+		// ALT-C: Clear screen
+		{
+			name: 'c', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					cli.clear();
+				}
+			}
+		},
+		// ALT-R: Reset session
+		{
+			name: 'r', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_reset', content: '' });
+				}
+			}
+		},
+		// ALT-S: Session list
+		{
+			name: 's', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_sessionlist', content: '' });
+				}
+			}
+		},
+		// ALT-I: Server info
+		{
+			name: 'i', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_info', content: '' });
+				}
+			}
+		},
+		// ALT-M: Copy last message
+		{
+			name: 'm', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy && lastMessage) {
+					await copyToClipboard(lastMessage);
+					cli.focus('util');
+					cli.write('Copied last message to clipboard');
+					cli.focus('user', true);
+				}
+			}
+		},
+		// CTRL-K: Help
+		{
+			name: 'k', ctrl: true, meta: false, shift: false,
+			handler: async () => {
+				cli.focus('util');
+				cli.write(`
+Available keys:
+• ALT-C: Clear screen
+• ALT-R: Reset session
+• ALT-I: Server info
+• ALT-S: List/load sessions
+• ALT-M: Copy last message
+• CTRL-K: Show help
+• CTRL-D: Exit
+`.trim());
+				cli.focus('user', true);
+			}
+		}
+	]);
+
+	// Input handler for user messages
+	cli.inputHandler = async (s) => {
+		if (busy || !s || !s.trim()) {
+			return;
+		}
+		await sendMessage({
+			action: 'user_request',
+			content: s.trim()
+		});
+	};
+
+	// Initialize
+
+	cli.focus('log');
+	cli.write('Connecting... (ALT-I for info, CTRL-K for keys, CTRL-D to exit)');
+
+	connect();
+
+}
+

package/lib/wsIO.js

@@ -0,0 +1,96 @@
+import { WebSocket } from 'ws';
+/*
+* Oneshot direct write response to/from a Agent server
+*/
+/**
+* @typedef {object} wsResponse
+* @property {string} action
+* @property {string} content
+* @property {number} id - message id
+*/
+/**
+* One-shot WebSocket client for hello-dave server using standard 'ws' library.
+* Connects directly to pure WS endpoint (no HTTP upgrade).
+* Sends intro + action, awaits matching response by ID, closes, returns response.
+* 
+* @param {string} connectUrl - Websocket server endpoint to connect to
+* @param {string} [secret] - Secret websocket connection key
+* @param {'user_request'|'user_info'|'user_reset'} action - Action
+* @param {string} [input] - When action is  'user_request' input is the query
+* @returns {Promise<wsResponse>}
+*/
+export default async function wsio(connectUrl, secret = '', action, input = '') {
+	if (!['user_request', 'user_reset', 'user_info'].includes(action)) {
+		throw new Error(`Invalid action: ${action}. Must be one of: user_input, user_reset, user_info`);
+	}
+	if (action === 'user_request' && (!input || typeof input !== 'string' || input.trim() === '')) {
+		throw new Error('Non-empty string input required for "user_input"');
+	}
+
+	let b64secret = '';
+	if (secret !== '') {
+		b64secret = Buffer.from(secret).toString('base64');
+	}
+
+	const url = `${connectUrl}${connectUrl.includes('?') ? '&' : '?'}wssrc_id=${b64secret}`;
+
+	return new Promise((resolve, reject) => {
+		const ws = new WebSocket(url);
+
+		let resolved = false;
+		const TIMEOUT_MS = 30000; // 30s timeout
+		const timeoutId = setTimeout(() => {
+			if (!resolved) {
+				ws.close();
+				reject(new Error('Request timeout (30s)'));
+			}
+		}, TIMEOUT_MS);
+
+		const actionId = Date.now();
+
+		ws.on('open', () => {
+			// Send introduction first (matches wsConnect.js protocol)
+			const introId = Date.now() - 1;
+			ws.send(JSON.stringify({
+				action: 'user_introduction',
+				content: '',
+				id: introId
+			}));
+
+			// Send the action immediately after
+			ws.send(JSON.stringify({
+				action,
+				content: input,
+				id: actionId
+			}));
+		});
+
+		ws.on('message', (data) => {
+			try {
+				const parsed = JSON.parse(data.toString());
+				if (parsed.id === actionId) {
+					clearTimeout(timeoutId);
+					resolved = true;
+					ws.close(1000, 'Request complete');
+					resolve(parsed);
+				}
+			} catch (e) {
+				// Ignore non-JSON or non-matching messages (e.g., intro response)
+			}
+		});
+
+		ws.on('close', (code, reason) => {
+			clearTimeout(timeoutId);
+			if (!resolved) {
+				reject(new Error(`Connection closed (${code}): ${reason || 'Unknown reason'}`));
+			}
+		});
+
+		ws.on('error', (error) => {
+			clearTimeout(timeoutId);
+			if (!resolved) {
+				reject(new Error(`WebSocket error: ${error.message}`));
+			}
+		});
+	});
+}

package/package.json

@@ -1,41 +1,47 @@
 {
   "name": "@j-o-r/hello-dave",
   "type": "module",
-  "version": "0.0.2",
-  "description": "ESM toolkit for building AI agents with unified access to Grok, OpenAI, and Anthropic endpoints",
-  "main": "lib/AgentManager.js",
-  "types": "types/AgentManager.d.ts",
+  "version": "0.0.3",
+  "description": "ESM toolkit for building AI agents with unified access to Grok (XAI), OpenAI, and Anthropic endpoints",
+  "main": "./lib/index.js",
+  "types": "./types/index.d.ts",
+  "typesVersions": {
+    ">4": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
   "bin": {
-    "hdPrompt": "bin/hdPrompt.js",
-    "hdNpm": "bin/hdNpm.js",
-    "hdAsk": "bin/hdAsk.js",
-    "hdCode": "bin/hdCode.js",
-    "hdConnect": "bin/hdConnect.js",
-    "hdInspect": "bin/hdInspect.js",
-    "hdClear": "bin/hdClear.js"
+    "dave": "bin/dave.js",
+    "createAgent": "examples/spawndave.js"
   },
   "scripts": {
-    "hdPrompt": "bin/hdPrompt.js",
-    "hdAsk": "bin/hdAsk.js",
-    "hdCode": "bin/hdCode.js",
-    "hdNpm": "bin/hdNpm.js",
-    "hdConnect": "bin/hdConnect.js",
-    "hdInspect": "bin/hdInspect.js",
-    "hdClear": "bin/hdClear.js",
     "test": "scenarios/grok.js",
     "release": "npm run types && npm pack --pack-destination=release",
     "types": "rm -fr types/* && tsc -p tsc.json",
-    "publish": "npm run release && npm publish --access public"
+    "publish": "npm run release && npm publish --access public",
+    "local": "npm -g uninstall '@j-o-r/hello-dave' && npm install -g .",
+    "link-self": "mkdir -p node_modules/@j-o-r && ln -sf . node_modules/@j-o-r/hello-dave && npm ls @j-o-r/hello-dave",
+    "unlink-self": "rm -rf node_modules/@j-o-r/hello-dave"
   },
   "repository": {
     "type": "git",
     "url": "https://codeberg.org/duin/hello-dave"
   },
   "dependencies": {
-    "@j-o-r/apiserver": "^2.1.5",
+    "@j-o-r/apiserver": "*",
     "@j-o-r/cli": "*",
+    "@j-o-r/sh": "1.1.28",
     "gpt-3-encoder": "*"
   },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./*": "lib/*.js"
+  },
   "author": "Jorrit Duin <j-o-r@duin.work>",
   "bugs": {
     "url": "https://codeberg.org/duin/hello-dave/issues"

package/types/API/openai.com/reponses/text.d.ts

@@ -33,7 +33,7 @@ export type OAOptions = {
     /**
      * - Model version to use.
      */
-    model?: "gpt-4.1" | "GPT-4o" | "o3" | "o3-mini" | "o4-mini" | "o1" | "o3-pro" | undefined;
+    model?: "gpt-5.4" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5-pro" | undefined;
     /**
      * - Reusable prompt string.
      */
@@ -51,6 +51,9 @@ export type OAOptions = {
          */
         summary: "auto" | "concise" | "detailed";
     } | undefined;
+    /**
+     * - Convenience: Adds `{type: "web_search_preview", search_context_size: search}` tool.
+     */
     search?: "low" | "high" | "medium" | undefined;
     /**
      * - Service tier option, default is auto-selected.
@@ -86,9 +89,9 @@ export type OAOptions = {
      */
     tool_choice?: "auto" | undefined;
     /**
-     * =[] Array of tool call objects.
+     * - Array of tool objects: custom function tools (`OAToolCall`) or built-in OpenAI tools (e.g., `{type: "web_search_preview"}`).
      */
-    tools: OAToolCall[];
+    tools?: OpenAITool[] | undefined;
     /**
      * =null An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability.
      */
@@ -126,6 +129,17 @@ export type OAToolCall = {
         required?: string[] | undefined;
     };
 };
+export type OABuiltinTool = {
+    /**
+     * - Type of built-in OpenAI tool (Responses API).
+     */
+    type: "code_interpreter" | "file_search" | "computer" | "web_search";
+    /**
+     * - Context size for `web_search_preview` only.
+     */
+    search_context_size?: "low" | "high" | "medium" | undefined;
+};
+export type OpenAITool = OAToolCall | OABuiltinTool;
 export type OAParameterProperty = {
     /**
      * - The data type of the parameter, e.g., "string".

package/types/API/x.ai/collections.d.ts

@@ -0,0 +1,167 @@
+declare namespace _default {
+    export { create };
+    export { list };
+    export { get };
+    export { status };
+    export { details };
+    export { update };
+    export { del };
+    export { addFileToCollection };
+    export { deleteFileFromCollection };
+    export { searchInCollections };
+    export { getStorage as storage };
+}
+export default _default;
+export type Collection = {
+    /**
+     * - Unique identifier for the collection.
+     */
+    collection_id: string;
+    /**
+     * - Name of the collection.
+     */
+    collection_name: string;
+    /**
+     * - ISO datetime string when the collection was created.
+     */
+    created_at: string;
+    updated_at: string;
+    /**
+     * - Configuration for the indexing model.
+     */
+    index_configuration: {
+        model_name: string;
+    };
+    /**
+     * - Configuration for chunking documents.
+     */
+    chunk_configuration: {
+        tokens_configuration: {
+            max_chunk_size_tokens: number;
+            chunk_overlap_tokens: number;
+            encoding_name: string;
+        };
+        strip_whitespace: boolean;
+        inject_name_into_chunks: boolean;
+    };
+    /**
+     * - Number of documents in the collection.
+     */
+    documents_count: number;
+    /**
+     * - Array of field definitions.
+     */
+    field_definitions: any[];
+};
+export type fileList = {
+    data: File[];
+    pagination_token: string | null;
+};
+export type File = {
+    /**
+     * - File size in bytes.
+     */
+    bytes: number;
+    /**
+     * - Unix timestamp of creation.
+     */
+    created_at: number;
+    /**
+     * - Unix timestamp of expiration, or null.
+     */
+    expires_at: number | null;
+    /**
+     * - Path to the file.
+     */
+    filename: string;
+    /**
+     * - Unique file identifier.
+     */
+    id: string;
+    /**
+     * - Type of object, e.g., 'file'.
+     */
+    object: string;
+    /**
+     * - Purpose of the file.
+     */
+    purpose: string;
+};
+export type SearchResult = {
+    document_id: string;
+    content: string;
+    metadata: Object;
+    score: number;
+};
+/**
+ * Create a collection
+ * @param {string} name
+ * @returns {Promise<string>} collection_id
+ */
+declare function create(name: string): Promise<string>;
+/**
+ * List collections
+ * @returns {Promise<Array<Collection>>}
+ */
+declare function list(): Promise<Array<Collection>>;
+/**
+ * Get collection details
+ * @param {string} id
+ * @returns {Promise<Collection>}
+ */
+declare function get(id: string): Promise<Collection>;
+/**
+ * The status of files in a collection
+ * @param {string} collectionId
+ * @returns {Promise<void>}
+ */
+declare function status(collectionId: string): Promise<void>;
+/**
+ * The status of files in a collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function details(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Update collection collection name
+ * @param {string} id
+ * @param {string} name
+ * @returns {Promise<void>}
+ */
+declare function update(id: string, name: string): Promise<void>;
+/**
+ * Delete collection
+ * @param {string} id
+ * @returns {Promise<void>}
+ */
+declare function del(id: string): Promise<void>;
+/**
+ * Add file to collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function addFileToCollection(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Delete file from collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function deleteFileFromCollection(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Search in collections
+ * @param {string} query
+ * @param {string[]} collectionIds
+ * @param {Object} [options]
+ * @param {string} [options.retrieval_mode] - e.g., 'hybrid'
+ * @returns {Promise<SearchResult[]>}
+ */
+declare function searchInCollections(query: string, collectionIds: string[], options?: {
+    retrieval_mode?: string | undefined;
+}): Promise<SearchResult[]>;
+/**
+* @returns {Promise<Map<string, Collection>>}
+*/
+declare function getStorage(): Promise<Map<string, Collection>>;