hyperclaw 5.4.0 → 5.4.1

package/dist/src-C52A3OwC.js

@@ -0,0 +1,301 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region packages/acp/src/server.ts
+var ACPServer = class {
+	sessions = /* @__PURE__ */ new Map();
+	initialized = false;
+	sendUpdate;
+	cancelCurrent = null;
+	constructor(sendUpdate) {
+		this.sendUpdate = sendUpdate;
+	}
+	sendResponse(id, result, error) {
+		const msg = {
+			jsonrpc: "2.0",
+			id,
+			...error ? { error } : { result: result ?? null }
+		};
+		this.write(JSON.stringify(msg));
+	}
+	write(raw) {
+		const buf = Buffer.from(raw, "utf8");
+		process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`, "utf8");
+		process.stdout.write(buf, "utf8");
+	}
+	async handleInitialize(params) {
+		this.initialized = true;
+		return {
+			protocolVersion: params.protocolVersion ?? 1,
+			agentCapabilities: {
+				loadSession: true,
+				promptCapabilities: {
+					image: true,
+					audio: false,
+					embeddedContext: true
+				},
+				mcp: {
+					http: true,
+					sse: false
+				}
+			},
+			agentInfo: {
+				name: "hyperclaw",
+				title: "HyperClaw",
+				version: "5.4.0"
+			},
+			authMethods: []
+		};
+	}
+	async handleSessionNew(params) {
+		const id = `sess_${crypto.default.randomBytes(8).toString("hex")}`;
+		const cwd = params.cwd ? path.default.resolve(params.cwd) : process.cwd();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.sessions.set(id, {
+			id,
+			cwd,
+			transcript: [],
+			created: now,
+			lastActive: now
+		});
+		return { sessionId: id };
+	}
+	async handleSessionLoad(params) {
+		const sess = this.sessions.get(params.sessionId);
+		if (!sess) {
+			const { ACPThreadManager } = await Promise.resolve().then(() => require("./src-DTft7Qvt.js"));
+			const mgr = new ACPThreadManager();
+			const threadId = params.sessionId.startsWith("sess_") ? params.sessionId.slice(5) : params.sessionId;
+			const thread = await mgr.get(threadId);
+			if (!thread) throw new Error(`Session not found: ${params.sessionId}`);
+			const cwd = params.cwd ? path.default.resolve(params.cwd) : thread.workspace || process.cwd();
+			const transcript = thread.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+				role: m.role,
+				content: m.content
+			}));
+			const sess2 = {
+				id: params.sessionId,
+				cwd,
+				transcript,
+				created: thread.createdAt,
+				lastActive: thread.lastActiveAt
+			};
+			this.sessions.set(params.sessionId, sess2);
+			for (const t of transcript) this.sendUpdate({
+				sessionId: params.sessionId,
+				update: {
+					sessionUpdate: t.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+					content: {
+						type: "text",
+						text: t.content
+					}
+				}
+			});
+			return;
+		}
+		for (const t of sess.transcript) this.sendUpdate({
+			sessionId: params.sessionId,
+			update: {
+				sessionUpdate: t.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+				content: {
+					type: "text",
+					text: t.content
+				}
+			}
+		});
+	}
+	async handleSessionPrompt(params) {
+		const sess = this.sessions.get(params.sessionId);
+		if (!sess) throw new Error(`Session not found: ${params.sessionId}`);
+		const userText = params.prompt.map((p) => p.type === "text" ? p.text : p.type === "resource" ? p.resource.text ?? "" : "").filter(Boolean).join("\n");
+		if (!userText.trim()) throw new Error("Empty prompt");
+		sess.transcript.push({
+			role: "user",
+			content: userText
+		});
+		sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+		const abortController = new AbortController();
+		this.cancelCurrent = () => abortController.abort();
+		let stopReason = "end_turn";
+		try {
+			const { runAgentEngine } = await Promise.resolve().then(() => require("./src-DTft7Qvt.js"));
+			const toolCallIds = /* @__PURE__ */ new Map();
+			const result = await runAgentEngine(userText, {
+				sessionId: params.sessionId,
+				source: "acp",
+				elevated: true,
+				transcript: sess.transcript.slice(0, -1),
+				workspace: sess.cwd,
+				modelOverride: void 0,
+				getTranscript: async () => sess.transcript.slice(0, -1),
+				appendTranscript: (key, role, content) => {
+					sess.transcript.push({
+						role,
+						content
+					});
+					sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+				},
+				onToken: (token) => {
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "agent_message_chunk",
+							content: {
+								type: "text",
+								text: token
+							}
+						}
+					});
+				},
+				onThinking: (thought) => {
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "thought_chunk",
+							content: {
+								type: "text",
+								text: thought
+							}
+						}
+					});
+				},
+				onToolCall: (name, input) => {
+					const id = `call_${crypto.default.randomBytes(4).toString("hex")}`;
+					toolCallIds.set(name, id);
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "tool_call",
+							toolCallId: id,
+							title: name,
+							kind: "other",
+							status: "pending"
+						}
+					});
+				},
+				onToolResult: (name) => {
+					const id = toolCallIds.get(name);
+					if (id) this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "tool_call_update",
+							toolCallId: id,
+							status: "completed"
+						}
+					});
+				}
+			});
+			if (result.error === "cancelled") stopReason = "cancelled";
+			sess.transcript.push({
+				role: "assistant",
+				content: result.text || ""
+			});
+			sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+		} catch (e) {
+			const err = e;
+			if (err?.name === "AbortError" || err?.message?.includes("abort")) stopReason = "cancelled";
+			else throw e;
+		} finally {
+			this.cancelCurrent = null;
+		}
+		return { stopReason };
+	}
+	handleSessionCancel(params) {
+		if (this.cancelCurrent) this.cancelCurrent();
+	}
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	async dispatch(req) {
+		const { id, method, params = {} } = req;
+		if (!this.initialized && method !== "initialize") {
+			this.sendResponse(id, void 0, {
+				code: -32002,
+				message: "Not initialized"
+			});
+			return;
+		}
+		try {
+			let result;
+			switch (method) {
+				case "initialize":
+					result = await this.handleInitialize(params);
+					break;
+				case "session/new":
+					result = await this.handleSessionNew(params);
+					break;
+				case "session/load":
+					result = await this.handleSessionLoad(params);
+					break;
+				case "session/prompt":
+					result = await this.handleSessionPrompt(params);
+					break;
+				case "session/cancel":
+					this.handleSessionCancel(params);
+					result = null;
+					break;
+				default:
+					this.sendResponse(id, void 0, {
+						code: -32601,
+						message: `Method not found: ${method}`
+					});
+					return;
+			}
+			if (method !== "session/cancel") this.sendResponse(id, result);
+		} catch (e) {
+			const err = e;
+			this.sendResponse(id, void 0, {
+				code: -32603,
+				message: err?.message ?? "Internal error",
+				data: { stack: err?.stack }
+			});
+		}
+	}
+};
+/**
+
+* Run ACP server on stdio (Content-Length delimited JSON-RPC).
+
+*/
+async function runACPStdio() {
+	const sendUpdate = (params) => {
+		const msg = {
+			jsonrpc: "2.0",
+			method: "session/update",
+			params
+		};
+		const raw = JSON.stringify(msg);
+		const buf = Buffer.from(raw, "utf8");
+		process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`, "utf8");
+		process.stdout.write(buf, "utf8");
+	};
+	const server = new ACPServer(sendUpdate);
+	let buffer = "";
+	process.stdin.setEncoding("utf8");
+	process.stdin.on("data", (chunk) => {
+		buffer += chunk;
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) break;
+			const headers = buffer.slice(0, headerEnd);
+			const bodyStart = headerEnd + 4;
+			const contentLen = /Content-Length:\s*(\d+)/i.exec(headers)?.[1];
+			if (!contentLen) {
+				buffer = buffer.slice(bodyStart);
+				continue;
+			}
+			const len = parseInt(contentLen, 10);
+			if (buffer.length < bodyStart + len) break;
+			const body = buffer.slice(bodyStart, bodyStart + len);
+			buffer = buffer.slice(bodyStart + len);
+			try {
+				const req = JSON.parse(body);
+				server.dispatch(req);
+			} catch {}
+		}
+	});
+}
+
+//#endregion
+exports.runACPStdio = runACPStdio;

