cozyclay 3.1.2 → 3.1.3

package/bin/agent/claude-code-executable.mjs

@@ -0,0 +1,93 @@
+// Resolving the Claude Code executable for the anthropic-subscription lane. The lane's API calls
+// must come from the official Claude Code binary (Anthropic's subscription terms tie the OAuth
+// token to it), so the provider spawns it through the Claude Agent SDK. Order: the
+// CLAUDE_CODE_EXECUTABLE override, the platform sidecar package the SDK ships
+// (@anthropic-ai/claude-agent-sdk-<platform>-<arch>/claude), then `claude` on PATH. Nothing is
+// accepted on resolution alone: a candidate counts only once it stats as a file.
+import { statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, isAbsolute, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+
+function executableName(platform = process.platform) {
+	return platform === "win32" ? "claude.exe" : "claude";
+}
+
+function sidecarCandidates(platform = process.platform, arch = process.arch) {
+	const ext = platform === "win32" ? ".exe" : "";
+	if (platform === "linux") {
+		return [
+			`@anthropic-ai/claude-agent-sdk-linux-${arch}/claude${ext}`,
+			`@anthropic-ai/claude-agent-sdk-linux-${arch}-musl/claude${ext}`,
+		];
+	}
+	return [`@anthropic-ai/claude-agent-sdk-${platform}-${arch}/claude${ext}`];
+}
+
+function isFile(candidate) {
+	try {
+		return statSync(candidate).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function findOnPath(command, env = process.env) {
+	const pathEnv = env.PATH;
+	if (!pathEnv) return null;
+	for (const directory of pathEnv.split(delimiter)) {
+		if (!directory) continue;
+		const candidate = join(directory, command);
+		if (isFile(candidate)) return candidate;
+	}
+	return null;
+}
+
+/**
+ * { executable, source, tried } on success, { executable: undefined, tried } when every source
+ * missed. `tried` names every spelling checked so the error can say exactly what was probed.
+ */
+function describeClaudeCodeExecutable({ env = process.env, platform = process.platform, arch = process.arch } = {}) {
+	const tried = [];
+	const accept = (candidate) => {
+		tried.push(candidate);
+		return isFile(candidate) ? candidate : undefined;
+	};
+	const override = env.CLAUDE_CODE_EXECUTABLE;
+	if (override) {
+		const accepted = accept(isAbsolute(override) ? override : join(process.cwd(), override));
+		if (accepted !== undefined) return { executable: accepted, source: "override", tried };
+	}
+	for (const candidate of sidecarCandidates(platform, arch)) {
+		let resolved;
+		try {
+			resolved = require.resolve(candidate);
+		} catch {
+			tried.push(candidate); // the sidecar package is not installed; name it by specifier
+			continue;
+		}
+		const accepted = accept(resolved);
+		if (accepted !== undefined) return { executable: accepted, source: "bundled", tried };
+	}
+	const onPath = findOnPath(executableName(platform), env);
+	if (onPath !== null) {
+		const accepted = accept(onPath);
+		if (accepted !== undefined) return { executable: accepted, source: "path", tried };
+	} else {
+		tried.push("claude on PATH");
+	}
+	return { executable: undefined, source: undefined, tried };
+}
+
+/** The validated executable, or an error naming every candidate — the SDK never sees a miss. */
+export function resolveClaudeCodeExecutable(deps = {}) {
+	const resolution = describeClaudeCodeExecutable(deps);
+	if (resolution.executable !== undefined) return resolution.executable;
+	throw new Error([
+		"Claude Code executable not found; the Anthropic subscription lane needs it.",
+		"Reinstall cozyclay so the @anthropic-ai/claude-agent-sdk platform package is present,",
+		"install Claude Code so `claude` is on PATH, or set CLAUDE_CODE_EXECUTABLE to the binary.",
+		`Tried: ${resolution.tried.join(", ")}`,
+	].join(" "));
+}

package/bin/agent/cliproxy-provider.mjs

@@ -9,7 +9,7 @@ const BASE_ENV = "CLIPROXY_BASE_URL";
 const KEY_ENV = "CLIPROXY_API_KEY";
 
 /** A server address as typed, cleaned: http(s), no trailing slash, no trailing /v1 (the models add it). */
-function cleanBase(value) {
+export function cleanBase(value) {
 	const url = new URL(String(value ?? "").trim());
 	if (!["http:", "https:"].includes(url.protocol)) throw new Error("The server address must start with http:// or https://.");
 	return url.href.replace(/\/+$/, "").replace(/\/v1$/, "");
@@ -18,7 +18,7 @@ function cleanBase(value) {
 /** The address the registry builds CLIProxyAPI's models on: environment, then the stored credential, then the default. */
 export function cliproxyBase({ env = process.env, credential } = {}) {
 	const fromEnv = typeof env?.[BASE_ENV] === "string" ? env[BASE_ENV].trim() : "";
-	return (fromEnv || credential?.env?.[BASE_ENV] || CLIPROXY_DEFAULT_BASE).replace(/\/$/, "");
+	return cleanBase(fromEnv || credential?.env?.[BASE_ENV] || CLIPROXY_DEFAULT_BASE);
 }
 
 /** pi ApiKeyAuth: login asks for the address, then the key; resolve prefers the stored key, then CLIPROXY_API_KEY. */
@@ -44,7 +44,7 @@ function cliproxyAuth() {
 }
 
 export async function cliproxyProvider({ baseUrl, env = process.env } = {}) {
-	const base = (baseUrl ?? cliproxyBase({ env })).replace(/\/$/, "");
+	const base = cleanBase(baseUrl ?? cliproxyBase({ env }));
 	const [{ createProvider }, { openaiProvider }, { anthropicProvider }, openaiResponsesApi, anthropicMessagesApi] = await Promise.all([
 		import("@earendil-works/pi-ai"),
 		import("@earendil-works/pi-ai/providers/openai"),
@@ -74,6 +74,19 @@ export async function cliproxyProvider({ baseUrl, env = process.env } = {}) {
 	});
 }
 
+/** GET <v1 base>/models: the server's entries ({ id, owned_by? } or bare ids). A refusal throws with its `status`;
+ * a network failure throws fetch's own error. Shared with the custom OpenAI-compatible lane (#885). */
+export async function fetchModelList(v1Base, apiKey, label, signal) {
+	const timeout = AbortSignal.timeout(5000);
+	const response = await fetch(`${v1Base}/models`, {
+		headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+		signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+	});
+	if (!response.ok) throw Object.assign(new Error(`${label} models request failed: ${response.status}`), { status: response.status });
+	const body = await response.json();
+	return Array.isArray(body?.data) ? body.data : [];
+}
+
 /** The proxy's own /v1/models (id -> owner), fetched once per registry; a failed fetch is asked again next time. */
 export async function registryLiveCliproxy(models, apiKey, state) {
 	if (!state.cliproxyFetch) {
@@ -81,18 +94,19 @@ export async function registryLiveCliproxy(models, apiKey, state) {
 			const provider = models?.getProvider?.("cliproxy");
 			const model = provider?.getModels?.().find((entry) => entry.api === "openai-responses");
 			if (!model?.baseUrl || !apiKey) throw new Error("CLIProxyAPI is not configured");
-			const response = await fetch(`${model.baseUrl}/models`, {
-				headers: { Authorization: `Bearer ${apiKey}` },
-				signal: AbortSignal.timeout(5000),
-			});
-			if (!response.ok) throw new Error(`CLIProxyAPI models request failed: ${response.status}`);
-			const body = await response.json();
+			const data = await fetchModelList(model.baseUrl, apiKey, "CLIProxyAPI");
 			// id -> owned_by: the owner is how CLIProxyAPI routes a model (openai, anthropic, or an
 			// openai-compatibility upstream name), so it picks the wire format for models pi does not know.
-			return new Map((Array.isArray(body?.data) ? body.data : [])
+			const live = new Map(data
 				.map((entry) => typeof entry === "string" ? [entry, undefined] : [entry?.id, typeof entry?.owned_by === "string" ? entry.owned_by : undefined])
 				.filter(([id]) => id));
-		}).catch(() => { state.cliproxyFetch = null; return null; });
+			state.cliproxyFetchError = null;
+			return live;
+		}).catch((error) => {
+			state.cliproxyFetch = null;
+			state.cliproxyFetchError = error instanceof Error ? error.message : String(error);
+			return null;
+		});
 	}
 	return state.cliproxyFetch;
 }

package/bin/agent/model-roles.mjs

@@ -0,0 +1,112 @@
+// --- model roles (#717) ------------------------------------------------------
+//
+// One picked model (main) implies the rest of the lineup a turn may lean on: a
+// cheap helper, a mid-tier advisor, a model that can see images, and the
+// ordered alternatives to try when main fails. Subscription accounts usually
+// have exactly one signed-in provider, so every derived role stays on main's
+// provider; only the fallback chain may cross to another signed-in provider
+// that serves the very same model id. Both functions are pure over a
+// listAgentModels-shaped `{ providers }` catalog and never throw.
+
+export const MODEL_ROLES = ["main", "helper", "vision", "advisor"];
+
+const CLAUDE_TIERS = ["opus", "sonnet", "haiku"];
+const GPT_MINI_CLASS = /mini|nano/;
+const newestFirst = (a, b) => b.id.localeCompare(a.id, undefined, { numeric: true });
+
+function splitModelKey(key) {
+	const slash = typeof key === "string" ? key.indexOf("/") : -1;
+	return slash > 0 ? { providerId: key.slice(0, slash), modelId: key.slice(slash + 1) } : null;
+}
+
+const modelFamily = (id) => /^claude-/.test(id) ? "claude" : /^gpt-/.test(id) ? "gpt" : null;
+const claudeTier = (id) => CLAUDE_TIERS.find((tier) => id.startsWith(`claude-${tier}`)) ?? null;
+const takesImages = (model) => Array.isArray(model?.input) && model.input.includes("image");
+const modelKeyOf = (providerId, model) => model.key ?? `${providerId}/${model.id}`;
+
+/** main's provider entry, main's own model entry and the same-family models on that provider. */
+function locateMain(mainKey, catalog) {
+	const parts = splitModelKey(mainKey);
+	const providers = Array.isArray(catalog?.providers) ? catalog.providers : [];
+	const provider = parts && providers.find((entry) => entry?.id === parts.providerId);
+	const models = Array.isArray(provider?.models) ? provider.models.filter((model) => typeof model?.id === "string") : [];
+	const main = parts && models.find((model) => model.id === parts.modelId);
+	if (!main) return null;
+	const family = modelFamily(main.id);
+	return { providers, provider, models, main, family, sameFamily: family ? models.filter((model) => modelFamily(model.id) === family) : [] };
+}
+
+/** The first preference that matches a model: an exact id, or the newest id a pattern matches. */
+function pickModel(models, preferences) {
+	for (const preference of preferences) {
+		const match = typeof preference === "string"
+			? models.find((model) => model.id === preference)
+			: [...models].filter((model) => preference.test(model.id)).sort(newestFirst)[0];
+		if (match) return match;
+	}
+	return null;
+}
+
+/** One tier of a Claude lineup, preferring main's own version (opus-5-5 -> sonnet-5-5). */
+function claudeTierModel(models, mainId, tier) {
+	const current = claudeTier(mainId);
+	return pickModel(models, [current ? mainId.replace(`claude-${current}`, `claude-${tier}`) : null, new RegExp(`^claude-${tier}`)].filter(Boolean));
+}
+
+export function resolveRoleModels(mainKey, catalog) {
+	const main = typeof mainKey === "string" ? mainKey : "";
+	const found = locateMain(main, catalog);
+	if (!found) return { main, helper: main, vision: main, advisor: main };
+	const { provider, models, main: model, family, sameFamily } = found;
+	const key = (entry) => (entry ? modelKeyOf(provider.id, entry) : main);
+	const helper = family === "claude" ? pickModel(sameFamily, ["claude-haiku-5-5", /^claude-haiku/, /^claude-sonnet/])
+		: family === "gpt" ? pickModel(sameFamily, [GPT_MINI_CLASS, /luna/])
+			: null;
+	const advisor = family === "claude" ? pickModel(sameFamily, ["claude-sonnet-5-5", /^claude-sonnet/])
+		: family === "gpt" ? pickModel(sameFamily, ["gpt-6-astra"])
+			: null;
+	const vision = takesImages(model) ? model : models.find(takesImages);
+	return { main, helper: key(helper), vision: key(vision), advisor: key(advisor) };
+}
+
+export function fallbackChain(mainKey, catalog) {
+	const found = locateMain(mainKey, catalog);
+	if (!found) return [];
+	const { providers, provider, main, family, sameFamily } = found;
+	const chain = [];
+	// The same model served by another signed-in provider is the closest substitute there is.
+	for (const other of providers) {
+		if (other === provider || !other?.signedIn || !Array.isArray(other.models)) continue;
+		const same = other.models.find((model) => model?.id === main.id);
+		if (same) chain.push(modelKeyOf(other.id, same));
+	}
+	// Then a step down main's own family on main's provider.
+	if (family === "claude") {
+		const tier = CLAUDE_TIERS.indexOf(claudeTier(main.id));
+		if (tier !== -1) {
+			for (const lower of CLAUDE_TIERS.slice(tier + 1)) {
+				const model = claudeTierModel(sameFamily, main.id, lower);
+				if (model) chain.push(modelKeyOf(provider.id, model));
+			}
+		}
+	} else if (family === "gpt" && !GPT_MINI_CLASS.test(main.id)) {
+		for (const model of [pickModel(sameFamily, ["gpt-6-astra"]), pickModel(sameFamily, [GPT_MINI_CLASS])]) {
+			if (model) chain.push(modelKeyOf(provider.id, model));
+		}
+	}
+	const mainKeyFound = modelKeyOf(provider.id, main);
+	return [...new Set(chain)].filter((key) => key !== mainKeyFound).slice(0, 3);
+}
+
+/** `roles.byMain` for listAgentModels: every model of every signed-in provider. */
+export function rolesByMain(catalog) {
+	const byMain = {};
+	for (const provider of catalog.providers) {
+		if (!provider.signedIn) continue;
+		for (const model of provider.models) {
+			const { helper, vision, advisor } = resolveRoleModels(model.key, catalog);
+			byMain[model.key] = { helper, vision, advisor, fallback: fallbackChain(model.key, catalog) };
+		}
+	}
+	return { byMain };
+}

package/bin/agent/openai-compatible-provider.mjs

@@ -0,0 +1,95 @@
+// A custom OpenAI-compatible endpoint (#885): LM Studio, Ollama, vLLM, llama.cpp's server or any server that
+// answers GET /v1/models and POST /v1/chat/completions, connected without CLIProxyAPI. Like CLIProxyAPI's lane,
+// its login is pi's api-key login: it asks for the server address and an optional key, checks that
+// <address>/v1/models answers, and returns one api-key credential carrying the address as provider env, which the
+// credential store keeps in auth.json. The models are the server's own /v1/models list (pi's fetchModels, run by
+// refreshOpenAICompatible), and turns stream through pi-ai's openai-completions API.
+import { cleanBase, fetchModelList } from "./cliproxy-provider.mjs";
+
+export const OPENAI_COMPATIBLE_ID = "openai-compatible";
+const BASE_ENV = "OPENAI_COMPATIBLE_BASE_URL";
+const DEFAULT_BASE = "http://127.0.0.1:11434";
+// openai-completions needs some key; a keyless local server ignores the Authorization header it carries.
+const NO_KEY = "no-key";
+
+const v1 = (base) => `${base}/v1`;
+
+/** One chat model the server listed. The server does not say which of its models read images, so every model is
+ * offered with image input (the panel only lists those); a text-only model refuses an image turn with its own error. */
+function endpointModel(id, base) {
+	return {
+		id,
+		name: id,
+		type: "chat",
+		api: "openai-completions",
+		provider: OPENAI_COMPATIBLE_ID,
+		baseUrl: v1(base),
+		reasoning: false,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 32768,
+		maxTokens: 8192,
+		compat: { supportsStore: false, supportsDeveloperRole: false, supportsReasoningEffort: false, supportsStrictMode: false, maxTokensField: "max_tokens" },
+	};
+}
+
+/** The server's model ids, or an error that says what went wrong in words the login and the picker can show. */
+async function listEndpoint(base, key, signal) {
+	let data;
+	try {
+		data = await fetchModelList(v1(base), key, "The OpenAI-compatible server", signal);
+	} catch (error) {
+		if (error?.status === 401 || error?.status === 403) throw new Error(`The server at ${base} refused ${key ? "the key" : "a request without a key"} (${error.status}).`, { cause: error });
+		if (error?.status) throw new Error(`The server at ${base} answered GET /v1/models with ${error.status}.`, { cause: error });
+		throw new Error(`Could not reach ${v1(base)}/models (${error?.cause?.code || error?.name || error?.message || error}).`, { cause: error });
+	}
+	return data.map((entry) => (typeof entry === "string" ? entry : entry?.id)).filter((id) => typeof id === "string" && id);
+}
+
+/** pi ApiKeyAuth: the address, then an optional key; the login only succeeds once the server lists its models. */
+function endpointAuth() {
+	return {
+		name: "Server address and optional key",
+		login: async (interaction) => {
+			interaction.signal.throwIfAborted();
+			const address = await interaction.prompt({ type: "text", message: "Server address (LM Studio, Ollama, or another OpenAI-compatible server)", placeholder: v1(DEFAULT_BASE) });
+			const base = cleanBase(address.trim() || DEFAULT_BASE);
+			interaction.signal.throwIfAborted();
+			const key = String(await interaction.prompt({ type: "secret", optional: true, message: "API key (leave empty when the server needs none)" })).trim();
+			interaction.signal.throwIfAborted();
+			const ids = await listEndpoint(base, key, interaction.signal);
+			interaction.notify?.({ type: "info", message: `${base} lists ${ids.length} model${ids.length === 1 ? "" : "s"}.` });
+			return { type: "api_key", key, env: { [BASE_ENV]: base } };
+		},
+		resolve: async ({ credential, signal }) => {
+			signal.throwIfAborted();
+			if (!credential?.env?.[BASE_ENV]) return undefined;
+			return { auth: { apiKey: credential.key || NO_KEY }, env: credential.env, source: "stored credential" };
+		},
+	};
+}
+
+export async function openaiCompatibleProvider() {
+	const [{ createProvider }, completionsApi] = await Promise.all([
+		import("@earendil-works/pi-ai"),
+		import("@earendil-works/pi-ai/api/openai-completions"),
+	]);
+	return createProvider({
+		id: OPENAI_COMPATIBLE_ID,
+		name: "OpenAI-compatible server (LM Studio, Ollama)",
+		auth: { apiKey: endpointAuth() },
+		models: [],
+		api: { "openai-completions": completionsApi },
+		fetchModels: async ({ credential, signal }) => {
+			const base = credential?.env?.[BASE_ENV];
+			return base ? (await listEndpoint(base, credential.key, signal)).map((id) => endpointModel(id, base)) : [];
+		},
+	});
+}
+
+/** Re-reads the server's /v1/models into the registry; the reason it failed, or null. */
+export async function refreshOpenAICompatible(models) {
+	if (typeof models?.refresh !== "function") return null;
+	const { errors } = await models.refresh({ providers: [OPENAI_COMPATIBLE_ID] });
+	return errors.get(OPENAI_COMPATIBLE_ID)?.message ?? null;
+}

package/bin/agent/pi-tools.mjs

@@ -31,6 +31,19 @@ function recoveryHint(error) {
 	return ` (${recovery.action}${recovery.retryAllowed === false ? ", do not retry" : ", retry allowed"})`;
 }
 
+/** The handler's result, unless the run is stopped first: then the call ends at once as aborted, as it did under pi's
+ * removed AgentHarness. The handler may still settle in the background; its result no longer counts. */
+function untilAborted(pending, signal) {
+	const aborted = () => Object.assign(new Error("Stopped before this call finished."), { name: "AbortError", code: "ABORTED" });
+	if (!signal) return pending;
+	if (signal.aborted) return Promise.reject(aborted());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(aborted());
+		signal.addEventListener("abort", onAbort, { once: true });
+		pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+
 function formatToolError(error) {
 	const code = error?.code || "BACKEND_UNAVAILABLE";
 	const message = error?.message || "Tool execution failed.";
@@ -48,21 +61,17 @@ export function toAgentTools(tools, { emit, signal, labels = STUDIO_TOOL_LABELS
 			parameters,
 			// Before pi's own check: array texts parsed, unknown fields named (tool-arguments.mjs).
 			prepareArguments: toolArgumentPreparer(tool.name, schema),
-			// pi's low-level `Agent` calls `execute(id, params, signal, onUpdate)`;
-			// pi's `AgentHarness` calls `execute(id, params, onUpdate, toolContext,
-			// invocation, context)` where `context.abortSignal` is the REAL abort
-			// signal (dist/harness/execution/tools.js:62-66). Accept both shapes:
-			// prefer `context.abortSignal`, else fall back to an AbortSignal found
-			// positionally in argument 3 (the low-level path), else the adapter's
-			// own fallback signal.
-			execute: async (toolCallId, params, third, toolContext, invocation, context) => {
-				const executeSignal = context?.abortSignal ?? (third instanceof AbortSignal ? third : undefined) ?? signal;
+			// pi's `Agent` calls `execute(id, params, signal, onUpdate)`, where `signal`
+			// is the REAL run abort signal (session.abort() fires it); a caller that
+			// passes none gets the adapter's own fallback signal.
+			execute: async (toolCallId, params, runSignal) => {
+				const executeSignal = runSignal ?? signal;
 				if (!Value.Check(parameters, params)) {
 					const first = [...Value.Errors(parameters, params)][0];
 					throw Object.assign(new Error(`Invalid arguments for ${tool.name}${first ? `: ${first.keyword}: ${first.message}` : "."}`), { code: "INVALID_ARGUMENT" });
 				}
 				try {
-					const result = await tool.handler(params, { signal: executeSignal, toolCallId, emit });
+					const result = await untilAborted(Promise.resolve(tool.handler(params, { signal: executeSignal, toolCallId, emit })), executeSignal);
 					const details = publicResult(result);
 					const image = result && typeof result === "object" && !Array.isArray(result) && result.dataUrl ? dataUrlImage(result.dataUrl) : null;
 					const content = [{ type: "text", text: resultText(details) }];

package/bin/agent/provider-login.mjs

@@ -27,7 +27,9 @@ export async function loginOptions(models, { chatgpt } = {}) {
 		const check = provider.id === "openai-codex"
 			? (chatgpt?.() ? { type: "oauth", source: "ChatGPT" } : undefined)
 			: await models.checkAuth(provider.id).catch(() => undefined);
-		options.push({ id: provider.id, name: provider.name ?? provider.id, methods, connected: !!check, via: check?.type ?? null, source: check?.source ?? null });
+		// pi 0.99 renamed its Codex lane "OpenAI Codex (legacy)"; here it is CozyClay's ChatGPT sign-in, so it keeps its name
+		const name = provider.id === "openai-codex" ? "OpenAI Codex" : provider.name ?? provider.id;
+		options.push({ id: provider.id, name, methods, connected: !!check, via: check?.type ?? null, source: check?.source ?? null });
 	}
 	const rank = (entry) => (entry.connected ? 0 : entry.methods.some((method) => method.subscription) ? 1 : 2);
 	return options.sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name));

package/bin/agent/provider-routes.mjs

@@ -82,6 +82,8 @@ export function createProviderRoutes({ auth, getModels, onChange, json, readBody
 		let key;
 		if (req.method === "PUT") {
 			if (id === "openai-codex") { json(res, 400, { error: "Use ChatGPT sign-in for OpenAI Codex." }); return true; }
+			if (id === "anthropic-subscription") { json(res, 400, { error: "Use the Claude sign-in; this provider takes no API key." }); return true; }
+			if (id === "openai-compatible") { json(res, 400, { error: "Connect the server under Connect a model; it needs its address." }); return true; }
 			try {
 				const value = await readBody(req);
 				if (typeof value?.key !== "string" || !value.key.trim()) throw new Error("Invalid key.");