@tekmidian/pai 0.36.1 → 0.37.0

package/dist/daemon-mcp/index.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { t as PaiClient } from "../ipc-client-BmypMNYk.mjs";
 import { o as loadConfig } from "../config-B64vFg14.mjs";
+import { C as loadStatus, D as workersLogDir, E as ledgerPath, a as setRole, c as useProvider, d as replayOutput, i as setProviderEnabled, k as readWorkersSection, m as testProvider, n as describeProviders, o as setWorkersEnabled, p as runWorker, r as removeProvider, s as unsetRole, t as addProvider, u as psOutput, v as sayToWorker, w as ledgerSummary } from "../providers-sXcK5bDZ.mjs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -1406,6 +1407,97 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -2614,6 +2706,39 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$1(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json.patternProperties = {};
+		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$1(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$1(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+		if (validKeyValues.length > 0) json.required = validKeyValues;
+	}
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$1(def.innerType, ctx, params);
@@ -3047,6 +3172,21 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -3299,6 +3439,7 @@ Fetch the full skill instructions with: prompts/get { name: "<skill-name>" }
 | what's emerging, find patterns in vault | vault-emerge |
 | find orphans, orphaned notes | vault-orphans |
 | trace idea, how did X evolve | vault-trace |
+| run a worker, check workers, worker providers | worker |
 
 ### Reference Resources
 
@@ -4377,6 +4518,48 @@ Otherwise the open items live only in a session note nobody re-reads, which is t
 `
 };
 
+//#endregion
+//#region src/daemon-mcp/prompts/worker.ts
+const worker = {
+	description: "Run, watch and route subagent workers on configured providers",
+	content: `## Worker Skill
+
+USE WHEN delegating subagent work, checking on running workers, or managing worker providers.
+
+### Delegating
+
+The Agent tool is denied when workers are on — delegate with Bash instead:
+
+\`\`\`
+pai worker run --label "short task label" --role research \\
+  -p '<full, self-contained task spec>' \\
+  --allowedTools 'Read,Edit,Write,Bash,Grep,Glob' --output-format json
+\`\`\`
+
+- Always run in background (run_in_background: true) and with a timeout.
+- Roles: implement (default quality), research (web: add WebSearch,WebFetch), spotcheck (cheap/fast model).
+- The answer is in the \`result\` field of the JSON it prints. Review the diff yourself.
+- \`--no-pane\` suppresses the iTerm follow pane; panes open automatically otherwise.
+- Panes run under the \`pai-worker\` dynamic profile (default profile's font
+  family at \`workers.pane.fontSize\`, default 13); \`pai worker pane <id> --check\`
+  reports the pane plus that profile's path, existence and font.
+
+### Watching
+
+- \`worker_ps\` — running + last finished workers.
+- \`worker_replay\` with id — the transcript of one worker.
+- CLI equivalents: \`pai worker ps\`, \`pai worker follow <id>\`.
+
+### Routing
+
+- \`worker_status\` — on/off, active provider, providers, run tally.
+- \`worker_providers\` — list/add/remove/use/enable/disable/test. Adding needs
+  name, base_url, model and a key (key file path, or a raw key which is
+  parked in ~/.config/pai/keys/<name>, mode 0600).
+- \`worker_roles\` — list/set/unset role → provider[/fast].
+- \`worker_toggle\` — off makes Agent subagents run on Anthropic again.`
+};
+
 //#endregion
 //#region src/daemon-mcp/resources/aesthetic.ts
 const aesthetic = {
@@ -5261,7 +5444,8 @@ async function startShim() {
 		"whisper": whisper,
 		"consolidate": consolidate,
 		"advisor": advisor,
-		"tasks": tasks
+		"tasks": tasks,
+		"worker": worker
 	};
 	for (const [promptName, skill] of Object.entries(SKILL_PROMPTS)) server.prompt(promptName, skill.description, () => ({ messages: [{
 		role: "user",
@@ -5521,6 +5705,249 @@ async function startShim() {
 		top_k: number().int().min(1).max(100).optional().describe("Maximum KG triples to return after re-ranking. Default: 20."),
 		tenant_id: string().optional().describe("Tenant ID for entity lookup scoping. Default: 'default'.")
 	}, async (args) => proxyTool("memory_kg_search", args));
+	const workerText = (s) => ({ content: [{
+		type: "text",
+		text: s
+	}] });
+	const workerError = (e) => ({
+		content: [{
+			type: "text",
+			text: e instanceof Error ? e.message : String(e)
+		}],
+		isError: true
+	});
+	server.tool("worker_status", [
+		"Show the worker system state: on/off, active provider, configured providers,",
+		"roles, and today's run tally from the ledger.",
+		"",
+		"Use this before delegating with `pai worker run` to see what routing will choose."
+	].join("\n"), {}, async () => {
+		try {
+			const { workers } = readWorkersSection();
+			const s = ledgerSummary(ledgerPath(workersLogDir(workers)), "all", 10);
+			const tally = s ? [`runs ${s.scope}: ${s.started} started, ${s.endedOk} ok, ${s.endedFailed} failed`, `agent hook: ${s.denied} denied, ${s.allowed} allowed, ${s.reroutes} reroutes`] : ["no runs recorded yet"];
+			return workerText([
+				`workers: ${workers.enabled ? "on" : "off"}`,
+				`active provider: ${workers.active ?? "(none)"}`,
+				...describeProviders(workers),
+				"",
+				...tally
+			].join("\n"));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_providers", [
+		"Manage worker providers (list, add, remove, use, enable, disable, test).",
+		"",
+		"action=list (default) shows providers, roles and routing.",
+		"action=add needs name, model — and either key_file or key, plus:",
+		"  base_url (anthropic protocol) or upstream_url (protocol=openai, runs",
+		"  through the local PAI proxy). A raw key is written to",
+		"  ~/.config/pai/keys/<name> (mode 0600); only the path lands in the config.",
+		"  engine=codex runs the Codex CLI instead of Claude Code.",
+		"action=test runs a one-word pong probe through the provider",
+		"  (reports 'codex not installed' when that engine's CLI is missing)."
+	].join("\n"), {
+		action: _enum([
+			"list",
+			"add",
+			"remove",
+			"use",
+			"enable",
+			"disable",
+			"test"
+		]).optional().describe("Default: list."),
+		name: string().optional().describe("Provider name (required for every action but list)."),
+		base_url: string().optional().describe("Anthropic-compatible API base URL (add)."),
+		upstream_url: string().optional().describe("Chat Completions base URL (add, protocol=openai)."),
+		protocol: _enum(["anthropic", "openai"]).optional().describe("Protocol (add). Default: anthropic."),
+		engine: _enum(["claude", "codex"]).optional().describe("Runner engine (add). Default: claude."),
+		context_window: number().int().positive().optional().describe("Context window for the meter (add). Default: 200000."),
+		key_file: string().optional().describe("File holding the API token, 0600 (add)."),
+		key: string().optional().describe("Raw API token (add) — parked in ~/.config/pai/keys/<name>."),
+		model: string().optional().describe("Default model id (add)."),
+		fast_model: string().optional().describe("Cheaper model for spotchecks (add, optional)."),
+		env: record(string(), string()).optional().describe("Extra env for runs (add, optional)."),
+		note: string().optional().describe("Human note shown in listings (add, optional)."),
+		quota_probe: string().optional().describe("URL whose JSON first number is the quota percent (add, optional).")
+	}, async (args) => {
+		try {
+			const action = args.action ?? "list";
+			if (action === "list") return workerText(describeProviders(readWorkersSection().workers).join("\n"));
+			if (!args.name) return workerError(/* @__PURE__ */ new Error("name is required for this action"));
+			if (action === "add") {
+				if (!args.model) return workerError(/* @__PURE__ */ new Error("add needs model"));
+				if (args.protocol !== "openai" && !args.base_url) return workerError(/* @__PURE__ */ new Error("add needs base_url (only protocol=openai goes without it)"));
+				const workers = addProvider({
+					name: args.name,
+					baseUrl: args.base_url ?? "",
+					keyFile: args.key_file ?? null,
+					...args.key !== void 0 ? { key: args.key } : {},
+					model: args.model,
+					...args.fast_model ? { fastModel: args.fast_model } : {},
+					env: args.env ?? {},
+					...args.note ? { note: args.note } : {},
+					...args.protocol ? { protocol: args.protocol } : {},
+					...args.upstream_url ? { upstreamUrl: args.upstream_url } : {},
+					...args.engine ? { engine: args.engine } : {},
+					...args.context_window ? { contextWindow: args.context_window } : {},
+					...args.quota_probe ? { quotaProbe: args.quota_probe } : {}
+				});
+				return workerText([`provider ${args.name} added; active: ${workers.active ?? "(none)"}; workers ${workers.enabled ? "on" : "off"}`, ...describeProviders(workers)].join("\n"));
+			}
+			if (action === "remove") {
+				removeProvider(args.name);
+				return workerText(`provider ${args.name} removed`);
+			}
+			if (action === "use") {
+				useProvider(args.name);
+				return workerText(`active provider: ${args.name}`);
+			}
+			if (action === "enable" || action === "disable") {
+				setProviderEnabled(args.name, action === "enable");
+				return workerText(`provider ${args.name} ${action}d`);
+			}
+			const { workers } = readWorkersSection();
+			const p = workers.providers[args.name];
+			if (!p) return workerError(/* @__PURE__ */ new Error(`no provider named "${args.name}"`));
+			const r = await testProvider(args.name, p, workersLogDir(workers));
+			if (r.skipped) return workerText(`${r.provider} ${r.model}  ${r.skipped}\nreply: ${r.result.slice(0, 200)}`);
+			return workerText(`${r.provider} ${r.model}  ${(r.latencyMs / 1e3).toFixed(1)}s\nreply: ${r.result.slice(0, 200)}\n${r.ok ? "OK" : "FAILED"}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_roles", [
+		"Manage worker roles (list, set, unset).",
+		"",
+		"A role maps a task class to a provider, optionally its fast model:",
+		"implement=glm, research=glm, spotcheck=glm/fast.",
+		"Runs pick the provider via --role first, then the active provider."
+	].join("\n"), {
+		action: _enum([
+			"list",
+			"set",
+			"unset"
+		]).optional().describe("Default: list."),
+		role: string().optional().describe("Role name (set/unset)."),
+		target: string().optional().describe("Provider or provider/fast (set).")
+	}, async (args) => {
+		try {
+			const action = args.action ?? "list";
+			if (action === "list") {
+				const { workers } = readWorkersSection();
+				const entries = Object.entries(workers.roles);
+				const text = (t) => typeof t === "string" ? t : typeof t === "object" && t !== null ? `${t.provider ?? "?"}${t.mcp?.length ? ` +mcp(${t.mcp.join(",")})` : ""}` : String(t);
+				return workerText(entries.length ? entries.map(([r, t]) => `${r}: ${text(t)}`).join("\n") : "no roles set");
+			}
+			if (!args.role) return workerError(/* @__PURE__ */ new Error("role is required for this action"));
+			if (action === "set") {
+				if (!args.target) return workerError(/* @__PURE__ */ new Error("set needs target provider[/fast]"));
+				setRole(args.role, args.target);
+				return workerText(`role ${args.role} → ${args.target}`);
+			}
+			unsetRole(args.role);
+			return workerText(`role ${args.role} removed`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_toggle", [
+		"Turn worker routing on or off.",
+		"",
+		"off: the Agent-tool hook stops denying, subagents run on Anthropic.",
+		"on: subagents are denied and rewritten to `pai worker run`."
+	].join("\n"), { enabled: boolean().describe("true = route subagents to workers, false = Anthropic.") }, async (args) => {
+		try {
+			const workers = setWorkersEnabled(args.enabled);
+			return workerText(`workers ${workers.enabled ? "on" : "off"} — Agent subagents ${workers.enabled ? "denied and rewritten to `pai worker run`" : "run on Anthropic"}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_ps", [
+		"List workers: running (id, provider, age, turns, current tool) and the last finished.",
+		"",
+		"Use this to check on delegated `pai worker run` calls; worker_replay shows",
+		"the transcript of one worker."
+	].join("\n"), { all: boolean().optional().describe("Show workers of all sessions (default: this one's).") }, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			return workerText(psOutput(workersLogDir(workers), args.all === true, {}, false));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_replay", [
+		"Replay the transcript of one worker: tool calls, short outputs, result.",
+		"",
+		"Plain text, no colors. Use tail to cap the output."
+	].join("\n"), {
+		id: string().describe("Worker id (as shown by worker_ps)."),
+		tail: number().int().min(1).max(2e3).optional().describe("Last N rendered lines. Default: all.")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			return workerText(replayOutput(workersLogDir(workers), args.id, false, args.tail));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_say", [
+		"Send one message to a RUNNING worker: it lands on the worker's open stdin",
+		"as a user message, mid-run, without breaking its stream.",
+		"",
+		"Fails with an explanation when the worker already finished — then use",
+		"worker_resume (or `pai worker resume <id> \"text\"`) instead."
+	].join("\n"), {
+		id: string().describe("Worker id (as shown by worker_ps)."),
+		text: string().min(1).describe("The message to send (one line).")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			await sayToWorker(workersLogDir(workers), args.id, args.text);
+			return workerText(`sent to ${args.id}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_resume", [
+		"Continue a FINISHED worker with a follow-up message: claude --resume on the",
+		"same provider, same Claude session, context intact.",
+		"",
+		"Returns the new worker id. Not for running workers — say to those instead."
+	].join("\n"), {
+		id: string().describe("Worker id of the finished run (as shown by worker_ps)."),
+		text: string().min(1).describe("The follow-up message.")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			const old = loadStatus(workersLogDir(workers), args.id);
+			if (!old) return workerError(/* @__PURE__ */ new Error(`no worker named "${args.id}"`));
+			if (old.state === "running") return workerError(/* @__PURE__ */ new Error(`worker ${args.id} is still running — send messages with worker_say`));
+			if (!old.claudeSession) return workerError(/* @__PURE__ */ new Error(`worker ${args.id} recorded no Claude session id — it predates resume support or ran through an engine that does not expose one`));
+			let newId = "";
+			const rc = await runWorker({
+				providerFlag: old.provider,
+				modelFlag: old.model,
+				label: `↩ ${old.label}`,
+				noPane: true,
+				claudeArgs: [
+					"--resume",
+					old.claudeSession,
+					"-p",
+					args.text
+				],
+				onWorkerStart: (wid) => {
+					newId = wid;
+				}
+			});
+			return workerText(`resumed ${args.id} as ${newId || "(unknown id)"} — rc=${rc}\ncheck on it with worker_ps / worker_replay`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
 }