package/dist/src-C8cbfjat.js

@@ -0,0 +1,173 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region packages/memory-lancedb/src/embedder.ts
+/** Create embedder from API key. Default: OpenAI. Use provider: 'gemini' for gemini-embedding-2-preview. */
+async function createEmbedder(apiKeyOrOpts) {
+	const opts = typeof apiKeyOrOpts === "string" ? { apiKey: apiKeyOrOpts } : apiKeyOrOpts ?? {};
+	const apiKey = opts.apiKey;
+	const provider = opts.provider ?? "openai";
+	if (provider === "gemini" && apiKey) return createGeminiEmbedder(apiKey);
+	if (apiKey) try {
+		const OpenAI = (await Promise.resolve().then(() => require("./openai-CrdtuLxw.js"))).default;
+		const client = new OpenAI({ apiKey });
+		return async (texts) => {
+			const res = await client.embeddings.create({
+				model: "text-embedding-3-small",
+				input: texts
+			});
+			return res.data.sort((a, b) => (a.index ?? 0) - (b.index ?? 0)).map((d) => d.embedding);
+		};
+	} catch {}
+	const dims = 1536;
+	return async (texts) => texts.map(() => new Array(dims).fill(0));
+}
+/** Gemini embedding via gemini-embedding-2-preview — for memory search (vector DB). */
+async function createGeminiEmbedder(apiKey) {
+	const model = "models/gemini-embedding-2-preview";
+	const base = "https://generativelanguage.googleapis.com/v1beta";
+	return async (texts) => {
+		const results = [];
+		for (let i = 0; i < texts.length; i++) {
+			const res = await fetch(`${base}/${model}:embedContent?key=${encodeURIComponent(apiKey)}`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					model,
+					content: { parts: [{ text: texts[i] }] },
+					taskType: "RETRIEVAL_DOCUMENT"
+				})
+			});
+			if (!res.ok) {
+				const err = await res.text();
+				throw new Error(`Gemini embed failed: ${res.status} ${err}`);
+			}
+			const j = await res.json();
+			const vec = j.embedding?.values;
+			if (!Array.isArray(vec)) throw new Error("Gemini embed: missing embedding.values");
+			results.push(vec);
+		}
+		return results;
+	};
+}
+
+//#endregion
+//#region packages/memory-lancedb/src/service.ts
+var VectorMemoryService = class {
+	store;
+	config;
+	_embedder = null;
+	constructor(config) {
+		this.config = config;
+		this.store = new VectorMemoryStore({ dbPath: config.dbPath });
+	}
+	async init() {
+		await this.store.init();
+		const provider = this.config.embeddingProvider ?? "openai";
+		const apiKey = this.config.apiKey ?? (provider === "gemini" ? process.env.GOOGLE_AI_API_KEY : process.env.OPENAI_API_KEY);
+		this._embedder = await createEmbedder({
+			apiKey,
+			provider
+		});
+	}
+	async getEmbedder() {
+		if (!this._embedder) await this.init();
+		return this._embedder;
+	}
+	async addMemory(text, category, sessionId) {
+		const embedder = await this.getEmbedder();
+		const vectors = await embedder([text]);
+		const embedding = vectors[0];
+		const item = {
+			id: (0, crypto.randomUUID)(),
+			text,
+			category,
+			sessionId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			embedding
+		};
+		await this.store.add([item]);
+	}
+	async search(query, limit = 10) {
+		const embedder = await this.getEmbedder();
+		const [queryEmbedding] = await embedder([query]);
+		return this.store.search(queryEmbedding, limit);
+	}
+	/** Add image to multimodal memory (requires Gemini embedding provider). */
+	async addImage(imagePath, caption) {
+		await this.init();
+		if (this.config.embeddingProvider !== "gemini") throw new Error("Multimodal memory (image) requires embeddingProvider: \"gemini\"");
+		const { createGeminiMultimodalEmbedder, addImageToMemory } = await Promise.resolve().then(() => require("./multimodal-zZdwqISl.js"));
+		const apiKey = this.config.apiKey ?? process.env.GOOGLE_AI_API_KEY;
+		if (!apiKey) throw new Error("GOOGLE_AI_API_KEY required for multimodal memory");
+		const embedder = createGeminiMultimodalEmbedder(apiKey);
+		await addImageToMemory(this.store, embedder, imagePath, caption);
+	}
+	/** Add audio to multimodal memory (requires Gemini embedding provider). */
+	async addAudio(audioPath, transcript) {
+		await this.init();
+		if (this.config.embeddingProvider !== "gemini") throw new Error("Multimodal memory (audio) requires embeddingProvider: \"gemini\"");
+		const { createGeminiMultimodalEmbedder, addAudioToMemory } = await Promise.resolve().then(() => require("./multimodal-zZdwqISl.js"));
+		const apiKey = this.config.apiKey ?? process.env.GOOGLE_AI_API_KEY;
+		if (!apiKey) throw new Error("GOOGLE_AI_API_KEY required for multimodal memory");
+		const embedder = createGeminiMultimodalEmbedder(apiKey);
+		await addAudioToMemory(this.store, embedder, audioPath, transcript);
+	}
+};
+
+//#endregion
+//#region packages/memory-lancedb/src/index.ts
+var VectorMemoryStore = class {
+	dbPath;
+	tableName;
+	db = null;
+	table = null;
+	constructor(config) {
+		this.dbPath = config.dbPath;
+		this.tableName = config.tableName ?? "hyperclaw_memory";
+	}
+	async init() {
+		const lancedb = await Promise.resolve().then(() => require_chunk.__toDynamicImportESM()(require("./dist-B1qvBUax.js"))).catch(() => null);
+		if (!lancedb) throw new Error("vectordb not installed. Run: npm install vectordb");
+		await fs_extra.default.ensureDir(path.default.dirname(this.dbPath));
+		this.db = await lancedb.connect(this.dbPath);
+		try {
+			this.table = await this.db.openTable(this.tableName);
+		} catch {
+			this.table = null;
+		}
+	}
+	/** Add memory items with pre-computed embeddings */
+	async add(items) {
+		if (!this.db) await this.init();
+		const rows = items.map(({ embedding,...rest }) => ({
+			vector: embedding,
+			...rest
+		}));
+		if (this.table) await this.table.add(rows);
+		else this.table = await this.db.createTable(this.tableName, rows);
+	}
+	/** Semantic search — pass query embedding, returns top-k similar items */
+	async search(queryEmbedding, limit = 10) {
+		if (!this.db || !this.table) return [];
+		const results = await this.table.search(queryEmbedding).limit(limit).execute();
+		return (results || []).map((r) => ({
+			id: r.id,
+			text: r.text,
+			category: r.category,
+			sessionId: r.sessionId,
+			timestamp: r.timestamp
+		}));
+	}
+	async close() {
+		this.db = null;
+		this.table = null;
+	}
+};
+
+//#endregion
+exports.VectorMemoryService = VectorMemoryService;
+exports.VectorMemoryStore = VectorMemoryStore;
+exports.createEmbedder = createEmbedder;