@victor-software-house/pi-acp 0.15.0 → 0.17.0

package/dist/{daemon-C-rb-cf5.mjs → daemon-CTINLJUp.mjs}

@@ -8,7 +8,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { Hono } from "hono";
 import { AgentSideConnection, RequestError, ndJsonStream } from "@agentclientprotocol/sdk";
 import { randomUUID } from "node:crypto";
-import { DefaultResourceLoader, SessionManager, createAgentSession, createBashToolDefinition, createReadToolDefinition, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { AuthStorage, DefaultResourceLoader, SessionManager, createAgentSession, createBashToolDefinition, createReadToolDefinition, getAgentDir } from "@earendil-works/pi-coding-agent";
 import * as z from "zod";
 import { parse } from "yaml";
 import { $ } from "bun";
@@ -544,6 +544,86 @@ function skillCommandsEnabled(cwd) {
 	return true;
 }
 //#endregion
+//#region src/acp/providers.ts
+/**
+* Map an ACP `LlmProtocol` to a pi `Api` identifier. Used when
+* `unstable_setProvider` injects a provider whose `apiType` is one of the
+* spec's enumerated protocols. Unknown protocols pass through verbatim
+* (LlmProtocol is `KnownProtocol | string`).
+*/
+function acpProtocolToPiApi(protocol) {
+	switch (protocol) {
+		case "anthropic": return "anthropic-messages";
+		case "openai": return "openai-responses";
+		case "azure": return "azure-openai-responses";
+		case "vertex": return "google-vertex";
+		case "bedrock": return "bedrock-converse-stream";
+		default: return protocol;
+	}
+}
+/**
+* Reverse map: pi `Api` → ACP `LlmProtocol`. Used by `listProviders` to
+* describe each pi-known model's transport. Falls back to the raw `api`
+* string when no canonical bucket matches.
+*/
+function piApiToAcpProtocol(api) {
+	if (api.startsWith("anthropic")) return "anthropic";
+	if (api.startsWith("openai")) return "openai";
+	if (api.startsWith("azure")) return "azure";
+	if (api.includes("vertex")) return "vertex";
+	if (api.startsWith("bedrock")) return "bedrock";
+	if (api.startsWith("google")) return "vertex";
+	return api;
+}
+function buildListProvidersResponse(deps) {
+	const first = firstRegistry(deps.registries());
+	if (first === void 0) return { providers: [] };
+	const byProvider = /* @__PURE__ */ new Map();
+	for (const model of first.getAll()) {
+		const entry = byProvider.get(model.provider) ?? {
+			baseUrls: /* @__PURE__ */ new Set(),
+			protocols: /* @__PURE__ */ new Set()
+		};
+		entry.baseUrls.add(model.baseUrl);
+		entry.protocols.add(piApiToAcpProtocol(model.api));
+		byProvider.set(model.provider, entry);
+	}
+	return { providers: Array.from(byProvider.entries()).map(([id, entry]) => {
+		const supported = Array.from(entry.protocols);
+		const primaryBaseUrl = Array.from(entry.baseUrls)[0] ?? "";
+		const primaryProtocol = supported[0] ?? "openai";
+		return {
+			id,
+			supported,
+			required: false,
+			current: deps.disabled.has(id) ? null : {
+				apiType: primaryProtocol,
+				baseUrl: primaryBaseUrl
+			}
+		};
+	}) };
+}
+function applySetProvider(deps, params) {
+	const config = {
+		baseUrl: params.baseUrl,
+		api: acpProtocolToPiApi(params.apiType),
+		...params.headers !== void 0 ? { headers: params.headers } : {}
+	};
+	for (const reg of deps.registries()) reg.registerProvider(params.id, config);
+	deps.disabled.delete(params.id);
+	return {};
+}
+function applyDisableProvider(deps, params) {
+	deps.disabled.add(params.id);
+	for (const reg of deps.registries()) try {
+		reg.unregisterProvider(params.id);
+	} catch {}
+	return {};
+}
+function firstRegistry(it) {
+	for (const reg of it) return reg;
+}
+//#endregion
 //#region src/acp/translate/tool-content.ts
 const textBlockSchema = z.object({
 	type: z.literal("text"),
@@ -2115,7 +2195,7 @@ var SshBackend = class {
 //#endregion
 //#region package.json
 var name = "@victor-software-house/pi-acp";
-var version = "0.15.0";
+var version = "0.17.0";
 //#endregion
 //#region src/acp/agent.ts
 /** Builtin ACP slash commands handled directly by the adapter. */
@@ -2213,6 +2293,12 @@ var PiAcpAgent = class {
 	connectionId = randomUUID();
 	extMethods;
 	startedAt = Date.now();
+	/**
+	* pi-acp-side soft-disable set for providers. Pi has only `unregister`
+	* (destructive); we layer a disabled-set on top so `listProviders` can
+	* report `current: null` per ACP spec even after disable.
+	*/
+	disabledProviders = /* @__PURE__ */ new Set();
 	dispose() {
 		if (this.daemonContext !== void 0) {
 			const registry = this.daemonContext.sessionRegistry;
@@ -2237,6 +2323,72 @@ var PiAcpAgent = class {
 	async extNotification(method, params) {
 		await this.extMethods.handleNotification(method, params);
 	}
+	/**
+	* Iterable of every live `ModelRegistry` instance — local SessionManager
+	* plus daemon SessionRegistry. Used by the providers/* methods to apply
+	* mutations across all live sessions.
+	*/
+	liveModelRegistries() {
+		const out = [];
+		for (const s of this.sessions.values()) out.push(s.piSession.modelRegistry);
+		if (this.daemonContext !== void 0) for (const e of this.daemonContext.sessionRegistry.listAll()) out.push(e.piSession.modelRegistry);
+		return out;
+	}
+	async unstable_listProviders(_params) {
+		return buildListProvidersResponse({
+			registries: () => this.liveModelRegistries(),
+			disabled: this.disabledProviders
+		});
+	}
+	async unstable_setProvider(params) {
+		if (params.id === "") throw RequestError.invalidParams("provider id must be non-empty");
+		return applySetProvider({
+			registries: () => this.liveModelRegistries(),
+			disabled: this.disabledProviders
+		}, params);
+	}
+	async unstable_disableProvider(params) {
+		if (params.id === "") throw RequestError.invalidParams("provider id must be non-empty");
+		return applyDisableProvider({
+			registries: () => this.liveModelRegistries(),
+			disabled: this.disabledProviders
+		}, params);
+	}
+	/**
+	* Clears every provider's stored credentials from the shared AuthStorage.
+	*
+	* ACP `LogoutRequest` carries only `_meta` — no per-provider selector —
+	* so this is correctly GLOBAL. Pi has no AuthStorage.clearAll(); we
+	* loop `list()` + `remove()` per provider.
+	*
+	* Sessions stay live. Subsequent prompts may surface auth_required which
+	* is the correct UX. Best-effort fanout: post an agent_message_chunk to
+	* every live PiAcpSession announcing the logout for client visibility.
+	*
+	* Strategy: reuse an active session's AuthStorage instance when one
+	* exists (every live session shares the same on-disk auth.json). When
+	* no session is live, mint an ad-hoc `AuthStorage.create()` to operate
+	* directly on the on-disk store.
+	*
+	* Gated by `agentCapabilities.auth.logout = {}`.
+	*/
+	async unstable_logout(_params) {
+		const live = this.sessions.first();
+		const authStorage = live !== void 0 ? live.piSession.modelRegistry.authStorage : AuthStorage.create();
+		const providers = authStorage.list();
+		for (const p of providers) authStorage.remove(p);
+		for (const s of this.sessions.values()) this.conn.sessionUpdate({
+			sessionId: s.sessionId,
+			update: {
+				sessionUpdate: "agent_message_chunk",
+				content: {
+					type: "text",
+					text: "[pi-acp] Logged out from all providers.\n"
+				}
+			}
+		}).catch(() => {});
+		return { _meta: { piAcp: { clearedProviders: providers } } };
+	}
 	registerWithDaemon(input) {
 		if (this.daemonContext === void 0) return;
 		this.daemonContext.sessionRegistry.register({
@@ -2399,6 +2551,7 @@ var PiAcpAgent = class {
 			},
 			authMethods: buildAuthMethods({ supportsTerminalAuthMeta: this.clientCapabilities.terminalAuth }),
 			agentCapabilities: {
+				auth: { logout: {} },
 				loadSession: true,
 				mcpCapabilities: {
 					http: false,
@@ -2415,7 +2568,8 @@ var PiAcpAgent = class {
 					resume: {},
 					fork: {},
 					delete: {}
-				}
+				},
+				providers: {}
 			}
 		};
 	}
@@ -3563,4 +3717,4 @@ async function runDaemon() {
 //#endregion
 export { runDaemon };
 
-//# sourceMappingURL=daemon-C-rb-cf5.mjs.map
+//# sourceMappingURL=daemon-CTINLJUp.mjs.map