@victor-software-house/pi-acp 0.14.0 → 0.16.0

package/dist/{daemon-CjPR14E_.mjs → daemon-DKl32dgA.mjs}

@@ -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.14.0";
+var version = "0.16.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,37 @@ 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);
+	}
 	registerWithDaemon(input) {
 		if (this.daemonContext === void 0) return;
 		this.daemonContext.sessionRegistry.register({
@@ -2413,8 +2530,10 @@ var PiAcpAgent = class {
 					list: {},
 					close: {},
 					resume: {},
-					fork: {}
-				}
+					fork: {},
+					delete: {}
+				},
+				providers: {}
 			}
 		};
 	}
@@ -2786,6 +2905,40 @@ var PiAcpAgent = class {
 		else if (local !== void 0) this.sessions.detach(params.sessionId);
 		return {};
 	}
+	/**
+	* Deletes a session's on-disk file + releases any live state.
+	*
+	* Pi's SessionManager exposes no `delete()` method (verified against
+	* session-manager.d.ts) — sessions are append-only JSONL files. We
+	* unlink the file directly via `fs.rmSync`. `resolveSessionFile`
+	* sources paths from `PiSessionManager.listAll`, so the unlinked path
+	* is always inside `~/.pi/agent/sessions/...`.
+	*
+	* Refuses to delete sessions owned by ANOTHER connection in the daemon
+	* registry — security boundary: clients may only delete sessions they
+	* own or sessions that are not currently live. Always releases the
+	* daemon registry entry first so the live piSession is disposed
+	* cleanly before the file disappears.
+	*
+	* Gated by `sessionCapabilities.delete = {}` (advertised in initialize).
+	*/
+	async unstable_deleteSession(params) {
+		const sessionFile = await this.resolveSessionFile(params.sessionId);
+		if (sessionFile === null) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		const live = this.daemonContext?.sessionRegistry.get(params.sessionId);
+		if (live !== void 0 && live.ownerConnectionId !== this.connectionId) throw RequestError.invalidParams(`Session ${params.sessionId} is owned by another connection — cannot delete`);
+		if (live !== void 0) {
+			if (this.releaseFromDaemon(params.sessionId).disposed) this.sessions.close(params.sessionId);
+		} else if (this.sessions.maybeGet(params.sessionId) !== void 0) this.sessions.close(params.sessionId);
+		try {
+			rmSync(sessionFile, { force: true });
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to delete session file: ${msg}`);
+		}
+		this.sessionPaths.delete(params.sessionId);
+		return { _meta: { piAcp: { deletedFile: sessionFile } } };
+	}
 	async resumeSession(params) {
 		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
 		const existing = this.sessions.maybeGet(params.sessionId);
@@ -3528,4 +3681,4 @@ async function runDaemon() {
 //#endregion
 export { runDaemon };
 
-//# sourceMappingURL=daemon-CjPR14E_.mjs.map
+//# sourceMappingURL=daemon-DKl32dgA.mjs.map