piclaw 0.0.4 → 0.0.6

package/.output/server/_chunks/session.mjs

@@ -1,14 +1,109 @@
 import { o as PI_MODEL, r as GROUPS_DIR, s as PI_PROVIDER, t as AGENT_TIMEOUT, u as SESSIONS_DIR } from "./config.mjs";
 import { t as createLogger } from "./logger.mjs";
-import { a as createCodingTools, i as AuthStorage, n as DefaultResourceLoader, o as SessionManager, r as ModelRegistry, s as SettingsManager, t as createAgentSession } from "../_libs/@mariozechner/pi-coding-agent+[...].mjs";
 import { t as streamBus } from "./stream.mjs";
+import { a as AuthStorage, i as ModelRegistry, l as SessionManager, n as DefaultResourceLoader, o as createCodingTools, t as createAgentSession, u as SettingsManager } from "../_libs/@mariozechner/pi-coding-agent+[...].mjs";
+import { b as Type } from "../_libs/@mariozechner/pi-agent-core+[...].mjs";
+import { n as getNtfyConfig, r as sendNtfyNotification } from "./ntfy.mjs";
 import path from "path";
-import fs from "fs";
+import os from "node:os";
+import fs from "node:fs/promises";
+import fs$1 from "fs";
+var availableCommands;
+async function getSystemInfo() {
+	const info = {
+		os: process.platform,
+		arch: process.arch,
+		nodeVersion: process.versions.node,
+		runtime: _getRuntime(),
+		freeMemory: os.freemem(),
+		totalMemory: os.totalmem(),
+		uptime: os.uptime()
+	};
+	if (process.platform === "linux") {
+		info.linuxDistro = await _getLinuxDistro();
+		info.isDocker = await _isDocker();
+	}
+	info.availableDiskSpace = await _getAvailableDiskSpace();
+	info.availableCommands = availableCommands ??= await _getAvailableCommands();
+	info.processMemory = process.memoryUsage().rss;
+	return info;
+}
+async function getSystemInfoText() {
+	const info = await getSystemInfo();
+	const lines = [];
+	let osLine = `${info.os} ${info.arch}`;
+	if (info.linuxDistro) osLine += ` (${info.linuxDistro})`;
+	if (info.isDocker) osLine += ` [Docker]`;
+	lines.push(`OS: ${osLine}`);
+	if (info.runtime) lines.push(`Runtime: ${info.runtime}`);
+	if (info.freeMemory != null && info.totalMemory != null) {
+		const fmt = (b) => `${(b / 1024 / 1024 / 1024).toFixed(1)}GB`;
+		let memLine = `Memory: ${fmt(info.freeMemory)} free / ${fmt(info.totalMemory)} total`;
+		if (info.processMemory != null) {
+			const mb = (info.processMemory / 1024 / 1024).toFixed(0);
+			memLine += ` (process: ${mb}MB)`;
+		}
+		lines.push(memLine);
+	}
+	if (info.availableDiskSpace != null) lines.push(`Disk: ${(info.availableDiskSpace / 1024 / 1024 / 1024).toFixed(1)}GB available`);
+	return lines.map((l) => `- ${l}`).join("\n");
+}
+function _getRuntime() {
+	if ("Bun" in globalThis) return `bun v${globalThis.Bun.version}`;
+	if ("Deno" in globalThis) return `deno v${globalThis.Deno.version.deno}`;
+	return `node v${process.versions.node}`;
+}
+async function _getLinuxDistro() {
+	try {
+		return (await fs.readFile("/etc/os-release", "utf8")).match(/^PRETTY_NAME="?(.+?)"?\s*$/m)?.[1] ?? null;
+	} catch {
+		return null;
+	}
+}
+async function _isDocker() {
+	try {
+		await fs.access("/.dockerenv");
+		return true;
+	} catch {
+		try {
+			const cgroup = await fs.readFile("/proc/1/cgroup", "utf8");
+			return cgroup.includes("docker") || cgroup.includes("containerd");
+		} catch {
+			return false;
+		}
+	}
+}
+async function _getAvailableCommands() {
+	try {
+		const pathEnv = process.env.PATH;
+		if (!pathEnv) return void 0;
+		const dirs = [...new Set(pathEnv.split(":"))];
+		const commands = /* @__PURE__ */ new Set();
+		await Promise.all(dirs.map(async (dir) => {
+			try {
+				const entries = await fs.readdir(dir);
+				for (const entry of entries) commands.add(entry);
+			} catch {}
+		}));
+		return [...commands].sort();
+	} catch {
+		return;
+	}
+}
+async function _getAvailableDiskSpace() {
+	try {
+		const stats = await fs.statfs("/");
+		return stats.bsize * stats.bavail;
+	} catch {
+		return null;
+	}
+}
 var logger$1 = createLogger("pi");
 function sendPrompt(managed, group, input, onOutput) {
 	return new Promise((resolve) => {
 		const { session } = managed;
 		let fullText = "";
+		let thinkingText = "";
 		let resolved = false;
 		let outputChain = Promise.resolve();
 		const timeout = setTimeout(() => {
@@ -52,19 +147,34 @@ function sendPrompt(managed, group, input, onOutput) {
 					}
 					if (ae.type === "text_end" && "content" in ae && onOutput) {
 						const text = ae.content;
+						const stored = thinkingText ? `<thinking>${thinkingText}</thinking>\n\n${text}` : text;
+						thinkingText = "";
 						outputChain = outputChain.then(async () => {
 							await onOutput({
 								status: "success",
-								result: text,
+								result: stored,
 								newSessionId: session.sessionId
 							});
 							streamBus.emit({
 								type: "text_end",
 								chatJid: jid,
-								content: text
+								content: stored
 							});
 						});
 					}
+					if (ae.type === "thinking_delta" && "delta" in ae) {
+						thinkingText += ae.delta;
+						streamBus.emit({
+							type: "thinking_delta",
+							chatJid: jid,
+							delta: ae.delta
+						});
+					}
+					if (ae.type === "thinking_end" && "content" in ae) streamBus.emit({
+						type: "thinking_end",
+						chatJid: jid,
+						content: ae.content
+					});
 					break;
 				}
 				case "agent_end":
@@ -78,7 +188,9 @@ function sendPrompt(managed, group, input, onOutput) {
 				case "tool_execution_start":
 					logger$1.debug({
 						group: group.name,
-						tool: event.toolName
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						argsPreview: previewForLog(event.args)
 					}, "Tool execution started");
 					streamBus.emit({
 						type: "tool_start",
@@ -86,11 +198,24 @@ function sendPrompt(managed, group, input, onOutput) {
 						toolName: event.toolName
 					});
 					break;
-				case "tool_execution_end":
-					if (event.isError) logger$1.warn({
+				case "tool_execution_update":
+					logger$1.debug({
 						group: group.name,
-						tool: event.toolName
-					}, "Tool execution error");
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						partialResultPreview: previewForLog(event.partialResult)
+					}, "Tool execution update");
+					break;
+				case "tool_execution_end": {
+					const payload = {
+						group: group.name,
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						isError: event.isError,
+						resultPreview: previewForLog(event.result)
+					};
+					if (event.isError) logger$1.warn(payload, "Tool execution error");
+					else logger$1.debug(payload, "Tool execution finished");
 					streamBus.emit({
 						type: "tool_end",
 						chatJid: jid,
@@ -98,6 +223,7 @@ function sendPrompt(managed, group, input, onOutput) {
 						isError: event.isError
 					});
 					break;
+				}
 			}
 		});
 		session.prompt(input.prompt).catch((err) => {
@@ -110,38 +236,117 @@ function sendPrompt(managed, group, input, onOutput) {
 		});
 	});
 }
-function buildSystemPrompt(assistantName, dir) {
-	return `You are ${assistantName}, an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+var baseSystemPrompt = `
+You live in your own OS and help your human with tasks.
 
 Available tools:
 - read: Read file contents
-- bash: Execute bash commands (ls, grep, find, etc.)
-- edit: Make surgical edits to files (find exact text and replace)
-- write: Create or overwrite files
+- bash: Execute shell commands (ls, rg, find, curl, etc.)
+- edit: Make precise text replacements in existing files
+- write: Create or fully overwrite files
+- notify: Send notifications to user
 
-In addition to the tools above, you may have access to other custom tools depending on the project.
+Execution rules:
+- You operate directly in your own OS/workspace environment autonomously; you do not need to ask for permission to run bash commands; users do not know how to run commands you do it for them.
+- Use tools proactively to do the work; do not just describe what should be done.
+- Use bash for operations (searching, building, testing, git-aware inspection).
+- Do not use cat/sed/awk to read files when read is available.
+- Use read to inspect files before editing them.
+- Prefer edit for targeted changes; use write for new files or full rewrites.
+- Use notify tool as a secondary channel to send important info to the user and for anything  you can't send in chat. Do not repeat chat messages in notifications.
+- Summarize results in plain text; do not print summaries via bash commands.
+- Be concise, explicit, and include file paths when referencing changes.
+- Ask a short clarification question when requirements are ambiguous or risky.
+- NEVER say "Use this command", you can just execute commands using bash tool.
+- ALWAYS write necessary info to AGENTS.md, it is your own private memory (do not ask user to do it).
+`;
+async function buildSystemPrompt(ctx) {
+	let prompt = `You are ${ctx.assistantName}, an expert assistant.
 
-Guidelines:
-- Use bash for file operations like ls, rg, find
-- Use read to examine files before editing. You must use this tool instead of cat or sed.
-- Use edit for precise changes (old text must match exactly)
-- Use write only for new files or complete rewrites
-- When summarizing your actions, output plain text directly - do NOT use cat or bash to display what you did
-- Be concise in your responses
-- Show file paths clearly when working with files
+  ${baseSystemPrompt}
 
-Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric",
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		timeZoneName: "short"
-	})}
-Current working directory: ${dir}`;
+Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+Current model name: ${ctx.modelName}
+Current working directory: ${ctx.dir}`;
+	const envInfo = await getSystemInfoText().catch((err) => {
+		logger$1.warn({ err }, "Failed to get system info");
+		return null;
+	});
+	if (envInfo) prompt += `\n\nEnvironment:\n${envInfo}`;
+	return prompt;
 }
