pi-ui-extend 1.0.12 → 1.0.13

package/dist/app/runtime.d.ts

@@ -46,6 +46,13 @@ type RuntimeSessionManagerModelState = Pick<SessionManager, "getEntries" | "getB
 export declare function resolvePixRuntimeModelRef(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string | undefined;
 export declare function resolvePixRuntimeInitialThinkingLevel(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config: PixConfig): ThinkingLevel | undefined;
 export declare function resolveSessionModelRefFromTail(entries: readonly SessionEntry[]): string | undefined;
-export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh">): Promise<void>;
+/**
+ * pi-ai 0.84.2 predates GLM-5.3's final thinking contract. The released model
+ * is always-thinking and accepts exactly low/high/max via reasoning_effort.
+ * Patch the mutable catalog model before AgentSession clamps the selected level.
+ */
+export declare function patchGlm53ThinkingMetadata(model: unknown): boolean;
+export declare function patchPixModelRuntimeCompatibility(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "getModels">): number;
+export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh" | "getModels">): Promise<void>;
 export declare function createPixRuntime(options: AppOptions, runtimeOptions?: CreatePixRuntimeOptions): Promise<AgentSessionRuntime>;
 export {};

package/dist/app/runtime.js

@@ -235,10 +235,49 @@ export function resolveSessionModelRefFromTail(entries) {
         return undefined;
     return thinkingLevel ? `${modelRef}:${thinkingLevel}` : modelRef;
 }
+const GLM_53_THINKING_LEVEL_MAP = {
+    off: null,
+    minimal: null,
+    low: "low",
+    medium: null,
+    high: "high",
+    xhigh: null,
+    max: "max",
+};
+/**
+ * pi-ai 0.84.2 predates GLM-5.3's final thinking contract. The released model
+ * is always-thinking and accepts exactly low/high/max via reasoning_effort.
+ * Patch the mutable catalog model before AgentSession clamps the selected level.
+ */
+export function patchGlm53ThinkingMetadata(model) {
+    if (!model || typeof model !== "object" || Array.isArray(model))
+        return false;
+    const candidate = model;
+    if (candidate.id !== "glm-5.3")
+        return false;
+    if (!candidate.compat || typeof candidate.compat !== "object" || Array.isArray(candidate.compat))
+        return false;
+    const compat = candidate.compat;
+    if (compat.thinkingFormat !== "zai")
+        return false;
+    candidate.reasoning = true;
+    candidate.thinkingLevelMap = { ...GLM_53_THINKING_LEVEL_MAP };
+    candidate.compat = { ...compat, supportsReasoningEffort: true };
+    return true;
+}
+export function patchPixModelRuntimeCompatibility(modelRuntime) {
+    let patched = 0;
+    for (const model of modelRuntime.getModels()) {
+        if (patchGlm53ThinkingMetadata(model))
+            patched += 1;
+    }
+    return patched;
+}
 export async function refreshPixModelRuntimeForStartup(modelRuntime) {
     // Startup only needs the locally configured model catalog. Remote catalog
     // refreshes belong to explicit model-management flows and must not block boot.
     await modelRuntime.refresh({ allowNetwork: false });
+    patchPixModelRuntimeCompatibility(modelRuntime);
 }
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();

package/external/pi-tools-suite/src/coding-discipline/index.ts

@@ -49,6 +49,16 @@ const SILENCE_REMINDER_MIN_MESSAGE_GAP = 20;
 // truncation), the chatter baseline is reset so it isn't measured against a stale peak.
 const SILENCE_REMINDER_COMPACTION_MARGIN = 8;
 const LOOKUP_TOOL_NAME = "lookup";
+const GLM_53_THINKING_LEVEL_MAP = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: null,
+	high: "high",
+	xhigh: null,
+	max: "max",
+} as const;
+const GLM_53_THINKING_LEVELS = ["low", "high", "max"] as const;
 
 const LOOKUP_TOOL_PARAMS = Type.Object(
 	{
@@ -203,13 +213,17 @@ export default function codingDiscipline(pi: ExtensionAPI) {
 	maybeRegisterLookupTool(process.cwd());
 
 	pi.on("session_start", async (_event: unknown, ctx: unknown) => {
+		patchGlm53ThinkingModels(ctx);
 		selectedModelRef = modelRefFromContext(ctx);
+		normalizeCurrentGlm53ThinkingLevel(pi, selectedModelRef);
 		maybeRegisterLookupTool(contextCwd(ctx));
 		syncLookupToolAvailability(selectedModelRef, contextCwd(ctx));
 	});
 
 	pi.on("model_select", async (event: { model?: unknown }, ctx: unknown) => {
+		patchGlm53ThinkingModels(ctx, event.model);
 		selectedModelRef = modelRefFromModel(event.model) ?? modelRefFromContext(ctx);
+		normalizeCurrentGlm53ThinkingLevel(pi, selectedModelRef);
 		maybeRegisterLookupTool(contextCwd(ctx));
 		syncLookupToolAvailability(selectedModelRef, contextCwd(ctx));
 	});
@@ -222,10 +236,11 @@ export default function codingDiscipline(pi: ExtensionAPI) {
 			lookupEnabled: Boolean(lookupModelFromConfig(cwd)),
 			strictness: codingDisciplineStrictnessFromConfig(cwd),
 		});
+		const corrected = applyGlm53ThinkingToPayload(injected, modelRef, ctx, pi);
 		if (process.env.PI_DEBUG_PROMPT === "1") {
-			logFinalPrompt(injected, modelRef, contextCwd(ctx) ?? process.cwd());
+			logFinalPrompt(corrected, modelRef, contextCwd(ctx) ?? process.cwd());
 		}
-		return injected;
+		return corrected;
 	});
 
 	pi.on("before_agent_start", async (event: { systemPromptOptions?: unknown; systemPrompt?: string }, ctx: unknown) => {
@@ -350,6 +365,83 @@ export function isGlmModel(modelRef: string | undefined): boolean {
 	return /(?:^|[/:_.-])glm(?:$|[/:_.-]|\d)/i.test(modelRef);
 }
 
+function isGlm53ModelRef(modelRef: string | undefined): boolean {
+	if (!modelRef) return false;
+	return /(?:^|\/)glm-5\.3(?:$|:)/i.test(modelRef) || /^glm-5\.3(?:$|:)/i.test(modelRef);
+}
+
+function patchGlm53ThinkingModel(model: unknown): boolean {
+	if (!isRecord(model)) return false;
+	const id = typeof model.id === "string"
+		? model.id
+		: typeof model.modelId === "string"
+			? model.modelId
+			: undefined;
+	if (id !== "glm-5.3") return false;
+	const provider = typeof model.provider === "string" ? model.provider : undefined;
+	const compat = isRecord(model.compat) ? model.compat : {};
+	if (provider !== "zai" && provider !== "zai-coding-cn" && compat.thinkingFormat !== "zai") return false;
+
+	model.reasoning = true;
+	model.thinkingLevelMap = { ...GLM_53_THINKING_LEVEL_MAP };
+	model.compat = { ...compat, supportsReasoningEffort: true };
+	return true;
+}
+
+function patchGlm53ThinkingModels(ctx: unknown, selectedModel?: unknown): void {
+	patchGlm53ThinkingModel(selectedModel);
+	if (!isRecord(ctx)) return;
+	patchGlm53ThinkingModel(ctx.model);
+
+	if (Array.isArray(ctx.scopedModels)) {
+		for (const entry of ctx.scopedModels) {
+			if (isRecord(entry)) patchGlm53ThinkingModel(entry.model);
+		}
+	}
+
+	const registry = ctx.modelRegistry;
+	if (!isRecord(registry) || typeof registry.getAll !== "function") return;
+	try {
+		const models = registry.getAll();
+		if (Array.isArray(models)) {
+			for (const model of models) patchGlm53ThinkingModel(model);
+		}
+	} catch {
+		// Compatibility patching must never break session startup.
+	}
+}
+
+function normalizeGlm53ThinkingLevel(level: unknown): (typeof GLM_53_THINKING_LEVELS)[number] {
+	if (level === "low" || level === "high" || level === "max") return level;
+	if (level === "off" || level === "minimal") return "low";
+	if (level === "medium") return "high";
+	return "max";
+}
+
+function normalizeCurrentGlm53ThinkingLevel(pi: ExtensionAPI, modelRef: string | undefined): void {
+	if (!isGlm53ModelRef(modelRef)) return;
+	const getter = (pi as { getThinkingLevel?: () => unknown }).getThinkingLevel;
+	const setter = (pi as { setThinkingLevel?: (level: string) => void }).setThinkingLevel;
+	if (!getter || !setter) return;
+	const current = getter.call(pi);
+	const normalized = normalizeGlm53ThinkingLevel(current);
+	if (current !== normalized) setter.call(pi, normalized);
+}
+
+function applyGlm53ThinkingToPayload(payload: unknown, modelRef: string | undefined, ctx: unknown, pi: ExtensionAPI): unknown {
+	if (!isGlm53ModelRef(modelRef) || !isRecord(payload)) return payload;
+	const getter = (pi as { getThinkingLevel?: () => unknown }).getThinkingLevel;
+	const runtimeLevel = getter ? getter.call(pi) : undefined;
+	const contextLevel = isRecord(ctx) ? ctx.thinkingLevel : undefined;
+	const effort = normalizeGlm53ThinkingLevel(runtimeLevel ?? contextLevel);
+	const existingThinking = isRecord(payload.thinking) ? payload.thinking : {};
+	return {
+		...payload,
+		thinking: { ...existingThinking, type: "enabled", clear_thinking: false },
+		reasoning_effort: effort,
+	};
+}
+
 export function injectCodingDisciplineIntoPayload(payload: unknown, options: DisciplinePromptOptions = {}): unknown {
 	if (!isRecord(payload)) return payload;
 

package/external/pi-tools-suite/src/todo/index.ts

@@ -8,7 +8,13 @@ import { ACTIVE_STATUSES, isTaskBlocked, selectVisibleTasks } from "./state/sele
 import { applyTaskMutation } from "./state/state-reducer.js";
 import { getState, replaceState } from "./state/store.js";
 import { activateTodoStateScope, DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
-import type { Task, TaskMutationParams } from "./tool/types.js";
+import {
+	TODO_THINKING_LEVEL_VALUES,
+	todoParamsSchemaForThinkingLevels,
+	type Task,
+	type TaskMutationParams,
+	type TodoThinkingLevel,
+} from "./tool/types.js";
 
 type AgentMessageLike = { role?: unknown; stopReason?: unknown; content?: unknown };
 
@@ -17,39 +23,73 @@ const TODO_NUDGE_INITIAL_DELAY_MS = 0;
 const TODO_NUDGE_IDLE_RETRY_DELAY_MS = 100;
 const TODO_NUDGE_MAX_IDLE_ATTEMPTS = 40;
 const ASK_USER_TOOL_NAMES = new Set(["ask_user", "ask_user_question", "question"]);
-const TODO_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 const TODO_THINKING_RESTORE_METADATA_KEY = "__piTodoRestoreThinking";
 
 function isStaleExtensionContextError(error: unknown): boolean {
 	return error instanceof Error && /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
 }
 
-type TodoThinkingLevel = (typeof TODO_THINKING_LEVELS)[number];
-type ModelLike = { reasoning?: boolean; thinkingLevelMap?: Partial<Record<TodoThinkingLevel, unknown | null>> };
+type ModelLike = {
+	provider?: string;
+	id?: string;
+	modelId?: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: Partial<Record<TodoThinkingLevel, unknown | null>>;
+	compat?: { thinkingFormat?: unknown };
+};
 
 function isTodoThinkingLevel(value: unknown): value is TodoThinkingLevel {
-	return TODO_THINKING_LEVELS.includes(value as TodoThinkingLevel);
+	return TODO_THINKING_LEVEL_VALUES.includes(value as TodoThinkingLevel);
+}
+
+function isGlm53TodoModel(model: ModelLike | undefined): boolean {
+	if (!model) return false;
+	const id = model.modelId ?? model.id;
+	if (id !== "glm-5.3") return false;
+	return model.provider === "zai" || model.provider === "zai-coding-cn" || model.compat?.thinkingFormat === "zai";
 }
 
 function getAvailableTodoThinkingLevels(model: unknown): TodoThinkingLevel[] {
 	const m = model as ModelLike | undefined;
 	if (!m?.reasoning) return ["off"];
+	if (isGlm53TodoModel(m)) return ["low", "high", "max"];
 	const map = m.thinkingLevelMap;
-	return TODO_THINKING_LEVELS.filter((level) => level === "off" || map?.[level] !== null);
+	return TODO_THINKING_LEVEL_VALUES.filter((level) => {
+		const mapped = map?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
+		return true;
+	});
 }
 
 function buildThinkingPromptParts(model: unknown): { promptSnippet?: string; promptGuidelines?: string[] } {
 	const levels = getAvailableTodoThinkingLevels(model);
 	if (levels.length <= 1) return {};
+	const lowEffortWording = levels.includes("off") ? "lower/off" : "lower";
 	return {
 		promptSnippet: `${DEFAULT_PROMPT_SNIPPET} Set per-item thinking: ${levels.join("|")}.`.trim(),
 		promptGuidelines: [
 			...DEFAULT_PROMPT_GUIDELINES,
-			`If todoThinking is enabled, set \`thinking\` on every planned task during create/batch_create (or update); choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use lower/off for mechanical steps and the final report. Never leave it unset in a non-trivial plan.`,
+			`If todoThinking is enabled, set \`thinking\` on every planned task during create/batch_create (or update); choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use ${lowEffortWording} for mechanical steps and the final report. Never leave it unset in a non-trivial plan.`,
 		],
 	};
 }
 
+function normalizeTodoThinkingLevelForModel(model: unknown, level: TodoThinkingLevel): TodoThinkingLevel {
+	const available = getAvailableTodoThinkingLevels(model);
+	if (available.includes(level)) return level;
+	const requestedIndex = TODO_THINKING_LEVEL_VALUES.indexOf(level);
+	for (let index = requestedIndex; index < TODO_THINKING_LEVEL_VALUES.length; index += 1) {
+		const candidate = TODO_THINKING_LEVEL_VALUES[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index -= 1) {
+		const candidate = TODO_THINKING_LEVEL_VALUES[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	return available[0] ?? "off";
+}
+
 function isAskUserToolName(toolName: string): boolean {
 	return ASK_USER_TOOL_NAMES.has(toolName);
 }
@@ -140,13 +180,15 @@ export default function (pi: ExtensionAPI) {
 	let settledNudgeEligible = false;
 
 	function registerTodoToolWithCurrentPrompt(): void {
+		const availableThinkingLevels = todoThinkingEnabled ? getAvailableTodoThinkingLevels(currentModel) : undefined;
 		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
 		registerTodoTool(pi, {
 			...thinkingPrompt,
+			...(availableThinkingLevels ? { parameters: todoParamsSchemaForThinkingLevels(availableThinkingLevels) } : {}),
 			prepareMutation: (state, _ctx, info) => {
 				if (!todoThinkingEnabled) return info.params;
-				if (info.action === "update") return prepareTodoThinkingMutation(state, info.params);
-				if (info.action === "batch_update") {
+				if (info.action === "create" || info.action === "update") return prepareTodoThinkingMutation(state, info.params);
+				if (info.action === "batch_create" || info.action === "batch_update") {
 					return {
 						...info.params,
 						items: (info.params.items ?? []).map((item) => prepareTodoThinkingMutation(state, item)),
@@ -194,20 +236,29 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	function prepareTodoThinkingMutation(state: ReturnType<typeof getState>, params: TaskMutationParams): TaskMutationParams {
-		if (params.id === undefined) return params;
-		const current = state.tasks.find((task) => task.id === params.id);
-		if (!current) return params;
-		const nextStatus = params.status ?? current.status;
-		const nextThinking = params.thinking ?? current.thinking;
+		let nextParams = params;
+		if (params.thinking !== undefined) {
+			const normalized = normalizeTodoThinkingLevelForModel(currentModel, params.thinking);
+			if (normalized !== params.thinking) nextParams = { ...nextParams, thinking: normalized };
+		}
+		if (nextParams.id === undefined) return nextParams;
+		const current = state.tasks.find((task) => task.id === nextParams.id);
+		if (!current) return nextParams;
+		const nextStatus = nextParams.status ?? current.status;
+		if (nextStatus === "in_progress" && nextParams.thinking === undefined && current.thinking !== undefined) {
+			const normalized = normalizeTodoThinkingLevelForModel(currentModel, current.thinking);
+			if (normalized !== current.thinking) nextParams = { ...nextParams, thinking: normalized };
+		}
+		const nextThinking = nextParams.thinking ?? current.thinking;
 		const shouldCapturePreviousThinking =
-			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || params.thinking !== undefined);
-		if (!shouldCapturePreviousThinking) return params;
+			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || nextParams.thinking !== undefined);
+		if (!shouldCapturePreviousThinking) return nextParams;
 		const currentThinking = getCurrentThinkingLevel();
-		if (!currentThinking) return params;
+		if (!currentThinking) return nextParams;
 		return {
-			...params,
+			...nextParams,
 			metadata: {
-				...(params.metadata ?? {}),
+				...(nextParams.metadata ?? {}),
 				[TODO_THINKING_RESTORE_METADATA_KEY]: currentThinking,
 			},
 		};
@@ -233,7 +284,8 @@ export default function (pi: ExtensionAPI) {
 		const previous = getRememberedThinking(taskId, state);
 		if (!previous) return;
 		rememberedThinkingByTaskId.delete(taskId);
-		if (getCurrentThinkingLevel() !== previous) setTodoThinkingLevel(previous);
+		const restored = normalizeTodoThinkingLevelForModel(currentModel, previous);
+		if (getCurrentThinkingLevel() !== restored) setTodoThinkingLevel(restored);
 	}
 
 	function restoreInactiveTodoThinking(state: ReturnType<typeof getState>): void {

package/external/pi-tools-suite/src/todo/todo.ts

@@ -91,6 +91,7 @@ interface TodoToolHooks {
 interface TodoToolRegistrationOptions extends TodoToolHooks {
 	promptSnippet?: string;
 	promptGuidelines?: string[];
+	parameters?: typeof TodoParamsSchema;
 }
 
 type TodoStateEventContext = { sessionManager?: { getSessionFile?: () => unknown; getSessionId?: () => unknown } };
@@ -391,7 +392,7 @@ export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolRegistrationOp
 		label: TOOL_LABEL,
 		promptSnippet: hooks.promptSnippet ?? DEFAULT_PROMPT_SNIPPET,
 		promptGuidelines: hooks.promptGuidelines ?? DEFAULT_PROMPT_GUIDELINES,
-		parameters: TodoParamsSchema,
+		parameters: hooks.parameters ?? TodoParamsSchema,
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 			activateTodoStateScope(_ctx);

package/external/pi-tools-suite/src/todo/tool/types.ts

@@ -24,7 +24,8 @@ export const MSG_NO_TODOS = "No todos yet. Ask the agent to add some!";
 // ---------------------------------------------------------------------------
 
 export type TaskStatus = "pending" | "in_progress" | "deferred" | "completed" | "deleted";
-export type TodoThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export const TODO_THINKING_LEVEL_VALUES = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type TodoThinkingLevel = (typeof TODO_THINKING_LEVEL_VALUES)[number];
 
 export type TaskAction = "create" | "update" | "batch_create" | "batch_update" | "list" | "get" | "delete" | "clear" | "export" | "import";
 
@@ -104,7 +105,7 @@ export const TodoParamsSchema = Type.Object({
 		}),
 	),
 	thinking: Type.Optional(
-		StringEnum(["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const, {
+		StringEnum(TODO_THINKING_LEVEL_VALUES, {
 			description: "Per-task thinking level used when todoThinking is enabled and this task is in_progress",
 		}),
 	),
@@ -164,4 +165,20 @@ export const TodoParamsSchema = Type.Object({
 	replace: Type.Optional(Type.Boolean({ description: "For import/create/batch_create, replace existing tasks instead of appending. Use batch_create with replace:true when starting a new plan that supersedes old unfinished todos. Default: false." })),
 });
 
+export function todoParamsSchemaForThinkingLevels(levels: readonly TodoThinkingLevel[]): typeof TodoParamsSchema {
+	const supported = TODO_THINKING_LEVEL_VALUES.filter((level) => levels.includes(level));
+	const effective = supported.length > 0 ? supported : ["off"];
+	return {
+		...TodoParamsSchema,
+		properties: {
+			...TodoParamsSchema.properties,
+			thinking: Type.Optional(
+				StringEnum(effective as unknown as typeof TODO_THINKING_LEVEL_VALUES, {
+					description: "Per-task thinking level used when todoThinking is enabled and this task is in_progress",
+				}),
+			),
+		},
+	} as typeof TodoParamsSchema;
+}
+
 export type TodoParams = Static<typeof TodoParamsSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {