pi2dsh 0.10.0 → 0.12.0

package/dist/{runtime-Ce3PTbWU.mjs → runtime-Bh5k4Kjt.mjs}

@@ -1,5 +1,5 @@
 
-import { F as AssistantMessageEventStream, a as builtinProviders, i as __setPiAiLlmBridge } from "./pi-ai-Dyg4zyLZ.mjs";
+import { F as AssistantMessageEventStream, a as builtinProviders, h as getSupportedThinkingLevels, i as __setPiAiLlmBridge } from "./pi-ai-Dyg4zyLZ.mjs";
 import { P as generateBranchSummary, Tn as PiCapabilityError, b as Theme, d as ExtensionRunner, w as __setSubagentSessionFactory, wn as CapabilityLedger } from "./pi-coding-agent-Ctw-BhoY.mjs";
 import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
 import { a as resolvePiProviderAuth, n as loginPiProvider, r as providerSupportsOAuth, t as FileCredentialStore } from "./oauth-bridge-CfyImWx4.mjs";
@@ -303,9 +303,22 @@ var PiSessionBridge = class {
 //#endregion
 //#region src/subagent-bridge.ts
 let subagentSerial = 0;
+/** Flatten a Pi message's content to text for transcript seeding. */
+function piMessageText(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((block) => {
+		const record = block;
+		if (record?.type === "text" && typeof record.text === "string") return record.text;
+		if (record?.type === "toolCall" && typeof record.name === "string") return `(tool ${record.name})`;
+		return "";
+	}).filter((text) => text.length > 0).join("\n");
+}
 var PiBridgedAgentSession = class {
 	agent = {};
 	messages = [];
+	#seed = [];
 	#host;
 	#handle;
 	#session;
@@ -313,6 +326,10 @@ var PiBridgedAgentSession = class {
 	#subscribers = /* @__PURE__ */ new Set();
 	#disposers = [];
 	#activeToolNames;
+	#state;
+	#model;
+	#streaming = false;
+	#pendingToolCalls = /* @__PURE__ */ new Set();
 	#sessionName = "";
 	#turns = 0;
 	#aborted = false;
@@ -341,6 +358,51 @@ var PiBridgedAgentSession = class {
 			return next();
 		});
 		this.#disposers.push(offEvents, offPre);
+		const session = this;
+		this.#state = {
+			get systemPrompt() {
+				return "";
+			},
+			get model() {
+				return session.#model;
+			},
+			get thinkingLevel() {
+				return "off";
+			},
+			get tools() {
+				return [...session.#tools];
+			},
+			set tools(_next) {},
+			get messages() {
+				return [...session.messages];
+			},
+			set messages(next) {
+				session.#assignTranscript(next);
+			},
+			get isStreaming() {
+				return session.#streaming;
+			},
+			get pendingToolCalls() {
+				return new Set(session.#pendingToolCalls);
+			}
+		};
+		this.agent.state = this.#state;
+	}
+	/** Pi's AgentState projection, shared by `session.state` and `session.agent.state`. */
+	get state() {
+		return this.#state;
+	}
+	/**
+	* Pi's `state.messages = …` assignment. Messages already present in this
+	* child's projection stay as they are (they are durable); anything new is
+	* queued and delivered with the next prompt so the child model really sees
+	* the transcript the package seeded.
+	*/
+	#assignTranscript(next) {
+		const identity = (message) => JSON.stringify([message.role, message.content]);
+		const known = new Set(this.messages.map(identity));
+		this.#seed = next.filter((message) => !known.has(identity(message)));
+		for (const message of this.#seed) this.messages.push(message);
 	}
 	#project(event) {
 		const type = event.type;
@@ -349,12 +411,27 @@ var PiBridgedAgentSession = class {
 				handler(piEvent);
 			} catch {}
 		};
-		if (type === "turn/start") emit({
-			type: "turn_start",
-			turnIndex: Number(event.data.turn ?? 1) - 1
-		});
+		if (type === "turn/start") {
+			this.#streaming = true;
+			emit({
+				type: "turn_start",
+				turnIndex: Number(event.data.turn ?? 1) - 1
+			});
+		}
+		if (type === "request/header") {
+			const config = event.data.config ?? {};
+			if (typeof config.model === "string") this.#model = {
+				id: config.model,
+				provider: String(config.provider ?? "")
+			};
+		}
+		if (type === "tools/result" || type === "tool/result") {
+			const data = event.data;
+			this.#pendingToolCalls.delete(String(data.callId ?? ""));
+		}
 		if (type === "tool/call") {
 			const data = event.data;
+			this.#pendingToolCalls.add(String(data.callId ?? ""));
 			let args = {};
 			try {
 				args = JSON.parse(String(data.arguments ?? "{}"));
@@ -401,6 +478,8 @@ var PiBridgedAgentSession = class {
 		}
 		if (type === "turn/end") {
 			this.#turns += 1;
+			this.#streaming = false;
+			this.#pendingToolCalls.clear();
 			emit({
 				type: "turn_end",
 				turnIndex: Number(event.data.turn ?? 1) - 1,
@@ -417,6 +496,28 @@ var PiBridgedAgentSession = class {
 		return () => this.#subscribers.delete(handler);
 	}
 	async prompt(text) {
+		if (this.#seed.length > 0) {
+			const seeded = this.#seed;
+			this.#seed = [];
+			const rendered = seeded.map((message) => {
+				const role = String(message.role ?? "user");
+				const content = piMessageText(message);
+				return content.length === 0 ? void 0 : `[${role}]: ${content}`;
+			}).filter((line) => line !== void 0);
+			if (rendered.length > 0) {
+				const seedBlocks = await this.#host.piContentToDsh([{
+					type: "text",
+					text: `<prior-conversation>\n${rendered.join("\n\n")}\n</prior-conversation>`
+				}]);
+				this.#host.deliver(this.#handle.agent, createUserMessage({
+					content: seedBlocks,
+					source: {
+						kind: "plugin",
+						plugin: this.#host.messageSource
+					}
+				}), "inject");
+			}
+		}
 		const blocks = await this.#host.piContentToDsh([{
 			type: "text",
 			text: String(text)
@@ -496,6 +597,18 @@ var PiBridgedAgentSession = class {
 		await this.#handle.dispose();
 	}
 };
+/**
+* The name DSH's own child catalog shows for a side thread. Pi packages rarely
+* label a child, so the package that started it is the honest fallback: with
+* several Pi packages installed, their threads stay apart in one list.
+* @param requested - a label the calling package supplied, if any.
+* @param packageName - the Pi package the call came from.
+*/
+function childLabel(requested, packageName) {
+	if (typeof requested === "string" && requested.trim().length > 0) return requested.trim().slice(0, 80);
+	const owner = packageName?.trim();
+	return owner === void 0 || owner.length === 0 ? "Pi side conversation" : `${owner} side conversation`;
+}
 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");
@@ -536,6 +649,17 @@ async function createBridgedAgentSession(host, options) {
 		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 : []];
+	const childSession = handle.agent.session;
+	if (typeof childSession?.append === "function") try {
+		childSession.append("subagent/descriptor", {
+			version: 2,
+			mode: "continuable",
+			provider: "pi2dsh",
+			label: childLabel(options.label, host.packageName)
+		});
+	} catch (error) {
+		host.cordis.logger?.warn?.(`[pi2dsh] child session could not record its subagent identity: ${error instanceof Error ? error.message : String(error)}`);
+	}
 	return { session: new PiBridgedAgentSession(host, handle, tools) };
 }
 //#endregion
@@ -1155,6 +1279,33 @@ const PI_CARRIED_FIELDS = [
 	"compat",
 	"headers"
 ];