+function previewForLog(value, maxLength = 1200) {
+	try {
+		const text = typeof value === "string" ? value : JSON.stringify(value);
+		if (!text) return "";
+		if (text.length <= maxLength) return text;
+		return `${text.slice(0, maxLength)}…(truncated ${text.length - maxLength} chars)`;
+	} catch {
+		return "[unserializable value]";
+	}
+}
+const notifyTool = {
+	name: "notify",
+	label: "Notify",
+	description: [
+		"Send a push notification via ntfy. Supports titles, priority levels, emoji tags,",
+		"clickable URLs, markdown, scheduled delivery, action buttons, and file attachments.",
+		"Requires ntfy to be configured in the Notifications window."
+	].join(" "),
+	parameters: Type.Object({
+		message: Type.String({ description: "Notification body text" }),
+		title: Type.Optional(Type.String({ description: "Notification title" })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal(1),
+			Type.Literal(2),
+			Type.Literal(3),
+			Type.Literal(4),
+			Type.Literal(5)
+		], { description: "1=min, 2=low, 3=default, 4=high, 5=urgent" })),
+		tags: Type.Optional(Type.Array(Type.String(), { description: "Emoji shortcodes or labels, e.g. [\"white_check_mark\",\"robot\"]. See https://docs.ntfy.sh/emojis/" })),
+		click: Type.Optional(Type.String({ description: "URL opened when notification is tapped" })),
+		markdown: Type.Optional(Type.Boolean({ description: "Enable markdown formatting in body (enabled by default)" })),
+		delay: Type.Optional(Type.String({ description: "Schedule delivery: duration (\"30m\",\"2h\"), timestamp, or \"tomorrow 9am\" (cannot be combined with email)" })),
+		actions: Type.Optional(Type.Array(Type.String(), { description: "Action buttons (max 3). Format: \"view, Label, https://...\" or \"http, Label, https://...\"" })),
+		attach: Type.Optional(Type.String({ description: "URL to an external file to attach" })),
+		filename: Type.Optional(Type.String({ description: "Override attachment filename" })),
+		email: Type.Optional(Type.String({ description: "Also forward notification to this email" }))
+	}),
+	async execute(_toolCallId, params) {
+		const p = params;
+		const config = getNtfyConfig();
+		if (!config) return {
+			content: [{
+				type: "text",
+				text: "ntfy is not configured. Set it up in the Notifications window."
+			}],
+			details: {
+				ok: false,
+				reason: "not_configured"
+			}
+		};
+		await sendNtfyNotification(config, {
+			message: p.message,
+			title: p.title,
+			priority: p.priority,
+			tags: p.tags,
+			click: p.click,
+			markdown: p.markdown ?? true,
+			delay: p.delay,
+			actions: p.actions,
+			attach: p.attach,
+			filename: p.filename,
+			email: p.email
+		});
+		return {
+			content: [{
+				type: "text",
+				text: `Notification sent: ${p.title ?? p.message}`
+			}],
+			details: { ok: true }
+		};
+	}
+};
 var logger = createLogger("pi");
 /**
 * Model preference order for fallback resolution.
@@ -162,10 +367,8 @@ const sessions = /* @__PURE__ */ new Map();
 const authStorage = AuthStorage.create();
 const modelRegistry = new ModelRegistry(authStorage);
 async function getOrCreateSession(group, input) {
-	const groupDir = path.join(GROUPS_DIR, group.folder);
-	fs.mkdirSync(path.join(groupDir, "logs"), { recursive: true });
 	const sessionDir = path.join(SESSIONS_DIR, group.folder);
-	fs.mkdirSync(sessionDir, { recursive: true });
+	fs$1.mkdirSync(sessionDir, { recursive: true });
 	let managed = sessions.get(input.chatJid);
 	if (!managed) {
 		managed = await createManagedSession(group, input, sessionDir);
@@ -267,20 +470,26 @@ async function createManagedSession(group, input, sessionDir) {
 			maxRetries: 3
 		}
 	});
