@f5-sales-demo/xcsh 19.104.0 → 19.105.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [19.105.1] - 2026-07-31
+
+### Fixed
+
+- Fixed GPT-5.6 Sol inference through LiteLLM when deterministic print mode requests an unsupported temperature ([#2698](https://github.com/f5-sales-demo/xcsh/issues/2698))
+
 ## [19.104.0] - 2026-07-31
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "19.104.0",
+	"version": "19.105.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -57,13 +57,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@mozilla/readability": "^0.6",
-		"@f5-sales-demo/xcsh-stats": "19.104.0",
-		"@f5-sales-demo/pi-agent-core": "19.104.0",
-		"@f5-sales-demo/pi-ai": "19.104.0",
-		"@f5-sales-demo/pi-natives": "19.104.0",
-		"@f5-sales-demo/pi-resource-management": "19.104.0",
-		"@f5-sales-demo/pi-tui": "19.104.0",
-		"@f5-sales-demo/pi-utils": "19.104.0",
+		"@f5-sales-demo/xcsh-stats": "19.105.1",
+		"@f5-sales-demo/pi-agent-core": "19.105.1",
+		"@f5-sales-demo/pi-ai": "19.105.1",
+		"@f5-sales-demo/pi-natives": "19.105.1",
+		"@f5-sales-demo/pi-resource-management": "19.105.1",
+		"@f5-sales-demo/pi-tui": "19.105.1",
+		"@f5-sales-demo/pi-utils": "19.105.1",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/browser/office-pane-server.ts

@@ -43,8 +43,58 @@ const IS_BUN_COMPILED =
 
 // Dev-mode assets: packages/coding-agent/src/browser → packages/office-pane/dist.
 const DEV_DIST_DIR = path.resolve(import.meta.dir, "..", "..", "..", "office-pane", "dist");
+/** The office-pane package itself. Present in a checkout, absent from a published tarball. */
+const DEV_PACKAGE_DIR = path.dirname(DEV_DIST_DIR);
 const COMPILED_DIR_ROOT = path.join(os.tmpdir(), "xcsh-office-pane");
 
+/**
+ * The files a usable pane must have regardless of what its manifest says.
+ *
+ * Not one marker. The build writes `taskpane.html` first and `manifest.json` three steps later, so a
+ * single marker accepts an interrupted build: `serve` would answer the page, then `manifest` and
+ * `sideload` would fail with the same ENOENT this check exists to replace.
+ */
+const PANE_REQUIRED_FILES = ["taskpane.html", "taskpane.js", "manifest.json"] as const;
+
+/**
+ * The assets a manifest says it needs, as dist-relative paths.
+ *
+ * Read out of the manifest rather than listed in this file, so adding an icon there cannot leave this
+ * check behind — the same "one map, or the copies drift" rule the rest of the pane follows.
+ *
+ * They are NOT cosmetic, which an earlier version of this guard assumed by grouping them with the
+ * fonts. `office sideload` shells out to office-addin-debugging, whose zip step fails outright on a
+ * missing `assets/color.png`; the comment in `runSideload` records exactly that. Since the build copies
+ * `assets/` after `manifest.json`, an interruption between the two leaves every other required file in
+ * place — and `runSideload` deletes the existing WEF registration before it discovers the problem.
+ *
+ * The manifest carries both forms, `assets/color.png` and an absolute `…:8444/assets/icon-16.png`, and
+ * both normalise to the same dist-relative path.
+ */
+export function manifestAssetPaths(manifestText: string): string[] {
+	return [...new Set(manifestText.match(/assets\/[\w.-]+/g) ?? [])];
+}
+
+/** Which supply route was expected to provide the pane, and therefore what the remedy is. */
+export type PaneSource = "compiled" | "dev" | "packaged";
+
+/**
+ * There is no pane to serve, and it is the environment's doing rather than a bug.
+ *
+ * Its own class so the command boundary can print the remedy and exit 1, while a real defect keeps its
+ * stack trace. String-matching the message would couple the two and quietly swallow the next genuine
+ * failure whose text happened to look similar.
+ */
+export class OfficePaneUnavailableError extends Error {
+	constructor(
+		message: string,
+		readonly source: PaneSource,
+	) {
+		super(message);
+		this.name = "OfficePaneUnavailableError";
+	}
+}
+
 const getEmbeddedArchive = (() => {
 	const txt = embeddedPaneArchiveTxt.replaceAll(/[\s\r\n]/g, "").trim();
 	if (!txt) return null;
@@ -81,31 +131,166 @@ async function extractEmbeddedArchive(archiveBytes: Buffer, outputDir: string):
 	}
 }
 
+/**
+ * Why there is no pane to serve, and what to do about it.
+ *
+ * Pure, and separate from the check, because the wording is the whole value of this path and the two
+ * audiences need opposite advice. Telling a developer to install a binary hides that they have simply
+ * not built yet; telling somebody who installed from npm to run a build names a directory they do not
+ * have. Getting that backwards is worse than the ENOENT it replaces.
+ */
+export function paneUnavailableMessage(distDir: string, source: PaneSource): string {
+	if (source === "compiled") {
+		return (
+			"The Office pane is missing from this binary: office-pane.generated.txt carries no embedded " +
+			"archive. Rebuild the binary with the office-pane assets baked in."
+		);
+	}
+	if (source === "dev") {
+		return (
+			`The Office pane has not been built: ${distDir} does not exist. ` +
+			"Run `bun run build` in packages/office-pane, then try again."
+		);
+	}
+	return (
+		"The Office pane is not included in the npm package — it ships as a build-time asset of the " +
+		"compiled binary, which is also what provides the sideload and the trusted certificate. " +
+		"Install it with `brew install f5-sales-demo/tap/xcsh` and run `xcsh office` from there."
+	);
+}
+
+/**
+ * Which supply route a non-compiled run was relying on, from whether the office-pane package is here.
+ *
+ * A checkout has `packages/office-pane` and may simply not have built it; a published tarball has no
+ * `packages/` directory at all. One line, but the line that chooses between two opposite remedies, so
+ * it is named and tested rather than inlined as a ternary nothing covers.
+ */
+export function paneSourceForLayout(officePanePackagePresent: boolean): PaneSource {
+	return officePanePackagePresent ? "dev" : "packaged";
+}
+
+/** The manifest's text if it parses as JSON, else null — presence alone says too little. */
+async function readValidManifest(manifestPath: string): Promise<string | null> {
+	try {
+		const text = await Bun.file(manifestPath).text();
+		JSON.parse(text);
+		return text;
+	} catch {
+		return null;
+	}
+}
+
+/** Which of the files a usable pane needs are absent from `dir`. Empty means complete. */
+export async function missingPaneFiles(dir: string): Promise<string[]> {
+	const missing: string[] = [];
+	for (const name of PANE_REQUIRED_FILES) {
+		if (!(await Bun.file(path.join(dir, name)).exists())) missing.push(name);
+	}
+	// Only worth asking once the manifest is there to be read — and a manifest that is present but
+	// unreadable is not a manifest. A truncated one has no asset references, so an existence-only check
+	// finds nothing missing, calls the pane complete, and lets `office manifest` print invalid JSON.
+	if (!missing.includes("manifest.json")) {
+		const manifestText = await readValidManifest(path.join(dir, "manifest.json"));
+		if (manifestText === null) {
+			missing.push("manifest.json (present but not valid JSON)");
+		} else {
+			for (const asset of manifestAssetPaths(manifestText)) {
+				if (!(await Bun.file(path.join(dir, asset)).exists())) missing.push(asset);
+			}
+		}
+	}
+	return missing;
+}
+
+/** True when `dir` holds every file a pane needs. */
+export async function isCompletePane(dir: string): Promise<boolean> {
+	return (await missingPaneFiles(dir)).length === 0;
+}
+
+/**
+ * Return `dir` only if it actually holds a built pane, else refuse with {@link paneUnavailableMessage}.
+ *
+ * The dev branch used to return its path unchecked, which is how a published npm install came to bind
+ * :8444 and answer 404 to every request — Office rendered "Not Found" and nothing reported an error.
+ * Serving nothing quietly is the failure this exists to prevent.
+ */
+export async function resolvePaneDir(dir: string, source: PaneSource): Promise<string> {
+	const missing = await missingPaneFiles(dir);
+	if (missing.length === 0) return dir;
+	// Name what is absent. "The pane is missing" sends someone looking at the whole directory; "no
+	// manifest.json" points at the step of the build that did not finish.
+	throw new OfficePaneUnavailableError(
+		`${paneUnavailableMessage(dir, source)} (missing: ${missing.join(", ")})`,
+		source,
+	);
+}
+
+/**
+ * Extract into a staging directory and move it into place only once it validates.
+ *
+ * Extraction used to write straight into the final hash-addressed directory, so an interruption or a
+ * full disk left a partial bundle exactly where the next run looks for a finished one — and every run
+ * after that accepted it, serving a pane whose JS 404s or whose script is half a file.
+ *
+ * Validating file CONTENTS would be an endless chase: a truncated `taskpane.js` is still valid text, so
+ * each new file type invites its own check. Publishing atomically closes the whole class instead. A
+ * crash leaves a `.incoming-*` directory, which the cache lookup ignores because it is not the name it
+ * asks for.
+ *
+ * The staging name carries the pid so two processes racing a first run cannot rename over each other
+ * mid-extraction.
+ */
+export async function publishCompletePane(
+	outputDir: string,
+	extractInto: (stagingDir: string) => Promise<void>,
+): Promise<string> {
+	const stagingDir = `${outputDir}.incoming-${process.pid}`;
+	await fs.rm(stagingDir, { recursive: true, force: true });
+	await fs.mkdir(stagingDir, { recursive: true });
+	try {
+		await extractInto(stagingDir);
+		// Validate BEFORE publishing, so an incomplete extraction never becomes the cache.
+		await resolvePaneDir(stagingDir, "compiled");
+		await fs.rm(outputDir, { recursive: true, force: true });
+		await fs.rename(stagingDir, outputDir);
+		return outputDir;
+	} finally {
+		await fs.rm(stagingDir, { recursive: true, force: true });
+	}
+}
+
 /**
  * Resolve the directory the assets are served from: the extracted embedded
  * bundle in a compiled binary, else `packages/office-pane/dist` in dev.
  */
 export async function getOfficePaneDir(): Promise<string> {
-	if (!IS_BUN_COMPILED) return DEV_DIST_DIR;
+	if (!IS_BUN_COMPILED) {
+		const present = await Bun.file(path.join(DEV_PACKAGE_DIR, "package.json")).exists();
+		return resolvePaneDir(DEV_DIST_DIR, paneSourceForLayout(present));
+	}
 	if (compiledDirPromise) return compiledDirPromise;
 
 	const archiveBytes = getEmbeddedArchive?.();
 	if (!archiveBytes) {
-		throw new Error("Compiled office-pane bundle missing. Rebuild the binary with the embedded office-pane assets.");
+		throw new OfficePaneUnavailableError(paneUnavailableMessage(COMPILED_DIR_ROOT, "compiled"), "compiled");
 	}
 
 	compiledDirPromise = (async () => {
 		const bundleHash = Bun.hash(archiveBytes).toString(16);
 		const outputDir = path.join(COMPILED_DIR_ROOT, bundleHash);
-		const markerPath = path.join(outputDir, "taskpane.html");
-		try {
-			if ((await fs.stat(markerPath)).isFile()) return outputDir;
-		} catch {}
+		// A cached extraction is reused only if it is COMPLETE. The old check was `taskpane.html` alone,
+		// so an extraction interrupted after the page but before its bundle left a hash-addressed
+		// directory that every later run accepted — superseding a working server to serve a pane whose
+		// JS 404s, until somebody deleted a temp directory they had no reason to suspect.
+		//
+		// Incomplete is not fatal here, unlike in the dev case: the archive is in hand, so the remedy is
+		// to extract it again rather than to tell anyone anything.
+		if (await isCompletePane(outputDir)) return outputDir;
 
-		await fs.rm(outputDir, { recursive: true, force: true });
-		await fs.mkdir(outputDir, { recursive: true });
-		await extractEmbeddedArchive(archiveBytes, outputDir);
-		return outputDir;
+		// Still incomplete after a fresh extraction means the baked archive is itself short, which no
+		// amount of retrying fixes — publishCompletePane refuses rather than serving a pane with holes.
+		return publishCompletePane(outputDir, staging => extractEmbeddedArchive(archiveBytes, staging));
 	})();
 
 	return compiledDirPromise;
@@ -151,9 +336,13 @@ export interface OfficePaneServer {
  * Start the fixed :8444 HTTPS listener serving the embedded/dev assets. Resolves
  * TLS via {@link resolveBridgeTls} (the shared local-ip.sh cert). Serves only GET
  * (405 otherwise); unknown paths return 404.
+ *
+ * The asset directory is resolved BEFORE the port is bound and before TLS is fetched, so a run with
+ * no pane available refuses without holding :8444 and without reaching the network. `assetDir` is the
+ * seam that lets a test assert exactly that, in the same spirit as the pure `handleAssetRequest`.
  */
-export async function startOfficePaneServer(port = OFFICE_PANE_PORT): Promise<OfficePaneServer> {
-	const dir = await getOfficePaneDir();
+export async function startOfficePaneServer(port = OFFICE_PANE_PORT, assetDir?: string): Promise<OfficePaneServer> {
+	const dir = assetDir === undefined ? await getOfficePaneDir() : await resolvePaneDir(assetDir, "dev");
 	const tls = await resolveBridgeTls();
 
 	const server = Bun.serve({

package/src/cli/office-cli.ts

@@ -17,6 +17,7 @@ import {
 	getOfficePaneDir,
 	OFFICE_PANE_PORT,
 	type OfficePaneServer,
+	OfficePaneUnavailableError,
 	readManifest,
 	startOfficePaneServer,
 } from "../browser/office-pane-server";
@@ -55,9 +56,15 @@ export interface OfficeServeDeps {
 	startOfficePaneServer: typeof startOfficePaneServer;
 	startHeadlessChatBridge: typeof startHeadlessChatBridge;
 	supersedeStaleServe: typeof supersedeStaleServe;
+	getOfficePaneDir: typeof getOfficePaneDir;
 }
 
-const defaultServeDeps: OfficeServeDeps = { startOfficePaneServer, startHeadlessChatBridge, supersedeStaleServe };
+const defaultServeDeps: OfficeServeDeps = {
+	startOfficePaneServer,
+	startHeadlessChatBridge,
+	supersedeStaleServe,
+	getOfficePaneDir,
+};
 
 /** A running `office serve`: the pane file server, the (optional) chat bridge, and
  *  a teardown that disposes both. */
@@ -75,6 +82,12 @@ export interface OfficeServeHandle {
  * Extracted from {@link runServe} so the start/teardown wiring is unit-testable.
  */
 export async function startOfficeServe(deps: OfficeServeDeps = defaultServeDeps): Promise<OfficeServeHandle> {
+	// Prove there is a pane to serve BEFORE anything is torn down. supersedeStaleServe SIGTERMs a
+	// running serve to take the port, so checking afterwards let an install with no pane at all stop
+	// the operator's working one and then exit with nothing in its place. Refusing loudly is only an
+	// improvement if it refuses before it breaks something.
+	await deps.getOfficePaneDir();
+
 	// Step down a stale serve squatting :8444 (e.g. left over from before a
 	// `brew upgrade`) so this start binds cleanly instead of "port 8444 in use".
 	const superseded = await deps.supersedeStaleServe(OFFICE_PANE_PORT);
@@ -238,6 +251,21 @@ export async function runOfficeCommand(
 	args: OfficeCommandArgs,
 	deps: OfficeCommandDeps = defaultCommandDeps,
 ): Promise<void> {
+	try {
+		await dispatchOfficeCommand(args, deps);
+	} catch (err) {
+		// Only this one class. The published npm form carries `office` and no pane bundle, so every
+		// action here can legitimately have nothing to work with — that is a fact about the install,
+		// not a defect, and it deserves the remedy rather than a stack trace. Anything else rethrows
+		// with its stack intact, because swallowing a real failure here is how the original silent
+		// 404 survived.
+		if (!(err instanceof OfficePaneUnavailableError)) throw err;
+		console.error(err.message);
+		process.exitCode = 1;
+	}
+}
+
+async function dispatchOfficeCommand(args: OfficeCommandArgs, deps: OfficeCommandDeps): Promise<void> {
 	switch (args.action) {
 		case "serve":
 			await deps.serve();

package/src/config/model-registry.ts

@@ -140,6 +140,7 @@ const ReasoningEffortMapSchema = Type.Object({
 
 const OpenAICompatSchema = Type.Object({
 	supportsStore: Type.Optional(Type.Boolean()),
+	supportsTemperature: Type.Optional(Type.Boolean()),
 	supportsDeveloperRole: Type.Optional(Type.Boolean()),
 	supportsReasoningEffort: Type.Optional(Type.Boolean()),
 	reasoningEffortMap: Type.Optional(ReasoningEffortMapSchema),

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "19.104.0",
-	"commit": "f07ee3a993f88e57cd1b44eb586f1ea527b63e27",
-	"shortCommit": "f07ee3a",
+	"version": "19.105.1",
+	"commit": "9f750089164f53de345f753a606ba28ff4cd446b",
+	"shortCommit": "9f75008",
 	"branch": "main",
-	"tag": "v19.104.0",
-	"commitDate": "2026-07-31T13:40:17Z",
-	"buildDate": "2026-07-31T14:12:51.834Z",
+	"tag": "v19.105.1",
+	"commitDate": "2026-07-31T15:37:23Z",
+	"buildDate": "2026-07-31T16:02:58.879Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/f07ee3a993f88e57cd1b44eb586f1ea527b63e27",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.104.0"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/9f750089164f53de345f753a606ba28ff4cd446b",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v19.105.1"
 };