pi2dsh 0.3.4 → 0.4.0

package/dist/{runtime-B9R7bDWT.mjs → runtime-B7mEIRf-.mjs}

@@ -1,8 +1,8 @@
 
-import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
-import { E as __setSubagentSessionFactory, S as Theme, f as ExtensionRunner } from "./pi-coding-agent-fPHwKP4d.mjs";
+import { C as realBuiltinProvider, R as AssistantMessageEventStream, S as openAIResponsesApi, a as builtinProviders, i as anthropicMessagesApi, r as __setPiAiLlmBridge, x as openAICompletionsApi } from "./pi-ai-B_88Wb0r.mjs";
+import { r as normalizePath, t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
+import { E as __setSubagentSessionFactory, S as Theme, f as ExtensionRunner } from "./pi-coding-agent-COMX0KHL.mjs";
 import { a as resolvePiProviderAuth, n as loginPiProvider, r as providerSupportsOAuth, t as FileCredentialStore } from "./oauth-bridge-C6fL1qSv.mjs";
-import { L as AssistantMessageEventStream, S as realBuiltinProvider, i as builtinProviders, n as __setPiAiLlmBridge } from "./pi-ai-DhYGgq4Y.mjs";
 import { createRequire } from "node:module";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -14,6 +14,9 @@ import { createJiti } from "jiti";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
 import { randomUUID } from "node:crypto";
+import { execSync, spawnSync } from "child_process";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
 //#region src/session-bridge.ts
 function sidecarDir() {
 	return join(getAgentDir(), "session-entries");
@@ -526,15 +529,28 @@ function llmOf(ctx) {
 		return;
 	}
 }
+const PI_MODEL_PASSTHROUGH_FIELDS = [
+	"baseUrl",
+	"cost",
+	"contextWindow",
+	"maxTokens",
+	"samplingParams",
+	"thinkingLevelMap",
+	"compat",
+	"headers"
+];
 function piModelFromInfo(info) {
 	const modalities = Array.isArray(info.inputModalities) ? info.inputModalities : void 0;
+	const carried = {};
+	for (const field of PI_MODEL_PASSTHROUGH_FIELDS) if (info[field] !== void 0) carried[field] = info[field];
 	return {
+		...carried,
 		id: String(info.id ?? ""),
 		name: String(info.name ?? info.id ?? ""),
 		provider: String(info.provider ?? ""),
-		api: "dsh-llm",
+		api: typeof info.api === "string" ? info.api : "faux",
 		input: modalities === void 0 ? ["text"] : modalities.filter((m) => m === "text" || m === "image"),
-		reasoning: info.reasoning !== void 0
+		reasoning: typeof info.reasoning === "boolean" ? info.reasoning : info.reasoning !== void 0
 	};
 }
 /**
@@ -726,7 +742,7 @@ function streamViaDshLlm(llm, request) {
 			content: [],
 			provider,
 			model: modelId,
-			api: "dsh-llm"
+			api: "faux"
 		};
 		const content = partial.content;
 		let usage;
@@ -882,7 +898,7 @@ function streamViaDshLlm(llm, request) {
 						content: content.filter((block) => block !== void 0),
 						provider,
 						model: modelId,
-						api: "dsh-llm",
+						api: "faux",
 						...usage === void 0 ? {} : { usage },
 						stopReason,
 						timestamp: Date.now()
@@ -1096,7 +1112,820 @@ async function* piEventsToDshChunks(events) {
 	};
 }
 //#endregion
+//#region src/compat/vendor/pi-json.ts
+/** Strip `//` line comments and trailing commas from JSON, leaving string literals untouched. */
+function stripJsonComments(input) {
+	return input.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => m[0] === "\"" ? m : "").replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === "\"" ? m : ""));
+}
+//#endregion
+//#region src/compat/vendor/pi-model-config.ts
+/** Immutable, credential-blind models.json snapshot. */
+const PercentileCutoffsSchema = Type.Object({
+	p50: Type.Optional(Type.Number()),
+	p75: Type.Optional(Type.Number()),
+	p90: Type.Optional(Type.Number()),
+	p99: Type.Optional(Type.Number())
+});
+const OpenRouterRoutingSchema = Type.Object({
+	allow_fallbacks: Type.Optional(Type.Boolean()),
+	require_parameters: Type.Optional(Type.Boolean()),
+	data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
+	zdr: Type.Optional(Type.Boolean()),
+	enforce_distillable_text: Type.Optional(Type.Boolean()),
+	order: Type.Optional(Type.Array(Type.String())),
+	only: Type.Optional(Type.Array(Type.String())),
+	ignore: Type.Optional(Type.Array(Type.String())),
+	quantizations: Type.Optional(Type.Array(Type.String())),
+	sort: Type.Optional(Type.Union([Type.String(), Type.Object({
+		by: Type.Optional(Type.String()),
+		partition: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+	})])),
+	max_price: Type.Optional(Type.Object({
+		prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+		completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+		image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+		audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+		request: Type.Optional(Type.Union([Type.Number(), Type.String()]))
+	})),
+	preferred_min_throughput: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
+	preferred_max_latency: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema]))
+});
+const VercelGatewayRoutingSchema = Type.Object({
+	only: Type.Optional(Type.Array(Type.String())),
+	order: Type.Optional(Type.Array(Type.String()))
+});
+const ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]);
+const ThinkingLevelMapSchema = Type.Object({
+	off: Type.Optional(ThinkingLevelMapValueSchema),
+	minimal: Type.Optional(ThinkingLevelMapValueSchema),
+	low: Type.Optional(ThinkingLevelMapValueSchema),
+	medium: Type.Optional(ThinkingLevelMapValueSchema),
+	high: Type.Optional(ThinkingLevelMapValueSchema),
+	xhigh: Type.Optional(ThinkingLevelMapValueSchema),
+	max: Type.Optional(ThinkingLevelMapValueSchema)
+});
+const ChatTemplateKwargScalarSchema = Type.Union([
+	Type.String(),
+	Type.Number(),
+	Type.Boolean(),
+	Type.Null()
+]);
+const ChatTemplateKwargVariableSchema = Type.Object({
+	$var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
+	omitWhenOff: Type.Optional(Type.Boolean())
+});
+const ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]);
+const OpenAICompletionsCompatSchema = Type.Object({
+	supportsStore: Type.Optional(Type.Boolean()),
+	supportsDeveloperRole: Type.Optional(Type.Boolean()),
+	supportsReasoningEffort: Type.Optional(Type.Boolean()),
+	supportsUsageInStreaming: Type.Optional(Type.Boolean()),
+	maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+	requiresToolResultName: Type.Optional(Type.Boolean()),
+	requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
+	requiresThinkingAsText: Type.Optional(Type.Boolean()),
+	requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
+	thinkingFormat: Type.Optional(Type.Union([
+		Type.Literal("openai"),
+		Type.Literal("openrouter"),
+		Type.Literal("together"),
+		Type.Literal("baseten"),
+		Type.Literal("deepseek"),
+		Type.Literal("zai"),
+		Type.Literal("qwen"),
+		Type.Literal("chat-template"),
+		Type.Literal("qwen-chat-template"),
+		Type.Literal("string-thinking"),
+		Type.Literal("ant-ling")
+	])),
+	chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
+	chatTemplateArgs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
+	cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
+	openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
+	vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
+	supportsOpenAIGrammarTools: Type.Optional(Type.Boolean()),
+	supportsStrictMode: Type.Optional(Type.Boolean()),
+	sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+	deferredToolsMode: Type.Optional(Type.Literal("kimi")),
+	sessionAffinityFormat: Type.Optional(Type.Union([
+		Type.Literal("openai"),
+		Type.Literal("openai-nosession"),
+		Type.Literal("openrouter")
+	])),
+	supportsLongCacheRetention: Type.Optional(Type.Boolean())
+});
+const OpenAIResponsesCompatSchema = Type.Object({
+	supportsDeveloperRole: Type.Optional(Type.Boolean()),
+	sessionAffinityFormat: Type.Optional(Type.Union([
+		Type.Literal("openai"),
+		Type.Literal("openai-nosession"),
+		Type.Literal("openrouter")
+	])),
+	supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+	supportsStrictMode: Type.Optional(Type.Boolean()),
+	supportsOpenAIGrammarTools: Type.Optional(Type.Boolean()),
+	supportsAdditionalTools: Type.Optional(Type.Boolean()),
+	supportsToolSearch: Type.Optional(Type.Boolean())
+});
+const AnthropicMessagesCompatSchema = Type.Object({
+	supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
+	supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+	sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+	supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
+	supportsTemperature: Type.Optional(Type.Boolean()),
+	forceAdaptiveThinking: Type.Optional(Type.Boolean()),
+	allowEmptySignature: Type.Optional(Type.Boolean()),
+	supportsStrictTools: Type.Optional(Type.Boolean()),
+	supportsToolReferences: Type.Optional(Type.Boolean())
+});
+const ProviderCompatSchema = Type.Union([
+	OpenAICompletionsCompatSchema,
+	OpenAIResponsesCompatSchema,
+	AnthropicMessagesCompatSchema
+]);
+const ModelCostRatesSchema = {
+	input: Type.Number(),
+	output: Type.Number(),
+	cacheRead: Type.Number(),
+	cacheWrite: Type.Number()
+};
+const ModelCostTierSchema = Type.Object({
+	inputTokensAbove: Type.Number(),
+	...ModelCostRatesSchema
+});
+const ModelCostSchema = Type.Object({
+	...ModelCostRatesSchema,
+	tiers: Type.Optional(Type.Array(ModelCostTierSchema))
+});
+const ModelDefinitionSchema = Type.Object({
+	id: Type.String({ minLength: 1 }),
+	name: Type.Optional(Type.String({ minLength: 1 })),
+	api: Type.Optional(Type.String({ minLength: 1 })),
+	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+	reasoning: Type.Optional(Type.Boolean()),
+	thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+	cost: Type.Optional(ModelCostSchema),
+	contextWindow: Type.Optional(Type.Number()),
+	maxTokens: Type.Optional(Type.Number()),
+	samplingParams: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	compat: Type.Optional(ProviderCompatSchema)
+});
+const ModelOverrideSchema = Type.Object({
+	name: Type.Optional(Type.String({ minLength: 1 })),
+	reasoning: Type.Optional(Type.Boolean()),
+	thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+	cost: Type.Optional(Type.Object({
+		input: Type.Optional(Type.Number()),
+		output: Type.Optional(Type.Number()),
+		cacheRead: Type.Optional(Type.Number()),
+		cacheWrite: Type.Optional(Type.Number()),
+		tiers: Type.Optional(Type.Array(ModelCostTierSchema))
+	})),
+	contextWindow: Type.Optional(Type.Number()),
+	maxTokens: Type.Optional(Type.Number()),
+	samplingParams: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	compat: Type.Optional(ProviderCompatSchema)
+});
+const ProviderConfigSchema = Type.Object({
+	name: Type.Optional(Type.String({ minLength: 1 })),
+	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+	apiKey: Type.Optional(Type.String({ minLength: 1 })),
+	api: Type.Optional(Type.String({ minLength: 1 })),
+	oauth: Type.Optional(Type.Literal("radius")),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	compat: Type.Optional(ProviderCompatSchema),
+	authHeader: Type.Optional(Type.Boolean()),
+	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
+	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema))
+});
+const ModelsConfigSchema = Type.Object({ providers: Type.Record(Type.String(), ProviderConfigSchema) });
+const validateModelsConfig = Compile(ModelsConfigSchema);
+function formatValidationPath(error) {
+	if (error.keyword === "required") {
+		const requiredProperty = error.params.requiredProperties?.[0];
+		if (requiredProperty) {
+			const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+			return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+		}
+	}
+	return error.instancePath.replace(/^\//, "").replace(/\//g, ".") || "root";
+}
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	for (const child of Object.values(value)) deepFreeze(child);
+	return Object.freeze(value);
+}
+/** One immutable load of models.json. */
+var ModelConfig = class ModelConfig {
+	providers;
+	error;
+	constructor(providers, error) {
+		this.providers = providers;
+		this.error = error;
+	}
+	static async load(modelsJsonPath) {
+		if (!modelsJsonPath) return new ModelConfig(/* @__PURE__ */ new Map());
+		const path = normalizePath(modelsJsonPath);
+		let content;
+		try {
+			content = await readFile(path, "utf-8");
+		} catch (error) {
+			if (error.code === "ENOENT") return new ModelConfig(/* @__PURE__ */ new Map());
+			return new ModelConfig(/* @__PURE__ */ new Map(), `Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${path}`);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(stripJsonComments(content));
+		} catch (error) {
+			return new ModelConfig(/* @__PURE__ */ new Map(), `Failed to parse models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${path}`);
+		}
+		if (!validateModelsConfig.Check(parsed)) {
+			const errors = validateModelsConfig.Errors(parsed).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join("\n") || "Unknown schema error";
+			return new ModelConfig(/* @__PURE__ */ new Map(), `Invalid models.json schema:\n${errors}\n\nFile: ${path}`);
+		}
+		const config = parsed;
+		const providers = /* @__PURE__ */ new Map();
+		for (const [providerId, provider] of Object.entries(config.providers)) providers.set(providerId, deepFreeze(structuredClone(provider)));
+		return new ModelConfig(providers);
+	}
+	getProvider(providerId) {
+		return this.providers.get(providerId);
+	}
+	getProviderIds() {
+		return [...this.providers.keys()];
+	}
+	getError() {
+		return this.error;
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-models-compose.ts
+function mergeCompat(base, override) {
+	if (!override) return base;
+	const merged = {
+		...base,
+		...override
+	};
+	const baseNested = base;
+	const overrideNested = override;
+	const mergedNested = merged;
+	for (const key of [
+		"openRouterRouting",
+		"vercelGatewayRouting",
+		"chatTemplateKwargs",
+		"chatTemplateArgs"
+	]) {
+		const baseValue = baseNested?.[key];
+		const overrideValue = overrideNested[key];
+		if (typeof baseValue === "object" && baseValue !== null || typeof overrideValue === "object" && overrideValue !== null) mergedNested[key] = {
+			...baseValue,
+			...overrideValue
+		};
+	}
+	return merged;
+}
+function applyModelOverride(model, override) {
+	return {
+		...model,
+		name: override.name ?? model.name,
+		reasoning: override.reasoning ?? model.reasoning,
+		thinkingLevelMap: override.thinkingLevelMap ? {
+			...model.thinkingLevelMap,
+			...override.thinkingLevelMap
+		} : model.thinkingLevelMap,
+		input: override.input ?? model.input,
+		cost: override.cost ? {
+			input: override.cost.input ?? model.cost.input,
+			output: override.cost.output ?? model.cost.output,
+			cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
+			cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
+			tiers: override.cost.tiers ?? model.cost.tiers
+		} : model.cost,
+		contextWindow: override.contextWindow ?? model.contextWindow,
+		maxTokens: override.maxTokens ?? model.maxTokens,
+		samplingParams: override.samplingParams ? {
+			...model.samplingParams,
+			...override.samplingParams
+		} : model.samplingParams,
+		compat: mergeCompat(model.compat, override.compat)
+	};
+}
+function modelFromJson(providerId, definition, providerConfig, defaults) {
+	const api = definition.api ?? providerConfig.api ?? defaults?.api;
+	if (!api) throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
+	const baseUrl = definition.baseUrl ?? providerConfig.baseUrl ?? defaults?.baseUrl;
+	if (!baseUrl) throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+	if (definition.contextWindow !== void 0 && definition.contextWindow <= 0) throw new Error(`Provider ${providerId}, model ${definition.id}: invalid contextWindow`);
+	if (definition.maxTokens !== void 0 && definition.maxTokens <= 0) throw new Error(`Provider ${providerId}, model ${definition.id}: invalid maxTokens`);
+	return {
+		id: definition.id,
+		name: definition.name ?? definition.id,
+		api,
+		provider: providerId,
+		baseUrl,
+		reasoning: definition.reasoning ?? false,
+		thinkingLevelMap: definition.thinkingLevelMap,
+		input: definition.input ?? ["text"],
+		cost: definition.cost ?? {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: definition.contextWindow ?? 128e3,
+		maxTokens: definition.maxTokens ?? 16384,
+		samplingParams: definition.samplingParams,
+		headers: void 0,
+		compat: mergeCompat(providerConfig.compat, definition.compat)
+	};
+}
+function applyModelsJson(providerId, baseModels, config) {
+	if (!config) return [...baseModels];
+	if (config.oauth && !config.baseUrl) throw new Error(`Provider ${providerId}: "baseUrl" is required when "oauth" is set.`);
+	const hasOverrides = config.modelOverrides && Object.keys(config.modelOverrides).length > 0;
+	if (!config.models?.length && !config.baseUrl && !config.headers && !config.compat && !hasOverrides && !config.apiKey && !config.oauth && config.authHeader === void 0) throw new Error(`Provider ${providerId}: must specify "baseUrl", "headers", "compat", "modelOverrides", or "models".`);
+	const models = baseModels.map((model) => ({
+		...model,
+		baseUrl: config.oauth === "radius" ? model.baseUrl : config.baseUrl ?? model.baseUrl,
+		compat: mergeCompat(model.compat, config.compat)
+	}));
+	for (const definition of config.models ?? []) {
+		const existingIndex = models.findIndex((model) => model.id === definition.id);
+		const model = modelFromJson(providerId, definition, config, existingIndex >= 0 ? models[existingIndex] : models[0]);
+		if (existingIndex >= 0) models[existingIndex] = model;
+		else models.push(model);
+	}
+	return models;
+}
+//#endregion
+//#region src/compat/vendor/pi-shell-config.ts
+function isLegacyWslBashPath(path) {
+	const normalized = path.replace(/\//g, "\\").toLowerCase();
+	return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized);
+}
+function getBashShellConfig(shell) {
+	return isLegacyWslBashPath(shell) ? {
+		shell,
+		args: ["-s"],
+		commandTransport: "stdin"
+	} : {
+		shell,
+		args: ["-c"]
+	};
+}
+function findBashOnPath() {
+	if (process.platform === "win32") {
+		try {
+			const result = spawnSync("where", ["bash.exe"], {
+				encoding: "utf-8",
+				timeout: 5e3,
+				windowsHide: true
+			});
+			if (result.status === 0 && result.stdout) {
+				const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+				if (firstMatch && existsSync(firstMatch)) return firstMatch;
+			}
+		} catch {}
+		return null;
+	}
+	try {
+		const result = spawnSync("which", ["bash"], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		if (result.status === 0 && result.stdout) {
+			const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+			if (firstMatch) return firstMatch;
+		}
+	} catch {}
+	return null;
+}
+/**
+* Resolve shell configuration based on platform and an optional explicit shell path.
+* Resolution order:
+* 1. User-specified shellPath
+* 2. On Windows: Git Bash in known locations, then bash on PATH
+* 3. On Unix: /bin/bash, then bash on PATH, then fallback to sh
+*/
+function getShellConfig(customShellPath) {
+	if (customShellPath) {
+		if (existsSync(customShellPath)) return getBashShellConfig(customShellPath);
+		throw new Error(`Custom shell path not found: ${customShellPath}`);
+	}
+	if (process.platform === "win32") {
+		const paths = [];
+		const programFiles = process.env.ProgramFiles;
+		if (programFiles) paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+		const programFilesX86 = process.env["ProgramFiles(x86)"];
+		if (programFilesX86) paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+		for (const path of paths) if (existsSync(path)) return getBashShellConfig(path);
+		const bashOnPath = findBashOnPath();
+		if (bashOnPath) return getBashShellConfig(bashOnPath);
+		throw new Error(`No bash shell found. Options:
+  1. Install Git for Windows: https://git-scm.com/download/win
+  2. Add your bash to PATH (Cygwin, MSYS2, etc.)
+  3. Set shellPath in settings.json
+
+Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`);
+	}
+	if (existsSync("/bin/bash")) return getBashShellConfig("/bin/bash");
+	const bashOnPath = findBashOnPath();
+	if (bashOnPath) return getBashShellConfig(bashOnPath);
+	return {
+		shell: "sh",
+		args: ["-c"]
+	};
+}
+//#endregion
+//#region src/compat/vendor/pi-resolve-config-value.ts
+/**
+* Resolve configuration values that may be shell commands, environment variables, or literals.
+* Used by auth-storage.ts and model-registry.ts.
+*/
+const ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
+function appendLiteral(parts, value) {
+	if (!value) return;
+	const previousPart = parts[parts.length - 1];
+	if (previousPart?.type === "literal") {
+		previousPart.value += value;
+		return;
+	}
+	parts.push({
+		type: "literal",
+		value
+	});
+}
+function parseConfigValueTemplate(config) {
+	const parts = [];
+	let index = 0;
+	while (index < config.length) {
+		const dollarIndex = config.indexOf("$", index);
+		if (dollarIndex < 0) {
+			appendLiteral(parts, config.slice(index));
+			break;
+		}
+		appendLiteral(parts, config.slice(index, dollarIndex));
+		const nextChar = config[dollarIndex + 1];
+		if (nextChar === "$" || nextChar === "!") {
+			appendLiteral(parts, nextChar);
+			index = dollarIndex + 2;
+			continue;
+		}
+		if (nextChar === "{") {
+			const endIndex = config.indexOf("}", dollarIndex + 2);
+			if (endIndex < 0) {
+				appendLiteral(parts, "$");
+				index = dollarIndex + 1;
+				continue;
+			}
+			const name = config.slice(dollarIndex + 2, endIndex);
+			if (ENV_VAR_NAME_RE.test(name)) parts.push({
+				type: "env",
+				name
+			});
+			else appendLiteral(parts, config.slice(dollarIndex, endIndex + 1));
+			index = endIndex + 1;
+			continue;
+		}
+		const match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
+		if (match) {
+			parts.push({
+				type: "env",
+				name: match[0]
+			});
+			index = dollarIndex + 1 + match[0].length;
+			continue;
+		}
+		appendLiteral(parts, "$");
+		index = dollarIndex + 1;
+	}
+	return parts;
+}
+function parseConfigValueReference(config) {
+	if (config.startsWith("!")) return {
+		type: "command",
+		config
+	};
+	return {
+		type: "template",
+		parts: parseConfigValueTemplate(config)
+	};
+}
+function resolveEnvConfigValue(name, env) {
+	return env?.[name] || process.env[name] || void 0;
+}
+function getTemplateEnvVarNames(parts) {
+	const names = [];
+	for (const part of parts) {
+		if (part.type !== "env" || names.includes(part.name)) continue;
+		names.push(part.name);
+	}
+	return names;
+}
+function resolveTemplate(parts, env) {
+	let resolved = "";
+	for (const part of parts) {
+		if (part.type === "literal") {
+			resolved += part.value;
+			continue;
+		}
+		const envValue = resolveEnvConfigValue(part.name, env);
+		if (envValue === void 0) return void 0;
+		resolved += envValue;
+	}
+	return resolved;
+}
+function getConfigValueEnvVarNames(config) {
+	const reference = parseConfigValueReference(config);
+	return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
+}
+function getMissingConfigValueEnvVarNames(config, env) {
+	return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === void 0);
+}
+function isCommandConfigValue(config) {
+	return parseConfigValueReference(config).type === "command";
+}
+function isConfigValueConfigured(config, env) {
+	return getMissingConfigValueEnvVarNames(config, env).length === 0;
+}
+function executeWithConfiguredShell(command) {
+	try {
+		const { shell, args, commandTransport } = getShellConfig();
+		const commandFromStdin = commandTransport === "stdin";
+		const result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
+			encoding: "utf-8",
+			input: commandFromStdin ? command : void 0,
+			timeout: 1e4,
+			stdio: [
+				commandFromStdin ? "pipe" : "ignore",
+				"pipe",
+				"ignore"
+			],
+			shell: false,
+			windowsHide: true
+		});
+		if (result.error) {
+			if (result.error.code === "ENOENT") return {
+				executed: false,
+				value: void 0
+			};
+			return {
+				executed: true,
+				value: void 0
+			};
+		}
+		if (result.status !== 0) return {
+			executed: true,
+			value: void 0
+		};
+		return {
+			executed: true,
+			value: (result.stdout ?? "").trim() || void 0
+		};
+	} catch {
+		return {
+			executed: false,
+			value: void 0
+		};
+	}
+}
+function executeWithDefaultShell(command) {
+	try {
+		return execSync(command, {
+			encoding: "utf-8",
+			timeout: 1e4,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function executeCommandUncached(commandConfig) {
+	const command = commandConfig.slice(1);
+	return process.platform === "win32" ? (() => {
+		const configuredResult = executeWithConfiguredShell(command);
+		return configuredResult.executed ? configuredResult.value : executeWithDefaultShell(command);
+	})() : executeWithDefaultShell(command);
+}
+/**
+* Resolve all header values using the same resolution logic as API keys.
+*/
+function resolveConfigValueUncached(config, env) {
+	const reference = parseConfigValueReference(config);
+	if (reference.type === "command") return executeCommandUncached(reference.config);
+	return resolveTemplate(reference.parts, env);
+}
+function resolveConfigValueOrThrow(config, description, env) {
+	const resolvedValue = resolveConfigValueUncached(config, env);
+	if (resolvedValue !== void 0) return resolvedValue;
+	const reference = parseConfigValueReference(config);
+	if (reference.type === "command") throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
+	if (reference.type === "template") {
+		const missingEnvVars = getMissingConfigValueEnvVarNames(config, env);
+		if (missingEnvVars.length === 1) throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
+		if (missingEnvVars.length > 1) throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
+	}
+	throw new Error(`Failed to resolve ${description}`);
+}
+function resolveHeadersOrThrow(headers, description, env) {
+	if (!headers) return void 0;
+	const resolved = {};
+	for (const [key, value] of Object.entries(headers)) resolved[key] = resolveConfigValueOrThrow(value, `${description} header "${key}"`, env);
+	return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+//#endregion
+//#region src/models-json.ts
+function modelsJsonPath() {
+	return join(getAgentDir(), "models.json");
+}
+const emptySnapshot = () => ({
+	models: [],
+	providers: /* @__PURE__ */ new Map(),
+	errors: []
+});
+/**
+* One load of models.json projected to Pi Model objects. Mirrors Pi's
+* composeModelProvider composition order: base (builtin) models →
+* applyModelsJson upserts → modelOverrides as the topmost user-config layer.
+* A provider that fails composition contributes an error and is skipped —
+* the same per-entry isolation the rest of the bridge applies to extensions.
+*/
+async function loadModelsJsonSnapshot(baseProviderOf) {
+	const snapshot = emptySnapshot();
+	const config = await ModelConfig.load(modelsJsonPath());
+	const loadError = config.getError();
+	if (loadError !== void 0) {
+		snapshot.errors.push(loadError);
+		return snapshot;
+	}
+	for (const providerId of config.getProviderIds()) {
+		const providerConfig = config.getProvider(providerId);
+		if (providerConfig === void 0) continue;
+		try {
+			const base = await baseProviderOf?.(providerId);
+			const composed = applyModelsJson(providerId, typeof base?.getModels === "function" ? base.getModels() : [], providerConfig).map((model) => {
+				const override = providerConfig.modelOverrides?.[String(model.id)];
+				return override ? applyModelOverride(model, override) : model;
+			});
+			snapshot.models.push(...composed);
+			snapshot.providers.set(providerId, providerConfig);
+		} catch (error) {
+			snapshot.errors.push(error instanceof Error ? error.message : String(error));
+		}
+	}
+	return snapshot;
+}
+/**
+* Pi's configured-auth answer for a models.json provider, following
+* composeApiKeyAuth.resolve + withConfiguredAuth and the registry's
+* translation of their failures:
+* - a configured apiKey resolves through $ENV/!command or fails loudly with
+*   the resolver's message;
+* - authHeader folds the resolved key into an Authorization header and,
+*   without a key, becomes Pi's "No API key found" answer;
+* - a provider with neither key nor authHeader answers with its resolved
+*   headers only (the registry's compatibility path).
+*/
+function resolveModelsJsonAuth(providerId, provider) {
+	try {
+		const headers = resolveHeadersOrThrow(provider.headers, `provider "${providerId}"`);
+		const rawKey = provider.apiKey;
+		if (rawKey === void 0) {
+			if (provider.authHeader ?? false) return {
+				ok: false,
+				error: `No API key found for "${providerId}"`
+			};
+			return {
+				ok: true,
+				...headers === void 0 ? {} : { headers }
+			};
+		}
+		const apiKey = resolveConfigValueOrThrow(rawKey, `API key for provider "${providerId}"`);
+		const merged = provider.authHeader ?? false ? {
+			...headers,
+			Authorization: `Bearer ${apiKey}`
+		} : headers;
+		return {
+			ok: true,
+			apiKey,
+			...merged === void 0 ? {} : { headers: merged }
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Pi's withConfiguredAuth layered over an auth resolved by another family
+* (an extension-registered provider or a builtin): models.json headers
+* override the resolved ones, and authHeader folds the resolved key into
+* an Authorization header — failing loudly without one, as Pi does.
+*/
+function applyModelsJsonConfiguredAuth(providerId, provider, auth) {
+	try {
+		const configured = resolveHeadersOrThrow(provider.headers, `provider "${providerId}"`);
+		let headers = auth.headers || configured ? {
+			...auth.headers,
+			...configured
+		} : void 0;
+		if (provider.authHeader ?? false) {
+			if (auth.apiKey === void 0) return {
+				ok: false,
+				error: `No API key found for "${providerId}"`
+			};
+			headers = {
+				...headers,
+				Authorization: `Bearer ${auth.apiKey}`
+			};
+		}
+		return {
+			ok: true,
+			...auth.apiKey === void 0 ? {} : { apiKey: auth.apiKey },
+			...headers === void 0 ? {} : { headers }
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* One models.json provider as a Pi Provider object: the composed Pi Models
+* as its catalog and Pi's per-api wire clients as its transport (attached by
+* the provider adapter's synthesis). Registered as a DSH llm route, this
+* makes the DSH directory the single model directory — the Pi registry
+* projects it back, and registry.getProvider() answers a genuine Pi
+* Provider, so packages that stream through the provider surface work
+* unchanged.
+*/
+function modelsJsonPiProvider(providerId, provider, models) {
+	return {
+		id: providerId,
+		name: provider.name ?? providerId,
+		...provider.baseUrl === void 0 ? {} : { baseUrl: provider.baseUrl },
+		...provider.api === void 0 ? {} : { api: provider.api },
+		getModels: () => models
+	};
+}
+/**
+* Pi's configured-check (not liveness) for a models.json provider — the
+* configuredRequestAuthStatus semantics: a literal or !command key counts as
+* configured, a templated key counts only when its env vars are present, and
+* a provider without an apiKey defers to the other credential families.
+*/
+function modelsJsonAuthConfigured(provider) {
+	const value = provider.apiKey;
+	if (value === void 0) return void 0;
+	if (isCommandConfigValue(value)) return true;
+	if (getConfigValueEnvVarNames(value).length > 0) return isConfigValueConfigured(value);
+	return true;
+}
+//#endregion
 //#region src/provider-adapter.ts
+const PI_API_FACTORIES = {
+	"openai-completions": openAICompletionsApi,
+	"openai-responses": openAIResponsesApi,
+	"anthropic-messages": anthropicMessagesApi
+};
+function piApiClientFor(api) {
+	const factory = typeof api === "string" ? PI_API_FACTORIES[api] : void 0;
+	return factory === void 0 ? void 0 : factory();
+}
+/**
+* Give a config-only Pi provider (models.json entries, packages that declare
+* models without a stream) Pi's own transport: each call dispatches on the
+* model's declared `api` to the real pi-ai client, exactly as Pi's
+* provider composer does. Undispatchable providers (no models, or an api
+* with no client) answer undefined and stay off the directory.
+*/
+function withSynthesizedTransport(provider) {
+	const models = typeof provider.getModels === "function" ? provider.getModels() : Array.isArray(provider.models) ? provider.models : [];
+	if (models.length === 0) return void 0;
+	if (!models.some((model) => piApiClientFor(model.api) !== void 0)) return void 0;
+	const dispatch = (simple) => (model, context, options) => {
+		const client = piApiClientFor(model.api);
+		if (client === void 0) throw new Error(`pi2dsh: no wire-protocol client for api ${JSON.stringify(String(model.api))} (model ${String(model.provider)}/${String(model.id)})`);
+		return (simple ? client.streamSimple ?? client.stream : client.stream).call(client, model, context, options);
+	};
+	return {
+		...provider,
+		getModels: () => models,
+		stream: dispatch(false),
+		streamSimple: dispatch(true)
+	};
+}
 function providerCarriesTransport(value) {
 	return typeof value?.stream === "function";
 }
@@ -1108,6 +1937,22 @@ function providerModels(provider) {
 		return [];
 	}
 }
+const PI_CARRIED_FIELDS = [
+	"api",
+	"baseUrl",
+	"cost",
+	"contextWindow",
+	"maxTokens",
+	"samplingParams",
+	"thinkingLevelMap",
+	"compat",
+	"headers"
+];
+function piCarriedFields(model) {
+	const carried = {};
+	for (const field of PI_CARRIED_FIELDS) if (model[field] !== void 0) carried[field] = model[field];
+	return carried;
+}
 /**
 * Wrap one Pi provider object as a DSH LlmAdapter-shaped route handler.
 * Structural typing carries it through `llm.registerAdapter`.
@@ -1120,6 +1965,7 @@ function piProviderDshAdapter(providerId, provider, host) {
 		}),
 		providerRetryPolicy: () => void 0,
 		listModels: async (id) => providerModels(provider).map((model) => ({
+			...piCarriedFields(model),
 			provider: id,
 			id: String(model.id ?? ""),
 			name: String(model.name ?? model.id ?? ""),
@@ -1128,6 +1974,7 @@ function piProviderDshAdapter(providerId, provider, host) {
 		resolveModel: async (id, modelId) => {
 			const known = providerModels(provider).find((model) => model.id === modelId);
 			return {
+				...known === void 0 ? {} : piCarriedFields(known),
 				provider: id,
 				id: modelId,
 				name: String(known?.name ?? modelId),
@@ -1156,17 +2003,20 @@ function piProviderDshAdapter(providerId, provider, host) {
 	};
 }
 /**
-* Register the provider as a live DSH route when it carries a transport and
-* an llm service is mounted. A route conflict (an adapter already owns the
-* name — e.g. a deployment-configured `deepseek`) keeps the existing route
-* and reports the skip; the package's registry entry still stands.
+* Register the provider as a live DSH route when an llm service is mounted.
+* A provider carrying its own transport streams through it; a config-only
+* provider gets Pi's synthesized per-api transport. A route conflict (an
+* adapter already owns the name — e.g. a deployment-configured `deepseek`)
+* keeps the existing route and reports the skip.
 * @returns the route disposer, or undefined when nothing was registered.
 */
 function registerPiProviderRoute(options) {
 	const { llm, providerId, provider, host } = options;
-	if (llm === void 0 || !providerCarriesTransport(provider)) return void 0;
+	if (llm === void 0) return void 0;
+	const transport = providerCarriesTransport(provider) ? provider : withSynthesizedTransport(provider);
+	if (transport === void 0) return void 0;
 	try {
-		return llm.registerAdapter([providerId], piProviderDshAdapter(providerId, provider, host));
+		return llm.registerAdapter([providerId], piProviderDshAdapter(providerId, transport, host));
 	} catch (error) {
 		host.warn(`[pi2dsh] Pi provider ${JSON.stringify(providerId)} was not added as a DSH llm route (${error instanceof Error ? error.message : String(error)}); the existing route keeps the name`);
 		return;
@@ -1428,7 +2278,7 @@ function currentPiModel(state, agent) {
 		id,
 		name: id,
 		provider,
-		api: "dsh-llm",
+		api: "faux",
 		input: ["text"],
 		reasoning: false
 	};
@@ -1518,28 +2368,43 @@ function contextFor(ctx, state, agent, signal, command = false) {
 	const session = agentSession(agent);
 	const providerConfig = (name) => state.providers.get(name);
 	const catalog = state.modelCatalog;
-	const piProviderModels = () => {
-		const out = [];
-		for (const [key, value] of state.providers) {
-			let models;
-			try {
-				models = typeof value.getModels === "function" ? value.getModels() : value.models;
-			} catch {
-				continue;
-			}
-			if (!Array.isArray(models)) continue;
-			for (const model of models) out.push({
-				...model,
-				provider: String(model.provider ?? key)
-			});
+	const piNativeEntry = (provider, id) => {
+		const source = state.modelsJsonProviders.get(provider) ?? (state.providerRouteDisposers.has(provider) ? state.providers.get(provider) : void 0);
+		if (source === void 0) return void 0;
+		let models;
+		try {
+			models = typeof source.getModels === "function" ? source.getModels() : source.models;
+		} catch {
+			return;
 		}
-		return out;
+		if (!Array.isArray(models)) return void 0;
+		return models.find((model) => model.id === id);
 	};
-	const allModels = () => {
-		const fromLlm = catalog?.all() ?? [];
-		const seen = new Set(fromLlm.map((model) => `${model.provider} ${model.id}`));
-		return [...fromLlm, ...piProviderModels().filter((model) => !seen.has(`${String(model.provider)} ${String(model.id)}`))];
+	const restorePiShape = (entry) => {
+		const native = piNativeEntry(String(entry.provider ?? ""), String(entry.id ?? ""));
+		return native === void 0 ? entry : {
+			...entry,
+			...native,
+			provider: entry.provider
+		};
 	};
+	const allModels = () => (catalog?.all() ?? []).map(restorePiShape);
+	const dshRoutedStream = (model, context, options) => {
+		const llm = llmOf(ctx);
+		if (llm === void 0) throw new Error("pi2dsh: model calls need a DSH llm service; this composition mounts none");
+		return streamViaDshLlm(llm, {
+			model,
+			context,
+			options
+		});
+	};
+	const dshRoutedPiProvider = (base, providerId) => ({
+		...base,
+		id: providerId,
+		getModels: () => allModels().filter((model) => model.provider === providerId),
+		stream: dshRoutedStream,
+		streamSimple: dshRoutedStream
+	});
 	const base = {
 		ui,
 		mode: "rpc",
@@ -1552,15 +2417,28 @@ function contextFor(ctx, state, agent, signal, command = false) {
 		modelRegistry: {
 			getAll: () => allModels(),
 			getAvailable: () => allModels(),
-			find: (provider, modelId) => catalog?.find(provider, modelId) ?? piProviderModels().find((model) => model.provider === provider && model.id === modelId),
-			getError: () => void 0,
+			find: (provider, modelId) => {
+				const entry = catalog?.find(provider, modelId);
+				return entry === void 0 ? void 0 : restorePiShape(entry);
+			},
+			getError: () => {
+				const problems = state.modelsJson?.errors ?? [];
+				return problems.length > 0 ? problems.join("\n") : void 0;
+			},
 			hasConfiguredAuth: (model) => {
 				const provider = String(model?.provider ?? "");
-				return provider.length > 0 && (state.providers.has(provider) || (catalog?.all() ?? []).some((entry) => entry.provider === provider));
+				if (provider.length === 0) return false;
+				const jsonProvider = state.modelsJson?.providers.get(provider);
+				if (jsonProvider !== void 0) {
+					const configured = modelsJsonAuthConfigured(jsonProvider);
+					if (configured !== void 0) return configured;
+				}
+				return state.providers.has(provider) || (catalog?.all() ?? []).some((entry) => entry.provider === provider) || jsonProvider !== void 0;
 			},
 			getApiKeyAndHeaders: async (model) => {
 				const provider = String(model?.provider ?? "");
-				const config = providerConfig(provider) ?? await realBuiltinProvider(provider);
+				const jsonProvider = state.modelsJson?.providers.get(provider);
+				const config = providerConfig(provider) ?? (jsonProvider?.apiKey !== void 0 ? void 0 : await realBuiltinProvider(provider));
 				if (config !== void 0) {
 					const auth = (await resolvePiProviderAuth({
 						providerId: provider,
@@ -1568,13 +2446,34 @@ function contextFor(ctx, state, agent, signal, command = false) {
 						store: oauthStoreOf(state)
 					}))?.auth;
 					if (auth?.apiKey === void 0) return { ok: false };
+					const configured = jsonProvider === void 0 ? void 0 : applyModelsJsonConfiguredAuth(provider, jsonProvider, {
+						apiKey: auth.apiKey,
+						...auth.headers === void 0 ? {} : { headers: auth.headers }
+					});
+					if (configured !== void 0 && !configured.ok) return {
+						ok: false,
+						error: configured.error
+					};
+					const headers = configured?.ok ? configured.headers : auth.headers;
 					return {
 						ok: true,
 						apiKey: auth.apiKey,
-						...auth.headers === void 0 ? {} : { headers: auth.headers },
+						...headers === void 0 ? {} : { headers },
 						...auth.baseUrl === void 0 && config.baseUrl === void 0 ? {} : { baseUrl: auth.baseUrl ?? config.baseUrl }
 					};
 				}
+				if (jsonProvider !== void 0) {
+					const resolved = resolveModelsJsonAuth(provider, jsonProvider);
+					if (!resolved.ok) return {
+						ok: false,
+						error: resolved.error
+					};
+					return {
+						ok: true,
+						...resolved.apiKey === void 0 ? {} : { apiKey: resolved.apiKey },
+						...resolved.headers === void 0 ? {} : { headers: resolved.headers }
+					};
+				}
 				try {
 					const entry = llmOf(ctx)?.listConfigurableProviders?.()?.find((candidate) => candidate.provider === provider);
 					if (entry === void 0) return { ok: false };
@@ -1592,11 +2491,23 @@ function contextFor(ctx, state, agent, signal, command = false) {
 				}
 			},
 			getProviderAuthStatus: (provider) => providerSupportsOAuth(providerConfig(provider)) ? "oauth" : "none",
-			getProvider: (provider) => providerConfig(provider),
+			getProvider: (provider) => {
+				const base = providerConfig(provider) ?? state.modelsJsonProviders.get(provider);
+				if (base !== void 0) return state.providerRouteDisposers.has(provider) || state.providerRouteDisposers.has(`${MODELS_JSON_ROUTE_PREFIX}${provider}`) ? dshRoutedPiProvider(base, provider) : base;
+				if ((catalog?.all() ?? []).some((entry) => entry.provider === provider)) return dshRoutedPiProvider({
+					id: provider,
+					name: provider
+				}, provider);
+			},
+			complete: async (model, context, options) => {
+				const result = await dshRoutedStream(model, context ?? {}, options).result();
+				if (result instanceof Error) throw result;
+				return result;
+			},
 			getRegisteredProviderConfig: (provider) => providerConfig(provider),
 			getRegisteredProviderIds: () => [...state.providers.keys()],
 			getProviderDisplayName: (provider) => {
-				const config = providerConfig(provider);
+				const config = providerConfig(provider) ?? state.modelsJsonProviders.get(provider);
 				return typeof config?.name === "string" ? config.name : provider;
 			},
 			getProviderAuth: async (provider) => {
@@ -1630,10 +2541,11 @@ function contextFor(ctx, state, agent, signal, command = false) {
 				return provider.length > 0 && providerSupportsOAuth(providerConfig(provider));
 			},
 			refresh: async () => {
+				await reloadModelsJson(ctx, state);
 				await catalog?.refresh();
 				return {
-					models: catalog?.all() ?? [],
-					errors: []
+					models: allModels(),
+					errors: [...state.modelsJson?.errors ?? []]
 				};
 			}
 		},
@@ -1974,11 +2886,77 @@ function subscribeInterceptors(ctx, state) {
 		};
 		return downstream;
 	});
+	cordis.on("agent/pre-step", async (payload, next) => {
+		const decision = await next();
+		if (decision.kind !== "enter" || payload.step !== 1) return decision;
+		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return decision;
+		const agent = payload.agent;
+		if (isSubagentOrigin(agent)) return decision;
+		const signal = payload.signal;
+		const messages = decision.messages ?? [];
+		const userMessages = messages.filter((message) => (message.source?.kind ?? "user") === "user");
+		const prompt = userMessages.flatMap((message) => textBlocks(message.content)).map((block) => block.text).join("\n");
+		const images = await collectPiImages(ctx, userMessages);
+		state.turnSystemPromptOverrides.delete(agent);
+		const event = {
+			type: "before_agent_start",
+			prompt,
+			...images.length > 0 ? { images } : {},
+			systemPrompt: state.currentSystemPrompt,
+			systemPromptOptions: {}
+		};
+		const results = await dispatch(state, "before_agent_start", event, contextFor(ctx, state, agent, signal));
+		const injected = [];
+		for (const result of results) {
+			if (typeof result !== "object" || result === null) continue;
+			const record = result;
+			if (typeof record.systemPrompt === "string") {
+				state.turnSystemPromptOverrides.set(agent, record.systemPrompt);
+				event.systemPrompt = record.systemPrompt;
+			}
+			const message = record.message;
+			if (message !== void 0) {
+				const content = message.content;
+				const blocks = await piToDshContent(ctx, typeof content === "string" ? [{
+					type: "text",
+					text: content
+				}] : content ?? []);
+				injected.push(createUserMessage({
+					content: blocks,
+					source: {
+						kind: "plugin",
+						plugin: state.messageSource,
+						...typeof message.customType === "string" ? { piCustomType: message.customType } : {}
+					}
+				}));
+			}
+		}
+		const stepMessages = injected.length === 0 ? messages : [...messages, ...injected];
+		const transformed = await applyPiContextTransform(ctx, state, agent, signal, stepMessages);
+		if (transformed === stepMessages && injected.length === 0) return decision;
+		return {
+			...decision,
+			messages: transformed
+		};
+	});
 	cordis.on("system-prompt/assemble", async (assembly, assembleContext, next) => {
 		const downstream = await next();
 		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return downstream;
 		const original = renderPrompt(downstream);
 		state.currentSystemPrompt = original;
+		const agent = assembleContext.agent ?? assembleContext.scope;
+		if (agent !== void 0 && !isSubagentOrigin(agent)) {
+			const override = state.turnSystemPromptOverrides.get(agent);
+			if (override === void 0) return downstream;
+			state.currentSystemPrompt = override;
+			return {
+				...downstream,
+				sections: [{
+					name: "pi2dsh:system-prompt",
+					text: override
+				}]
+			};
+		}
 		const event = {
 			type: "before_agent_start",
 			prompt: "",
@@ -1987,12 +2965,9 @@ function subscribeInterceptors(ctx, state) {
 		};
 		const results = await dispatch(state, "before_agent_start", event, contextFor(ctx, state, assembleContext.scope, assembleContext.signal));
 		let replacement = original;
-		for (const result of results) {
-			if (typeof result === "object" && result !== null && typeof result.systemPrompt === "string") {
-				replacement = result.systemPrompt;
-				event.systemPrompt = replacement;
-			}
-			if (typeof result === "object" && result !== null && result.message !== void 0) logger(ctx).warn("[pi2dsh] before_agent_start custom-message injection is unsupported and was ignored");
+		for (const result of results) if (typeof result === "object" && result !== null && typeof result.systemPrompt === "string") {
+			replacement = result.systemPrompt;
+			event.systemPrompt = replacement;
 		}
 		state.currentSystemPrompt = replacement;
 		return {
@@ -2004,10 +2979,146 @@ function subscribeInterceptors(ctx, state) {
 		};
 	});
 }
+function piShapeOfPending(message) {
+	const source = message.source;
+	const content = dshToPiContent(message.content ?? []);
+	return typeof source?.piCustomType === "string" ? {
+		role: "custom",
+		customType: source.piCustomType,
+		content
+	} : {
+		role: "user",
+		content
+	};
+}
+async function applyPiContextTransform(ctx, state, agent, signal, pending) {
+	if ((state.handlers.get("context")?.length ?? 0) === 0) return pending;
+	const session = agentSession(agent);
+	const history = [];
+	for (const event of session?.events ?? []) {
+		const projected = messageFromSessionEvent(event);
+		if (projected === void 0) continue;
+		if (event.type === "user/message") {
+			const customType = (event.data?.source)?.piCustomType;
+			if (typeof customType === "string") {
+				history.push({
+					...projected,
+					role: "custom",
+					customType
+				});
+				continue;
+			}
+		}
+		history.push(projected);
+	}
+	const projectedPending = pending.map(piShapeOfPending);
+	const event = {
+		type: "context",
+		messages: [...history, ...projectedPending]
+	};
+	const results = await dispatch(state, "context", event, contextFor(ctx, state, agent, signal));
+	let current = event.messages;
+	for (const result of results) {
+		if (typeof result !== "object" || result === null) continue;
+		const returned = result.messages;
+		if (!Array.isArray(returned)) continue;
+		if (returned.length !== current.length) {
+			logger(ctx).warn("[pi2dsh] a Pi context handler changed the message count; DSH durable history is append-only, so the transform was ignored");
+			continue;
+		}
+		current = returned;
+	}
+	if (current === event.messages) return pending;
+	for (let index = 0; index < history.length; index++) {
+		if (current[index] === history[index]) continue;
+		if (JSON.stringify(current[index]) === JSON.stringify(history[index])) continue;
+		logger(ctx).warn("[pi2dsh] a Pi context handler edited already-entered history; DSH durable history is append-only, so those edits were ignored (only this step's not-yet-entered messages accept the transform)");
+		break;
+	}
+	const tail = current.slice(history.length);
+	const rebuilt = [];
+	for (const [index, original] of pending.entries()) {
+		const shape = tail[index];
+		if (shape === void 0) {
+			rebuilt.push(original);
+			continue;
+		}
+		const blocks = await piToDshContent(ctx, typeof shape.content === "string" ? [{
+			type: "text",
+			text: shape.content
+		}] : shape.content ?? []);
+		rebuilt.push(createUserMessage({
+			content: blocks,
+			source: original.source ?? {
+				kind: "plugin",
+				plugin: state.messageSource
+			}
+		}));
+	}
+	return rebuilt;
+}
+async function collectPiImages(ctx, messages) {
+	const attachments = ctx.get("attachments");
+	if (attachments === void 0) return [];
+	const images = [];
+	for (const message of messages) {
+		const content = message.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			if (block?.type !== "image" || block.attachment === void 0) continue;
+			try {
+				const stored = await attachments.readImage(block.attachment);
+				images.push({
+					type: "image",
+					data: Buffer.from(stored.data).toString("base64"),
+					mimeType: String(block.attachment.mediaType ?? "image/png")
+				});
+			} catch {}
+		}
+	}
+	return images;
+}
 function oauthStoreOf(state) {
 	state.oauthStore ??= new FileCredentialStore(join(getAgentDir(), "auth.json"));
 	return state.oauthStore;
 }
+const MODELS_JSON_ROUTE_PREFIX = "models.json/";
+async function reloadModelsJson(ctx, state) {
+	for (const [key, dispose] of state.providerRouteDisposers) {
+		if (!key.startsWith(MODELS_JSON_ROUTE_PREFIX)) continue;
+		state.providerRouteDisposers.delete(key);
+		dispose();
+	}
+	state.modelsJsonProviders.clear();
+	state.modelsJson = await loadModelsJsonSnapshot(realBuiltinProvider);
+	for (const problem of state.modelsJson.errors) logger(ctx).warn(`[pi2dsh] models.json: ${problem}`);
+	for (const [providerId, providerConfig] of state.modelsJson.providers) {
+		const models = state.modelsJson.models.filter((model) => model.provider === providerId);
+		const provider = modelsJsonPiProvider(providerId, providerConfig, models);
+		const routeDisposer = registerPiProviderRoute({
+			llm: llmOf(ctx),
+			providerId,
+			provider,
+			host: {
+				resolveAuth: async () => {
+					const resolved = resolveModelsJsonAuth(providerId, providerConfig);
+					if (!resolved.ok) return void 0;
+					return { auth: {
+						...resolved.apiKey === void 0 ? {} : { apiKey: resolved.apiKey },
+						...resolved.headers === void 0 ? {} : { headers: resolved.headers },
+						...providerConfig.baseUrl === void 0 ? {} : { baseUrl: providerConfig.baseUrl }
+					} };
+				},
+				warn: (message) => logger(ctx).warn(message)
+			}
+		});
+		if (routeDisposer !== void 0) {
+			state.modelsJsonProviders.set(providerId, provider);
+			state.providerRouteDisposers.set(`${MODELS_JSON_ROUTE_PREFIX}${providerId}`, routeDisposer);
+			logger(ctx).info(`[pi2dsh] models.json provider ${JSON.stringify(providerId)} registered as a native DSH llm route (${models.length} models)`);
+		}
+	}
+}
 function ensureLoginCommand(ctx, state) {
 	if (state.loginCommandRegistered === true) return;
 	state.loginCommandRegistered = true;
@@ -2206,15 +3317,19 @@ function dshCommandName(ctx, piName) {
 	return name;
 }
 function registerCommand(ctx, state, command) {
-	if (state.commands.has(command.name)) throw new Error(`Pi command ${JSON.stringify(command.name)} is already registered`);
+	if (state.commands.has(command.name)) {
+		state.commandDisposers.get(command.name)?.();
+		state.commandDisposers.delete(command.name);
+	}
 	state.commands.set(command.name, command);
 	const commands = ctx.get("commands");
 	if (commands === void 0) {
 		logger(ctx).warn(`[pi2dsh] command /${command.name} was not registered because this DSH composition has no ctx.commands`);
 		return;
 	}
-	commands.register({
-		name: dshCommandName(ctx, command.name),
+	const baseName = dshCommandName(ctx, command.name);
+	const definitionFor = (dshName) => ({
+		name: dshName,
 		description: command.description || `Migrated Pi command /${command.name}`,
 		...command.argumentHint !== void 0 ? { input: { hint: command.argumentHint } } : {},
 		async handler(invocation) {
@@ -2228,6 +3343,18 @@ function registerCommand(ctx, state, command) {
 			};
 		}
 	});
+	let lastError;
+	for (let ordinal = 1; ordinal <= 9; ordinal++) {
+		const dshName = ordinal === 1 ? baseName : `${baseName}-${ordinal}`;
+		try {
+			state.commandDisposers.set(command.name, commands.register(definitionFor(dshName)));
+			if (ordinal > 1) logger(ctx).warn(`[pi2dsh] command /${command.name} collides with an earlier registration in this host; mounted as /${dshName} (Pi numbers colliding commands the same way)`);
+			return;
+		} catch (error) {
+			lastError = error;
+		}
+	}
+	logger(ctx).warn(`[pi2dsh] command /${command.name} was not registered: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 }
 function requireSession(state, operation) {
 	const session = agentSession(currentAgent(state));
@@ -2569,6 +3696,8 @@ async function applyPiPackage(ctx, options) {
 		toolDisposers: /* @__PURE__ */ new Map(),
 		toolRestrictions: /* @__PURE__ */ new WeakMap(),
 		commands: /* @__PURE__ */ new Map(),
+		commandDisposers: /* @__PURE__ */ new Map(),
+		modelsJsonProviders: /* @__PURE__ */ new Map(),
 		flags: /* @__PURE__ */ new Map(),
 		notifications: [],
 		activeAgents: /* @__PURE__ */ new Set(),
@@ -2588,6 +3717,7 @@ async function applyPiPackage(ctx, options) {
 		toolsExpanded: false,
 		modelOverrides: /* @__PURE__ */ new WeakMap(),
 		thinkingLevels: /* @__PURE__ */ new WeakMap(),
+		turnSystemPromptOverrides: /* @__PURE__ */ new WeakMap(),
 		globalThinkingLevel: "off",
 		argMutations: /* @__PURE__ */ new WeakMap(),
 		streamingTexts: /* @__PURE__ */ new Map(),
@@ -2616,6 +3746,7 @@ async function applyPiPackage(ctx, options) {
 	}
 	const llm = llmOf(ctx);
 	state.modelCatalog = new ModelCatalog(llm);
+	await reloadModelsJson(ctx, state);
 	if (llm !== void 0) {
 		ctx.on("llm/adapters-updated", () => {
 			state.modelCatalog?.refresh();
@@ -2654,4 +3785,4 @@ const runtimeInternals = {
 //#endregion
 export { normalizeToolSchema as n, runtimeInternals as r, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-B9R7bDWT.mjs.map
+//# sourceMappingURL=runtime-B7mEIRf-.mjs.map