+	const systemPrompt = await buildSystemPrompt({
+		assistantName: input.assistantName,
+		dir: groupDir,
+		modelName: `${model?.provider}/${model?.id}`
+	});
 	const resourceLoader = new DefaultResourceLoader({
 		cwd: groupDir,
 		settingsManager,
-		systemPromptOverride: () => buildSystemPrompt(input.assistantName, groupDir)
+		systemPromptOverride: () => systemPrompt
 	});
 	await resourceLoader.reload();
 	const sessionManager = input.sessionId ? SessionManager.continueRecent(groupDir, sessionDir) : SessionManager.create(groupDir, sessionDir);
 	const { session, modelFallbackMessage } = await createAgentSession({
 		cwd: groupDir,
 		model,
-		thinkingLevel: "off",
+		thinkingLevel: group.thinkingLevel || "off",
 		authStorage,
 		modelRegistry,
 		tools: createCodingTools(groupDir),
+		customTools: [notifyTool],
 		resourceLoader,
 		sessionManager,
 		settingsManager
@@ -317,4 +526,4 @@ function findAvailable(available, provider, modelId) {
 function fmtModel(m) {
 	return m ? `${m.provider}/${m.id}` : "none";
 }
-export { resolveModel as a, resolveGroupModel as i, getOrCreateSession as n, sessions as o, modelRegistry as r, sendPrompt as s, authStorage as t };
+export { resolveModel as a, getSystemInfo as c, resolveGroupModel as i, getOrCreateSession as n, sessions as o, modelRegistry as r, sendPrompt as s, authStorage as t };

package/.output/server/_chunks/settings.mjs

@@ -1,6 +1,6 @@
 import { join } from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 /**
 * Read/write ~/.pi/agent/settings.json and models.json
 */

package/.output/server/_chunks/terminal.mjs

@@ -1,31 +1,48 @@
 import { t as createLogger } from "./logger.mjs";
 import crypto from "node:crypto";
-import * as pty from "node-pty";
+import os from "node:os";
+var _isBun = typeof globalThis.Bun !== "undefined";
+async function spawnPty(opts) {
+	if (_isBun) {
+		const { spawnBunPty } = await import("./bun.mjs");
+		return spawnBunPty(opts);
+	}
+	const { spawnNodePty } = await import("./node.mjs");
+	return spawnNodePty(opts);
+}
+async function spawnVirtualPty(...args) {
+	const { spawnVirtualPty: fn } = await import("./virtual.mjs");
+	return fn(...args);
+}
 var logger = createLogger("terminal");
 var MAX_SESSIONS = 5;
 var SESSION_TIMEOUT = 1800 * 1e3;
 var TerminalManager = class {
 	sessions = /* @__PURE__ */ new Map();
-	create(opts) {
+	async create(opts) {
 		if (this.sessions.size >= MAX_SESSIONS) throw new Error(`Max terminal sessions (${MAX_SESSIONS}) reached`);
 		const id = crypto.randomUUID();
 		const cols = opts?.cols ?? 80;
 		const rows = opts?.rows ?? 24;
-		const cwd = opts?.cwd ?? process.cwd();
-		const shell = process.env.SHELL || "/bin/zsh";
-		const env = { TERM: "xterm-256color" };
-		for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
-		env.TERM = "xterm-256color";
-		const term = pty.spawn(shell, [], {
-			name: "xterm-256color",
-			cols,
-			rows,
-			cwd,
-			env
-		});
+		const cwd = opts?.cwd?.startsWith("~") ? os.homedir() + opts.cwd.slice(1) : opts?.cwd ?? process.cwd();
+		let handle;
+		if (opts?.virtual) handle = await spawnVirtualPty({ cwd });
+		else {
+			const shell = process.env.SHELL || "/bin/zsh";
+			const env = { TERM: "xterm-256color" };
+			for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
+			env.TERM = "xterm-256color";
+			handle = await spawnPty({
+				shell,
+				cols,
+				rows,
+				cwd,
+				env
+			});
+		}
 		const session = {
 			id,
-			pty: term,
+			pty: handle,
 			createdAt: Date.now(),
 			lastActivity: Date.now(),
 			cols,
@@ -37,11 +54,11 @@ var TerminalManager = class {
 			timeoutTimer: setTimeout(() => this.kill(id), SESSION_TIMEOUT)
 		};
 		this.sessions.set(id, session);
-		term.onData((data) => {
+		handle.onData((data) => {
 			session.lastActivity = Date.now();
 			for (const listener of session.listeners) listener(data);
 		});
-		term.onExit(() => {
+		handle.onExit(() => {
 			this.cleanup(id);
 		});
 		logger.info({
@@ -90,9 +107,7 @@ var TerminalManager = class {
 	kill(id) {
 		const session = this.sessions.get(id);
 		if (!session) return;
-		try {
-			session.pty.kill();
-		} catch {}
+		session.pty.kill();
 		this.cleanup(id);
 	}
 	list() {

package/.output/server/_chunks/virtual.mjs

@@ -0,0 +1,129 @@
+async function spawnVirtualPty(opts) {
+	const { Bash } = await import("../_libs/_96.mjs");
+	const dataListeners = /* @__PURE__ */ new Set();
+	const exitListeners = /* @__PURE__ */ new Set();
+	let cwd = opts.cwd || "/";
+	let env = {
+		HOME: "/home/user",
+		PATH: "/usr/bin:/bin",
+		...opts.env
+	};
+	let line = "";
+	let alive = true;
+	let busy = false;
+	let pending = "";
+	const bash = new Bash({
+		cwd,
+		env,
+		files: opts.files
+	});
+	function emit(data) {
+		for (const cb of dataListeners) cb(data);
+	}
+	function prompt() {
+		const home = env.HOME || "";
+		emit(`\x1b[1;32m${home && cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd}\x1b[0m $ `);
+	}
+	async function exec(command) {
+		const trimmed = command.trim();
+		if (!trimmed) {
+			prompt();
+			return;
+		}
+		busy = true;
+		try {
+			const result = await bash.exec(trimmed, {
+				cwd,
+				env
+			});
+			if (result.env.PWD) cwd = result.env.PWD;
+			for (const [k, v] of Object.entries(result.env)) env[k] = v;
+			if (result.stdout) {
+				const out = result.stdout.endsWith("\n") ? result.stdout.slice(0, -1) : result.stdout;
+				if (out) emit(out.replaceAll("\n", "\r\n") + "\r\n");
+			}
+			if (result.stderr) {
+				const err = result.stderr.endsWith("\n") ? result.stderr.slice(0, -1) : result.stderr;
+				if (err) emit(`\x1b[31m${err.replaceAll("\n", "\r\n")}\x1b[0m\r\n`);
+			}
+		} catch (err) {
+			emit(`\x1b[31m${err.message}\x1b[0m\r\n`);
+		} finally {
+			busy = false;
+		}
+		prompt();
+		if (pending) {
+			const queued = pending;
+			pending = "";
+			handle.write(queued);
+		}
+	}
+	queueMicrotask(() => prompt());
+	const handle = {
+		write(data) {
+			if (!alive) return;
+			if (busy) {
+				pending += data;
+				return;
+			}
+			for (const ch of data) switch (ch) {
+				case "\r":
+				case "\n": {
+					emit("\r\n");
+					const cmd = line;
+					line = "";
+					exec(cmd);
+					break;
+				}
+				case "":
+				case "\b":
+					if (line.length > 0) {
+						line = line.slice(0, -1);
+						emit("\b \b");
+					}
+					break;
+				case "":
+					line = "";
+					emit("^C\r\n");
+					prompt();
+					break;
+				case "":
+					if (line.length === 0) {
+						alive = false;
+						emit("\r\nexit\r\n");
+						for (const cb of exitListeners) cb();
+						dataListeners.clear();
+						exitListeners.clear();
+					}
+					break;
+				case "\f":
+					emit("\x1B[2J\x1B[H");
+					prompt();
+					emit(line);
+					break;
+				default: if (ch >= " " || ch === "	") {
+					line += ch;
+					emit(ch);
+				}
+			}
+		},
+		resize() {},
+		kill() {
+			if (!alive) return;
+			alive = false;
+			for (const cb of exitListeners) cb();
+			dataListeners.clear();
+			exitListeners.clear();
+		},
+		onData(cb) {
+			dataListeners.add(cb);
+			return () => dataListeners.delete(cb);
+		},
+		onExit(cb) {
+			exitListeners.add(cb);
+			return () => exitListeners.delete(cb);
+		}
+	};
+	return handle;
+}
+export { spawnVirtualPty };

package/.output/server/_jid_.delete.mjs

@@ -1,7 +1,7 @@
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
-import { t as server } from "./_chunks/bootstrap.mjs";
+import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
+import { t as server } from "./_chunks/server.mjs";
 var _jid__delete_default = defineHandler((event) => {
 	const jid = decodeURIComponent(getRouterParam(event, "jid"));
 	server.cleanupChat(jid);

package/.output/server/_jid_.patch.mjs

@@ -1,14 +1,23 @@
 import { a as defineHandler, l as getRouterParam, n as HTTPError } from "./_libs/h3+rou3+srvx.mjs";
 import { t as createLogger } from "./_chunks/logger.mjs";
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
-import { t as server } from "./_chunks/bootstrap.mjs";
+import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
+import { t as server } from "./_chunks/server.mjs";
 var logger = createLogger("api:groups");
 var UPDATABLE_FIELDS = [
 	"name",
 	"trigger",
 	"requiresTrigger",
-	"model"
+	"model",
+	"thinkingLevel"
+];
+var VALID_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
 ];
 var _jid__patch_default = defineHandler(async (event) => {
 	const jid = decodeURIComponent(getRouterParam(event, "jid"));
@@ -48,6 +57,14 @@ var _jid__patch_default = defineHandler(async (event) => {
 		if (val !== void 0 && val !== null && typeof val !== "string") throw new HTTPError("model must be a string or null", { status: 400 });
 		group.model = val ? String(val) : void 0;
 	}
+	const oldThinkingLevel = group.thinkingLevel;
+	if ("thinkingLevel" in body) {
+		const val = body.thinkingLevel;
+		if (val !== void 0 && val !== null) {
+			if (typeof val !== "string" || !VALID_THINKING_LEVELS.includes(val)) throw new HTTPError(`thinkingLevel must be one of: ${VALID_THINKING_LEVELS.join(", ")}`, { status: 400 });
+		}
+		group.thinkingLevel = val === null || val === "off" ? void 0 : val;
+	}
 	server.setRegisteredGroup(jid, group);
 	if (oldModel !== group.model) {
 		server.pi.kill(jid);
@@ -59,6 +76,16 @@ var _jid__patch_default = defineHandler(async (event) => {
 			newModel: group.model
 		}, "Model changed, session killed");
 	}
+	if (oldThinkingLevel !== group.thinkingLevel) {
+		server.pi.kill(jid);
+		const display = group.thinkingLevel || "off";
+		changes.push(`thinkingLevel → ${display}`);
+		logger.info({
+			jid,
+			oldThinkingLevel,
+			newThinkingLevel: group.thinkingLevel
+		}, "Thinking level changed, session killed");
+	}
 	if (changes.length > 0) {
 		server.sendBotMessage(jid, `Config updated: ${changes.join(", ")}`);
 		logger.info({

package/.output/server/_jid_2.delete.mjs

@@ -1,7 +1,7 @@
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
-import { t as server } from "./_chunks/bootstrap.mjs";
+import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
+import { t as server } from "./_chunks/server.mjs";
 var _jid__delete_default = defineHandler((event) => {
 	const jid = decodeURIComponent(getRouterParam(event, "jid"));
 	server.cleanupChat(jid);