+/**
+* Pi's reasoning capability, in DSH's shape.
+*
+* The two sides say the same thing differently: Pi carries a `reasoning`
+* boolean plus a `thinkingLevelMap` whose `null` entries mark unsupported
+* levels, while DSH asks an adapter for the selectable efforts directly.
+* Translating is this layer's job — carrying Pi's boolean through under the
+* name `reasoning` would collide with DSH's `{efforts}` object, and carrying
+* nothing (what this bridge did before) leaves every package-registered route
+* with no selectable effort at all, so any reasoning request is rejected.
+*
+* The mapping is DSH's own: its native pi-ai adapter derives efforts from
+* `getSupportedThinkingLevels` and names them the same way, so a route a Pi
+* package registers offers exactly the efforts it would through the host's
+* own adapter. It belongs to the exact-route resolve, not the catalog listing
+* — `reasoning` is a resolved-model field in DSH's contract.
+* @param model - the Pi model descriptor as its package declared it.
+*/
+function reasoningProjection(model) {
+	if (model.reasoning !== true) return {};
+	const levels = getSupportedThinkingLevels(model);
+	if (levels.length === 0) return {};
+	return { reasoning: { efforts: levels.map((level) => ({
+		id: level,
+		name: `${level.charAt(0).toUpperCase()}${level.slice(1)}`
+	})) } };
+}
 function piCarriedFields(model) {
 	const carried = {};
 	for (const field of PI_CARRIED_FIELDS) if (model[field] !== void 0) carried[field] = model[field];
@@ -1182,6 +1333,7 @@ function piProviderDshAdapter(providerId, provider, host) {
 			const known = providerModels(provider).find((model) => model.id === modelId);
 			return {
 				...known === void 0 ? {} : piCarriedFields(known),
+				...known === void 0 ? {} : reasoningProjection(known),
 				provider: id,
 				id: modelId,
 				name: String(known?.name ?? modelId),
@@ -1203,7 +1355,8 @@ function piProviderDshAdapter(providerId, provider, host) {
 				...auth?.headers === void 0 ? {} : { headers: auth.headers },
 				...options.signal instanceof AbortSignal ? { signal: options.signal } : {},
 				...typeof options.maxTokens === "number" ? { maxTokens: options.maxTokens } : {},
-				...typeof options.temperature === "number" ? { temperature: options.temperature } : {}
+				...typeof options.temperature === "number" ? { temperature: options.temperature } : {},
+				...typeof options.reasoningEffort === "string" ? { reasoningEffort: options.reasoningEffort } : {}
 			};
 			yield* piEventsToDshChunks(provider.stream(model, piContext, piOptions));
 		}
@@ -2908,7 +3061,7 @@ function registerCommand(ctx, state, command) {
 	const definitionFor = (dshName) => ({
 		name: dshName,
 		description: command.description || `Migrated Pi command /${command.name}`,
-		...command.argumentHint !== void 0 ? { input: { hint: command.argumentHint } } : {},
+		input: { hint: command.argumentHint ?? "arguments (optional)" },
 		async handler(invocation) {
 			const agent = invocation.agent;
 			const commandContext = contextFor(ctx, state, agent, invocation.signal, true);
@@ -3368,7 +3521,8 @@ async function applyPiPackage(ctx, options) {
 		piContentToDsh: (content) => piToDshContent(ctx, content),
 		deliver: (agent, message, mode) => deliverAgentMessage(agent, message, mode),
 		messageFromSessionEvent,
-		messageSource: state.messageSource
+		messageSource: state.messageSource,
+		packageName: state.packageName
 	}, subagentOptions));
 	ctx.effect(() => () => __setSubagentSessionFactory(void 0));
 	await registerPromptCommands(ctx, state, rootDir, options.manifest);
@@ -3410,4 +3564,4 @@ const runtimeInternals = {
 //#endregion
 export { runtimeInternals as i, normalizeToolSchema as n, registerVisionCompanions as r, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-Ce3PTbWU.mjs.map
+//# sourceMappingURL=runtime-Bh5k4Kjt.mjs.map