pi2dsh 0.2.0 → 0.3.1

package/dist/{runtime-D84Hv_3m.mjs → runtime-6DefpI6h.mjs}

@@ -1,6 +1,8 @@
 
 import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
-import { x as Theme } from "./pi-coding-agent-Dsg6_0ua.mjs";
+import { E as __setSubagentSessionFactory, S as Theme, f as ExtensionRunner } from "./pi-coding-agent-Z1hTs61i.mjs";
+import { a as storedOAuthCredential, i as resolveOAuthApiKey, n as loginPiProvider, r as providerSupportsOAuth, t as FileCredentialStore } from "./oauth-bridge-BpPrppjR.mjs";
+import { r as builtinProviders } from "./pi-ai-CWFlgigJ.mjs";
 import { createRequire } from "node:module";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -277,6 +279,221 @@ var PiSessionBridge = class {
 	}
 };
 //#endregion
+//#region src/subagent-bridge.ts
+let subagentSerial = 0;
+var PiBridgedAgentSession = class {
+	agent = {};
+	messages = [];
+	#host;
+	#handle;
+	#session;
+	#tools;
+	#subscribers = /* @__PURE__ */ new Set();
+	#disposers = [];
+	#activeToolNames;
+	#sessionName = "";
+	#turns = 0;
+	#aborted = false;
+	constructor(host, handle, tools) {
+		this.#host = host;
+		this.#handle = handle;
+		this.#session = handle.agent.session ?? {};
+		this.#tools = tools;
+		this.#activeToolNames = tools.map((tool) => tool?.name).filter((name) => typeof name === "string");
+		const cordis = host.cordis;
+		const offEvents = cordis.on("session/event", (session, event) => {
+			if (session !== this.#session) return;
+			this.#project(event);
+		});
+		const offPre = cordis.on("tools/pre-execute", async (exec, next) => {
+			if (exec.agent !== this.#handle.agent || this.agent.beforeToolCall === void 0) return next();
+			const decision = await this.agent.beforeToolCall({ toolCall: {
+				name: exec.name,
+				id: exec.callId,
+				arguments: exec.arguments
+			} }, void 0);
+			if (decision?.block === true) return {
+				kind: "deny",
+				reason: decision.reason ?? `Tool "${exec.name}" is not available to this subagent.`
+			};
+			return next();
+		});
+		this.#disposers.push(offEvents, offPre);
+	}
+	#project(event) {
+		const type = event.type;
+		const emit = (piEvent) => {
+			for (const handler of [...this.#subscribers]) try {
+				handler(piEvent);
+			} catch {}
+		};
+		if (type === "turn/start") emit({
+			type: "turn_start",
+			turnIndex: Number(event.data.turn ?? 1) - 1
+		});
+		if (type === "tool/call") {
+			const data = event.data;
+			let args = {};
+			try {
+				args = JSON.parse(String(data.arguments ?? "{}"));
+			} catch {
+				args = {};
+			}
+			emit({
+				type: "tool_execution_start",
+				toolCallId: data.callId,
+				toolName: data.name,
+				args
+			});
+		}
+		if (type === "assistant/chunk") {
+			const chunk = event.data.chunk ?? {};
+			const delta = typeof chunk.text === "string" ? chunk.text : typeof chunk.delta === "string" ? chunk.delta : "";
+			emit({
+				type: "message_update",
+				message: {
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: delta
+					}]
+				},
+				assistantMessageEvent: {
+					type: "text_delta",
+					delta,
+					...chunk
+				}
+			});
+		}
+		const message = this.#host.messageFromSessionEvent(event);
+		if (message !== void 0) {
+			this.messages.push(message);
+			emit({
+				type: "message_start",
+				message
+			});
+			emit({
+				type: "message_end",
+				message
+			});
+		}
+		if (type === "turn/end") {
+			this.#turns += 1;
+			emit({
+				type: "turn_end",
+				turnIndex: Number(event.data.turn ?? 1) - 1,
+				message: {
+					role: "assistant",
+					content: []
+				},
+				toolResults: []
+			});
+		}
+	}
+	subscribe(handler) {
+		this.#subscribers.add(handler);
+		return () => this.#subscribers.delete(handler);
+	}
+	async prompt(text) {
+		const blocks = await this.#host.piContentToDsh([{
+			type: "text",
+			text: String(text)
+		}]);
+		const cordis = this.#host.cordis;
+		const completed = new Promise((resolve) => {
+			const off = cordis.on("session/event", (session, event) => {
+				if (session !== this.#session) return;
+				if (event.type === "turn/end") {
+					off();
+					resolve();
+				}
+			});
+			this.#disposers.push(off);
+		});
+		this.#host.deliver(this.#handle.agent, createUserMessage({
+			content: blocks,
+			source: {
+				kind: "plugin",
+				plugin: this.#host.messageSource
+			}
+		}), "followup");
+		await completed;
+	}
+	steer(text) {
+		this.#host.piContentToDsh([{
+			type: "text",
+			text: String(text)
+		}]).then((blocks) => {
+			this.#host.deliver(this.#handle.agent, createUserMessage({
+				content: blocks,
+				source: {
+					kind: "plugin",
+					plugin: this.#host.messageSource
+				}
+			}), "steer");
+		});
+	}
+	abort() {
+		this.#aborted = true;
+		const cancel = this.#handle.agent.cancel;
+		cancel?.({
+			kind: "hook",
+			reason: "pi2dsh subagent abort()"
+		});
+	}
+	setSessionName(name) {
+		this.#sessionName = String(name);
+	}
+	getSessionName() {
+		return this.#sessionName;
+	}
+	getSessionStats() {
+		return {
+			turns: this.#turns,
+			messages: this.messages.length,
+			aborted: this.#aborted
+		};
+	}
+	getAllTools() {
+		return [...this.#tools];
+	}
+	getActiveToolNames() {
+		return [...this.#activeToolNames];
+	}
+	setActiveToolsByName(names) {
+		this.#activeToolNames = names.filter((name) => typeof name === "string");
+	}
+	async bindExtensions(_bindings = {}) {}
+	async dispose() {
+		for (const dispose of this.#disposers.splice(0)) try {
+			dispose();
+		} catch {}
+		this.#subscribers.clear();
+		await this.#handle.dispose();
+	}
+};
+async function createBridgedAgentSession(host, options) {
+	const agents = host.cordis.get("agents");
+	if (agents?.create === void 0) throw new Error("pi2dsh: createAgentSession() needs the DSH agent registry in the host composition");
+	subagentSerial += 1;
+	const sessionId = `pi2dsh-sub-${Date.now().toString(36)}-${subagentSerial}`;
+	let handle;
+	try {
+		handle = await agents.create({
+			sessionId,
+			meta: {
+				cwd: typeof options.cwd === "string" ? options.cwd : host.cwd(),
+				origin: "subagent",
+				...host.parentSessionId() !== void 0 ? { parentSession: host.parentSessionId() } : {}
+			}
+		});
+	} catch (error) {
+		throw new Error(`pi2dsh: subagent creation needs the DSH host loop (model runtime) to provide the agent factory; this composition cannot run one (${error instanceof Error ? error.message : String(error)})`);
+	}
+	const tools = [...Array.isArray(options.tools) ? options.tools : [], ...Array.isArray(options.customTools) ? options.customTools : []];
+	return { session: new PiBridgedAgentSession(host, handle, tools) };
+}
+//#endregion
 //#region src/runtime.ts
 function logger(ctx) {
 	const candidate = ctx.logger;
@@ -600,6 +817,7 @@ function contextFor(ctx, state, agent, signal, command = false) {
 		}
 	};
 	const session = agentSession(agent);
+	const providerConfig = (name) => state.providers.get(name);
 	const base = {
 		ui,
 		mode: "rpc",
@@ -615,12 +833,45 @@ function contextFor(ctx, state, agent, signal, command = false) {
 			find: (_provider, _modelId) => void 0,
 			getError: () => void 0,
 			hasConfiguredAuth: (_model) => false,
-			getProviderAuthStatus: (_provider) => "none",
-			getProvider: (_provider) => void 0,
-			getProviderDisplayName: (provider) => provider,
-			getProviderAuth: async (_provider) => void 0,
-			getApiKeyForProvider: async (_provider) => void 0,
-			isUsingOAuth: (_model) => false,
+			getProviderAuthStatus: (provider) => providerSupportsOAuth(providerConfig(provider)) ? "oauth" : "none",
+			getProvider: (provider) => providerConfig(provider),
+			getRegisteredProviderConfig: (provider) => providerConfig(provider),
+			getRegisteredProviderIds: () => [...state.providers.keys()],
+			getProviderDisplayName: (provider) => {
+				const config = providerConfig(provider);
+				return typeof config?.name === "string" ? config.name : provider;
+			},
+			getProviderAuth: async (provider) => {
+				const config = providerConfig(provider);
+				if (!providerSupportsOAuth(config)) return void 0;
+				if (await storedOAuthCredential(oauthStoreOf(state), provider) === void 0) return void 0;
+				const apiKey = await resolveOAuthApiKey({
+					providerId: provider,
+					providerConfig: config,
+					store: oauthStoreOf(state)
+				});
+				if (apiKey === void 0) return void 0;
+				return {
+					auth: {
+						apiKey,
+						baseUrl: config.baseUrl
+					},
+					source: "OAuth"
+				};
+			},
+			getApiKeyForProvider: async (provider) => {
+				const config = providerConfig(provider);
+				if (!providerSupportsOAuth(config)) return void 0;
+				return resolveOAuthApiKey({
+					providerId: provider,
+					providerConfig: config,
+					store: oauthStoreOf(state)
+				});
+			},
+			isUsingOAuth: (model) => {
+				const provider = String(model?.provider ?? "");
+				return provider.length > 0 && providerSupportsOAuth(providerConfig(provider));
+			},
 			refresh: async () => ({
 				models: [],
 				errors: []
@@ -988,8 +1239,42 @@ function subscribeInterceptors(ctx, state) {
 		};
 	});
 }
+function oauthStoreOf(state) {
+	state.oauthStore ??= new FileCredentialStore(join(getAgentDir(), "auth.json"));
+	return state.oauthStore;
+}
+function ensureLoginCommand(ctx, state) {
+	if (state.loginCommandRegistered === true) return;
+	state.loginCommandRegistered = true;
+	registerCommand(ctx, state, {
+		name: "login",
+		description: "Log in to a Pi provider through its own OAuth flow",
+		argumentHint: "<provider>",
+		async handler(args, commandContext) {
+			const oauthProviders = [...state.providers.entries()].filter(([, config]) => providerSupportsOAuth(config)).map(([name]) => name);
+			if (oauthProviders.length === 0) throw new Error("no registered Pi provider supports OAuth login");
+			const ui = commandContext.ui;
+			let providerId = args.trim().split(/\s+/u)[0] ?? "";
+			if (providerId.length === 0) providerId = oauthProviders.length === 1 ? oauthProviders[0] : String(await ui.select("Log in to which provider?", oauthProviders) ?? "");
+			const config = state.providers.get(providerId);
+			if (config === void 0 || !providerSupportsOAuth(config)) throw new Error(`unknown OAuth provider ${JSON.stringify(providerId)}; available: ${oauthProviders.join(", ")}`);
+			const oauthName = config.oauth?.name ?? providerId;
+			const commandSignal = commandContext.signal;
+			await loginPiProvider({
+				providerId,
+				providerName: oauthName,
+				providerConfig: config,
+				store: oauthStoreOf(state),
+				ui,
+				...commandSignal !== void 0 ? { signal: commandSignal } : {}
+			});
+			ui.notify(`Logged in to ${oauthName}; credential stored in ${oauthStoreOf(state).path}`);
+			return `Logged in to ${oauthName}`;
+		}
+	});
+}
 function registerTool(ctx, state, tool) {
-	if (state.tools.has(tool.name)) throw new Error(`Pi tool ${JSON.stringify(tool.name)} is already registered`);
+	if (state.tools.has(tool.name)) unregisterTool(state, tool.name);
 	const normalized = normalizeToolSchema(tool.parameters);
 	for (const warning of normalized.warnings) logger(ctx).warn(`[pi2dsh] tool ${tool.name}: ${warning}`);
 	state.tools.set(tool.name, tool);
@@ -1206,7 +1491,10 @@ function createPiApi(ctx, state) {
 			const name = typeof providerOrName === "string" ? providerOrName : String(providerOrName?.name ?? "unnamed");
 			const value = typeof providerOrName === "string" ? config ?? {} : providerOrName;
 			state.providers.set(name, value);
-			logger(ctx).info(`[pi2dsh] recorded Pi provider ${JSON.stringify(name)}; model calls stay on DSH llm adapters`);
+			if (providerSupportsOAuth(value)) {
+				ensureLoginCommand(ctx, state);
+				logger(ctx).info(`[pi2dsh] Pi provider ${JSON.stringify(name)} supports OAuth — log in with /login ${name}`);
+			} else logger(ctx).info(`[pi2dsh] recorded Pi provider ${JSON.stringify(name)}; model calls stay on DSH llm adapters`);
 		},
 		unregisterProvider(name) {
 			state.providers.delete(name);
@@ -1255,18 +1543,21 @@ function createPiApi(ctx, state) {
 			return executePiCommand(service, cwdOf(currentAgent(state)), command, args, options);
 		},
 		getActiveTools: () => getActiveTools(ctx, state),
-		getAllTools: () => toolRuntime(ctx, currentAgent(state)).schemas(currentAgent(state)).map((tool) => ({
-			name: tool.name,
-			description: tool.description ?? "",
-			parameters: tool.parameters ?? {},
-			source: state.tools.has(tool.name) ? "extension" : "builtin",
-			sourceInfo: {
-				path: "",
-				source: state.tools.has(tool.name) ? "pi2dsh" : "dsh",
-				scope: "session",
-				origin: "runtime"
-			}
-		})),
+		getAllTools: () => {
+			const visiblePiTools = new Set(state.runner.getAllRegisteredTools().map((record) => record.definition?.name).filter((name) => typeof name === "string"));
+			return toolRuntime(ctx, currentAgent(state)).schemas(currentAgent(state)).filter((tool) => !state.tools.has(tool.name) || visiblePiTools.has(tool.name)).map((tool) => ({
+				name: tool.name,
+				description: tool.description ?? "",
+				parameters: tool.parameters ?? {},
+				source: state.tools.has(tool.name) ? "extension" : "builtin",
+				sourceInfo: {
+					path: "",
+					source: state.tools.has(tool.name) ? "pi2dsh" : "dsh",
+					scope: "session",
+					origin: "runtime"
+				}
+			}));
+		},
 		setActiveTools: (names) => setActiveTools(ctx, state, names),
 		getCommands: () => [...state.commands.values()].map((command) => ({
 			name: command.name,
@@ -1439,9 +1730,20 @@ async function loadExtensions(rootDir, manifest, api, onExtensionError) {
 async function applyPiPackage(ctx, options) {
 	if (options.manifest.schemaVersion !== 1) throw new Error(`unsupported pi2dsh manifest version ${String(options.manifest.schemaVersion)}`);
 	const rootDir = fileURLToPath(options.rootUrl);
+	const runtimeTools = /* @__PURE__ */ new Map();
+	const piToolRecords = () => [...runtimeTools.values()].map((tool) => ({
+		definition: tool,
+		sourceInfo: {
+			path: "",
+			source: "pi2dsh",
+			scope: "session",
+			origin: "package"
+		}
+	}));
 	const state = {
 		handlers: /* @__PURE__ */ new Map(),
-		tools: /* @__PURE__ */ new Map(),
+		tools: runtimeTools,
+		runner: new ExtensionRunner(piToolRecords),
 		toolDisposers: /* @__PURE__ */ new Map(),
 		toolRestrictions: /* @__PURE__ */ new WeakMap(),
 		commands: /* @__PURE__ */ new Map(),
@@ -1471,6 +1773,12 @@ async function applyPiPackage(ctx, options) {
 	};
 	subscribeLifecycle(ctx, state);
 	subscribeInterceptors(ctx, state);
+	for (const provider of builtinProviders()) state.providers.set(provider.id, {
+		name: provider.name,
+		baseUrl: provider.baseUrl,
+		oauth: provider.auth.oauth
+	});
+	ensureLoginCommand(ctx, state);
 	if (options.manifest.skillDirs.length > 0) {
 		if (ctx.get("skills") === void 0) logger(ctx).warn("[pi2dsh] migrated skills were not mounted because this DSH composition has no ctx.skills");
 		else {
@@ -1483,6 +1791,19 @@ async function applyPiPackage(ctx, options) {
 			});
 		}
 	}
+	__setSubagentSessionFactory((subagentOptions) => createBridgedAgentSession({
+		cordis: ctx,
+		cwd: () => cwdOf(currentAgent(state)),
+		parentSessionId: () => {
+			const session = agentSession(currentAgent(state));
+			return session === void 0 ? void 0 : String(session.id ?? "") || void 0;
+		},
+		piContentToDsh: (content) => piToDshContent(ctx, content),
+		deliver: (agent, message, mode) => deliverAgentMessage(agent, message, mode),
+		messageFromSessionEvent,
+		messageSource: state.messageSource
+	}, subagentOptions));
+	ctx.effect(() => () => __setSubagentSessionFactory(void 0));
 	await registerPromptCommands(ctx, state, rootDir, options.manifest);
 	await loadExtensions(rootDir, options.manifest, createPiApi(ctx, state), (failure) => logger(ctx).warn(`[pi2dsh] extension entry failed and was skipped (matching Pi's per-extension error isolation): ${failure}`));
 	logger(ctx).info(`[pi2dsh] loaded ${options.manifest.package.name}: ${state.tools.size} tools, ${state.commands.size} commands, ${options.manifest.skillDirs.length} skill roots`);
@@ -1496,4 +1817,4 @@ const runtimeInternals = {
 //#endregion
 export { normalizeToolSchema as n, runtimeInternals as r, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-D84Hv_3m.mjs.map
+//# sourceMappingURL=runtime-6DefpI6h.mjs.map