pi-llamacpp-infra 1.2.1 → 1.2.3

package/README.md

@@ -25,6 +25,7 @@ Anything else (vLLM, Ollama, cloud APIs…) is out of scope — use pi's built-i
 - **Multi-machine discovery** — configurable list of servers (host, ports, API key, options); probes all of them at startup and on demand
 - **Compact model ids** — models appear as `Name (host:port)` in pi's `/model` picker, like a native provider; the raw GGUF path/alias is sent to the server automatically on every request
 - **Single-model & router modes** — llama.cpp single-model mode (one GGUF per instance) and router mode (multiple models per server, with per-model status and args)
+- **Long local generations** — discovered models are registered with up to **32,768 output tokens** (bounded by the model/server context) and llamacpp-infra OpenAI-compatible requests enforce a **20 minute** timeout floor so slow local runs don't get cut early by pi defaults
 - **Per-model metadata badges** — 👁️ vision (mmproj / modalities), 🚀 drafter (speculative decoding), 🗜️ quant tag from GGUF filename, 🧠 KV cache quantization (from server args or `/proc`)
 - **Live speed & metrics** — a constantly updating footer reading of the active model's prefill (⚡) and generation (🔥) token speed, measured straight from the stream (per token, ~10 updates/s); when pi is idle it also mirrors other clients the server's `/metrics` endpoint reports. Lives in the footer's status line, so no extra terminal row is taken. Works even without `--metrics`
 - **Thinking budgets** — llama.cpp accepts `thinking_budget_tokens` per request; configure budgets per thinking level (minimal/low/medium/high/xhigh/max) per model; models with budgets are registered with reasoning enabled
@@ -223,6 +224,8 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
 | `prefixModelIds` | `true` | Append the machine tag `(host:port)` to model ids; OFF keeps bare names and only disambiguates collisions |
 | `showBadgesInNames` | `true` | Append 👁️🚀💤 badges to model display names |
 | `includeUnloadedRouterModels` | `false` | Router mode: list models that are not currently loaded |
+| output cap | `32768` | Registered per model as `maxTokens` unless the server reports an explicit `max_tokens`; still bounded by available context |
+| request timeout | `1200000` | 20 minute timeout floor applied to llamacpp-infra OpenAI-compatible streams |
 | `warmup` | `true` | Pre-cache system prompt KV on llama.cpp servers |
 | `metricsEnabled` | `true` | Show live speed & metrics in the footer for llamacpp-infra models |
 | `metricsPollMs` | `5000` | How often `/metrics` is fetched |
@@ -247,20 +250,20 @@ llama.cpp-family models are registered as reasoning models, exactly like a nativ
 
 ## Live Speed & Metrics (footer)
 
-When enabled, the speed reading appears in the footer's status line (no extra terminal row) whenever the active model is from llamacpp-infra, updating constantly while tokens flow:
+When enabled, the speed reading appears in the footer's status line (no extra terminal row) whenever the active model is from llamacpp-infra, updating constantly while tokens flow. Both entries are kept ultra-compact so they coexist with other extensions on pi's single status line (which truncates from the end):
 
 ```
-🦙 12 models · 3/3 ✓ 📊 · ⚡ prefill…                    (before the first token)
-🦙 12 models · 3/3 ✓ 📊 · 🔥 38.1 t/s · ⚡ 420 · 1.2k tok  (while streaming)
-🦙 12 models · 3/3 ✓ 📊 · 🔥 38.1 t/s · ⚡ 420 · 1.2k tok  (just after the answer ends)
-🦙 12 models · 3/3 ✓ 📊 · ⏸ idle                         (between turns)
-🦙 12 models · 3/3 ✓ 📊 · ▶ 2 · ⚡ 150 · 🔥 18.0 · server (pi idle, server busy for other clients)
+🦙(12) ⚡…            (before the first token)
+🦙(12) ⚡ 420 t/s 🔥 38.1 t/s  (while streaming)
+🦙(12) ⚡ 420 t/s 🔥 38.1 t/s  (just after the answer ends)
+🦙(12) ⏸             (between turns)
+🦙(12) ▶2 ⚡ 150 t/s 🔥 18.0 t/s  (pi idle, server busy for other clients)
 ```
 
-(The `🦙 …` prefix is the extension's model-count status; both live on the same footer line, so no extra row is consumed.)
+(`🦙(n)` is the extension's model-count status; both live on the same footer line, so no extra row is consumed.)
 
 - **Client measurement (always, no `--metrics` needed)** — prefill speed = `prompt tokens ÷ (request → first token)` (pi's `usage.input`, OpenAI-style `prompt_tokens` as fallback); generation speed = a moving 1.5 s window over per-token arrival samples. Updated ~every 100 ms while a stream is live (throttled, and unchanged text is skipped, so the footer never churns).
-- **Server supplement (only when pi is idle)** — the poller fetches the server's Prometheus `/metrics` endpoint (or JSON `/stats`) every `metricsPollMs` (default 5 s). If the server reports other clients processing, their ⚡/🔥 rates are shown; when the server is idle, the plain `⏸ idle` reading returns.
+- **Server supplement (only when pi is idle)** — the poller fetches the server's Prometheus `/metrics` endpoint (or JSON `/stats`) every `metricsPollMs` (default 5 s). If the server reports other clients processing, their ⚡/🔥 rates are shown (`▶n`); when the server is idle, the plain `⏸` reading returns.
 
 ## Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llamacpp-infra",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Discovery, metrics and control of llama.cpp-family servers for pi (llama.cpp, ZINC, DwarfStar/ds4, lucebox, LM Studio): scan machines (localhost, LAN, Tailscale), register models, live metrics, per-model thinking budgets, vision detection, native config UI.",
   "keywords": [
     "pi-package",

package/src/core.ts

@@ -21,6 +21,8 @@ export const LEGACY_CONFIG_FILE = "local-models.json";
 export const METRICS_STATUS_KEY = "llamacpp-infra-speed";
 export const DEFAULT_API_KEY = "no-auth";
 export const THINKING_BUDGET_FIELD = "thinking_budget_tokens";
+export const DEFAULT_MAX_OUTPUT_TOKENS = 32_768;
+export const DEFAULT_PROVIDER_TIMEOUT_MS = 20 * 60 * 1000;
 
 // ── Settings defaults ───────────────────────────────────────────────────────
 export const DEFAULT_SETTINGS: SettingsConfig = {
@@ -28,6 +30,8 @@ export const DEFAULT_SETTINGS: SettingsConfig = {
 	pollIntervalMs: 4000,
 	pollMaxMs: 90_000,
 	startupGraceMs: 40_000,
+	maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS,
+	requestTimeoutMs: DEFAULT_PROVIDER_TIMEOUT_MS,
 	knownGoodFailLimit: 3,
 	detectVision: true,
 	prefixModelIds: true,

package/src/index.ts

@@ -20,6 +20,7 @@ import {
 	shared,
 	supportsThinkingBudget,
 } from "./core.ts";
+import { createLongTimeoutOpenAICompletionsStream } from "./runtime.ts";
 
 export default function (pi: ExtensionAPI) {
 	const config = loadConfig();
@@ -120,6 +121,7 @@ export default function (pi: ExtensionAPI) {
 			baseUrl: `http://${first?.host ?? "127.0.0.1"}:${first?.ports[0] ?? 8080}/v1`,
 			apiKey: first?.apiKey || "no-auth",
 			api: "openai-completions",
+			streamSimple: createLongTimeoutOpenAICompletionsStream,
 			models: [],
 		});
 		providerIsEmpty = true;
@@ -225,7 +227,7 @@ export default function (pi: ExtensionAPI) {
 
 	async function rescan(ctx?: ExtensionContext) {
 		if (!extensionActive) return;
-		if (ctxHasUI(ctx)) ctx.ui.setStatus(STATUS_KEY, "🔎 scanning…");
+		if (ctxHasUI(ctx)) ctx.ui.setStatus(STATUS_KEY, "🔎");
 		stopPolling();
 		registerEmptyProvider();
 		const r = await discoverAndRegister();
@@ -237,11 +239,9 @@ export default function (pi: ExtensionAPI) {
 	function updateStatusFooter(ctx?: ExtensionContext) {
 		if (!ctxHasUI(ctx)) return;
 		if (shared.registeredCount > 0) {
-			const up = shared.lastScan?.serversUp ?? 0;
-			const total = shared.lastScan?.serversTotal ?? 0;
-			ctx.ui.setStatus(STATUS_KEY, `🦙 ${shared.registeredCount} models · ${up}/${total} ✓`);
+			ctx.ui.setStatus(STATUS_KEY, `🦙(${shared.registeredCount})`);
 		} else if (shared.lastScan?.endpoints.some((e) => e.loading)) {
-			ctx.ui.setStatus(STATUS_KEY, "⏳ loading…");
+			ctx.ui.setStatus(STATUS_KEY, "⏳");
 		} else if (shared.lastError) {
 			ctx.ui.setStatus(STATUS_KEY, "⚠️");
 		} else {

package/src/registration.ts

@@ -21,6 +21,7 @@ import type {
 	ScanResult,
 } from "./types.ts";
 import { cleanModelName, lmStudioContextLength } from "./scan.ts";
+import { createLongTimeoutOpenAICompletionsStream } from "./runtime.ts";
 
 /** Compact badge string appended to display names when enabled. */
 function badgeSuffix(
@@ -73,7 +74,7 @@ function toPiModel(
 			name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
 			reasoning: false,
 			contextWindow,
-			maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
+			maxTokens: model.max_tokens ?? Math.min(contextWindow, settings.maxOutputTokens),
 			compat: makeCompat(kind),
 		};
 	}
@@ -92,7 +93,7 @@ function toPiModel(
 			name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
 			reasoning: ep.props?.capabilities?.reasoning_supported ?? true,
 			contextWindow,
-			maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
+			maxTokens: model.max_tokens ?? Math.min(contextWindow, settings.maxOutputTokens),
 			compat: makeCompat(kind),
 		};
 	}
@@ -118,7 +119,7 @@ function toPiModel(
 		name: `${displayName}${badgeSuffix(modelMeta, settings.showBadgesInNames)}`,
 		reasoning: isLlamaFamily,
 		contextWindow,
-		maxTokens: model.max_tokens ?? Math.min(contextWindow, 8192),
+		maxTokens: model.max_tokens ?? Math.min(contextWindow, settings.maxOutputTokens),
 		compat: makeCompat(kind),
 	};
 }
@@ -232,6 +233,7 @@ export function buildAndRegisterProvider(pi: ExtensionAPI, scan: ScanResult, con
 		baseUrl: defaultBaseUrl,
 		apiKey: defaultApiKey,
 		api: "openai-completions",
+		streamSimple: createLongTimeoutOpenAICompletionsStream,
 		models: piModels,
 	});
 

package/src/runtime.ts

@@ -0,0 +1,131 @@
+// Runtime request defaults for the OpenAI-compatible llama.cpp provider.
+// pi owns the normal SDK stream options, but this provider is for slow local
+// models where long generations are expected. Keep a local floor so llamacpp-
+// infra models don't inherit too-small global/default request timeouts.
+
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { DEFAULT_PROVIDER_TIMEOUT_MS, shared } from "./core.ts";
+
+type AssistantMessageEvent = any;
+type AssistantMessage = any;
+type StreamOptions = Record<string, any> | undefined;
+type StreamSimple = (model: any, context: any, options?: Record<string, any>) => AsyncIterable<AssistantMessageEvent> & { result?: () => Promise<AssistantMessage> };
+
+class ForwardedAssistantMessageEventStream implements AsyncIterable<AssistantMessageEvent> {
+	private queue: AssistantMessageEvent[] = [];
+	private waiting: Array<(result: IteratorResult<AssistantMessageEvent>) => void> = [];
+	private done = false;
+	private resolveFinal!: (value: AssistantMessage) => void;
+	private readonly finalResult = new Promise<AssistantMessage>((resolve) => {
+		this.resolveFinal = resolve;
+	});
+
+	push(event: AssistantMessageEvent): void {
+		if (this.done) return;
+		if (event?.type === "done") {
+			this.done = true;
+			this.resolveFinal(event.message);
+		} else if (event?.type === "error") {
+			this.done = true;
+			this.resolveFinal(event.error);
+		}
+
+		const waiter = this.waiting.shift();
+		if (waiter) waiter({ value: event, done: false });
+		else this.queue.push(event);
+	}
+
+	end(result?: AssistantMessage): void {
+		this.done = true;
+		if (result !== undefined) this.resolveFinal(result);
+		while (this.waiting.length > 0) this.waiting.shift()?.({ value: undefined, done: true });
+	}
+
+	async *[Symbol.asyncIterator](): AsyncIterator<AssistantMessageEvent> {
+		for (;;) {
+			if (this.queue.length > 0) {
+				yield this.queue.shift();
+			} else if (this.done) {
+				return;
+			} else {
+				const next = await new Promise<IteratorResult<AssistantMessageEvent>>((resolve) => this.waiting.push(resolve));
+				if (next.done) return;
+				yield next.value;
+			}
+		}
+	}
+
+	result(): Promise<AssistantMessage> {
+		return this.finalResult;
+	}
+}
+
+let openAICompletionsStreamPromise: Promise<StreamSimple> | undefined;
+
+async function loadOpenAICompletionsStreamSimple(): Promise<StreamSimple> {
+	if (!openAICompletionsStreamPromise) {
+		openAICompletionsStreamPromise = (async () => {
+			try {
+				const mod = await import("@earendil-works/pi-ai/api/openai-completions");
+				return (mod as { streamSimple: StreamSimple }).streamSimple;
+			} catch {
+				// In pi package installs, pi-ai may be nested under pi-coding-agent
+				// instead of hoisted as a top-level dependency of this extension.
+				const piIndexUrl = import.meta.resolve("@earendil-works/pi-coding-agent");
+				const piPackageDir = dirname(dirname(fileURLToPath(piIndexUrl)));
+				const nestedModule = join(piPackageDir, "node_modules", "@earendil-works", "pi-ai", "dist", "api", "openai-completions.js");
+				const mod = await import(pathToFileURL(nestedModule).href);
+				return (mod as { streamSimple: StreamSimple }).streamSimple;
+			}
+		})();
+	}
+	return openAICompletionsStreamPromise;
+}
+
+export function activeRequestTimeoutMs(): number {
+	const configured = shared.activeConfig?.settings?.requestTimeoutMs;
+	return typeof configured === "number" && Number.isFinite(configured) && configured > 0
+		? configured
+		: DEFAULT_PROVIDER_TIMEOUT_MS;
+}
+
+export function withLocalRuntimeDefaults(options: StreamOptions, floorMs?: number): Record<string, any> {
+	const floor = typeof floorMs === "number" && Number.isFinite(floorMs) && floorMs > 0 ? floorMs : DEFAULT_PROVIDER_TIMEOUT_MS;
+	const currentTimeout = typeof options?.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? options.timeoutMs : undefined;
+	return {
+		...(options ?? {}),
+		timeoutMs: currentTimeout === undefined ? floor : Math.max(currentTimeout, floor),
+	};
+}
+
+export function createLongTimeoutOpenAICompletionsStream(model: any, context: any, options?: Record<string, any>) {
+	const out = new ForwardedAssistantMessageEventStream();
+	void (async () => {
+		try {
+			const streamSimple = await loadOpenAICompletionsStreamSimple();
+			const inner = streamSimple(model, context, withLocalRuntimeDefaults(options, activeRequestTimeoutMs()));
+			for await (const event of inner) out.push(event);
+			if (typeof inner.result === "function") out.end(await inner.result());
+			else out.end();
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			out.push({
+				type: "error",
+				reason: "error",
+				error: {
+					role: "assistant",
+					content: [],
+					api: model?.api ?? "openai-completions",
+					provider: model?.provider ?? "llamacpp-infra",
+					model: model?.id ?? "unknown",
+					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+					stopReason: "error",
+					errorMessage: message,
+					timestamp: Date.now(),
+				},
+			});
+		}
+	})();
+	return out;
+}

package/src/speed.ts

@@ -6,10 +6,15 @@
 //   prefill t/s  = prompt tokens / (before_provider_request → first token)
 //   gen t/s      = moving window over per-token arrival samples
 //
+// Footer format (kept ultra-compact so it coexists with other extensions on
+// pi's single status line, which is truncated at the end):
+//
+//   ⚡ {prefill} t/s 🔥 {gen} t/s
+//
 // The server-side /metrics polling (metrics.ts) only supplements this:
 // when the client is idle but the server reports other clients processing,
-// their rate is shown. The client measurement works even when the server has
-// no --metrics endpoint.
+// their rate is shown as `▶{n} ⚡ … t/s 🔥 … t/s`. The client measurement
+// works even when the server has no --metrics endpoint.
 
 import { debugLog, METRICS_STATUS_KEY } from "./core.ts";
 import type { AssistantMessageEvent, ExtensionContext, ServerMetricsState, ThemeFg } from "./types.ts";
@@ -126,58 +131,58 @@ export function createSpeedTracker(deps: SpeedDeps) {
 		return tokens / (span / 1000);
 	}
 
-	function buildLine(ctx: ExtensionContext | undefined, now: number): string[] {
+	function buildLine(ctx: ExtensionContext | undefined, now: number): string {
 		const f = fg(ctx);
-		const parts: string[] = [f("accent", "📊")];
+		const parts: string[] = [];
 
 		switch (state) {
 			case "prefill":
-				parts.push(f("warning", "⚡ prefill…"));
+				parts.push(f("warning", "⚡…"));
 				break;
 
 			case "streaming": {
+				// Prefill rate of the previous call (only known once it ended).
+				if (lastPrefillTps !== undefined) {
+					parts.push(f("muted", `⚡ ${Math.round(lastPrefillTps)} t/s`));
+				}
 				const gen = genRateAt(now);
 				if (gen !== undefined) {
 					lastGenTps = gen;
 					parts.push(f(rateColor(gen, "gen"), `🔥 ${formatRate(gen)} t/s`));
 				}
-				if (lastPrefillTps !== undefined) {
-					parts.push(f("muted", `⚡ ${Math.round(lastPrefillTps)}`));
-				}
-				parts.push(f("muted", `${tokenCount} tok`));
 				break;
 			}
 
 			case "done": {
-				if (lastGenTps !== undefined) {
-					parts.push(f("muted", `🔥 ${formatRate(lastGenTps)} t/s`));
-				}
 				if (lastPrefillTps !== undefined) {
-					parts.push(f("muted", `⚡ ${Math.round(lastPrefillTps)}`));
+					parts.push(f(rateColor(lastPrefillTps, "prefill"), `⚡ ${Math.round(lastPrefillTps)} t/s`));
+				}
+				if (lastGenTps !== undefined) {
+					parts.push(f(rateColor(lastGenTps, "gen"), `🔥 ${formatRate(lastGenTps)} t/s`));
 				}
-				parts.push(f("muted", `${tokenCount} tok`));
 				break;
 			}
 
 			case "idle": {
 				// Server supplement: this endpoint is busy for *other* clients.
 				if (server && server.processing > 0) {
-					parts.push(f("success", `▶ ${server.processing}`));
+					parts.push(f("success", `▶${server.processing}`));
 					if (server.promptTps !== undefined && server.promptTps > 0) {
-						parts.push(f(rateColor(server.promptTps, "prefill"), `⚡ ${Math.round(server.promptTps)}`));
+						parts.push(f(rateColor(server.promptTps, "prefill"), `⚡ ${Math.round(server.promptTps)} t/s`));
 					}
 					if (server.genTps !== undefined && server.genTps > 0) {
-						parts.push(f(rateColor(server.genTps, "gen"), `🔥 ${formatRate(server.genTps)}`));
+						parts.push(f(rateColor(server.genTps, "gen"), `🔥 ${formatRate(server.genTps)} t/s`));
 					}
-					parts.push(f("muted", "server"));
 				} else {
-					parts.push(f("muted", "⏸ idle"));
+					parts.push(f("muted", "⏸"));
 				}
 				break;
 			}
 		}
 
-		return [parts.join(" · ")];
+		// A stream is live but no rate is computable yet (first ~300 ms of a call).
+		if (parts.length === 0) parts.push(f("muted", "🔥…"));
+		return parts.join(" ");
 	}
 
 	function render(ctx: ExtensionContext | undefined, now: number, force = false): void {
@@ -186,7 +191,7 @@ export function createSpeedTracker(deps: SpeedDeps) {
 			return;
 		}
 		if (!deps.hasUI(ctx) || !deps.isOurs(ctx)) return;
-		const line = buildLine(ctx, now).join(" · ");
+		const line = buildLine(ctx, now);
 		if (!force && now - lastRenderAt < RENDER_THROTTLE_MS) return;
 		lastRenderAt = now;
 		// No visual change → skip (avoids a full UI re-render on the footer).

package/src/types.ts

@@ -31,6 +31,8 @@ export interface SettingsConfig {
 	pollIntervalMs: number;
 	pollMaxMs: number;
 	startupGraceMs: number;
+	maxOutputTokens: number;
+	requestTimeoutMs: number;
 	knownGoodFailLimit: number;
 	detectVision: boolean;
 	prefixModelIds: boolean;

package/src/ui.ts

@@ -64,6 +64,15 @@ function formatCtx(tokens: number | undefined): string {
 	return tokens >= 1024 ? `${Math.round(tokens / 1024)}k` : `${tokens}`;
 }
 
+function formatTokens(n: number): string {
+	if (!Number.isFinite(n) || n <= 0) return "0";
+	if (n >= 1024) {
+		const k = n / 1024;
+		return Number.isInteger(k) ? `${k}k` : `${k.toFixed(1)}k`;
+	}
+	return `${n}`;
+}
+
 function metadataBadges(m: ModelMetadata | undefined): string {
 	if (!m) return "";
 	const parts: string[] = [];
@@ -661,6 +670,16 @@ async function showSettingsMenu(ctx: ExtensionContext, deps: UiDeps): Promise<vo
 				label: `💤 Include unloaded router models: ${s.includeUnloadedRouterModels ? "ON" : "OFF"}`,
 				description: "router mode: list models not currently loaded",
 			},
+			{
+				value: "maxtokens",
+				label: `📏 Max output tokens: ${formatTokens(s.maxOutputTokens)}`,
+				description: "per-model ceiling for outgoing max_tokens requests",
+			},
+			{
+				value: "timeoutfloor",
+				label: `⏱️ Request timeout: ${formatMs(s.requestTimeoutMs)}`,
+				description: "lower bound on OpenAI-completions stream idle timeout",
+			},
 			{
 				value: "warmup",
 				label: `☕ Header warmup: ${s.warmup ? "ON" : "OFF"}`,
@@ -765,6 +784,25 @@ async function showSettingsMenu(ctx: ExtensionContext, deps: UiDeps): Promise<vo
 				saveConfig(config);
 				ctx.ui.notify(`☕ Header warmup ${config.settings.warmup ? "ON" : "OFF"}`, "info");
 				break;
+			case "maxtokens": {
+				const v = await pickNumber("📏 Max output tokens", [4_096, 8_192, 16_384, 24_576, 32_768, 49_152, 65_536]);
+				if (v !== undefined) {
+					config.settings.maxOutputTokens = v;
+					saveConfig(config);
+					ctx.ui.notify(`📏 Max output tokens: ${v.toLocaleString()}`, "info");
+					await deps.rescan(ctx);
+				}
+				break;
+			}
+			case "timeoutfloor": {
+				const v = await pickNumber("⏱️ Request timeout", [60_000, 300_000, 600_000, 1_200_000, 1_800_000, 3_600_000]);
+				if (v !== undefined) {
+					config.settings.requestTimeoutMs = v;
+					saveConfig(config);
+					ctx.ui.notify(`⏱️ Request timeout: ${formatMs(v)}`, "info");
+				}
+				break;
+			}
 			case "reset": {
 				const ok = await ctx.ui.confirm("♻️ Reset settings", "Restore all discovery settings to their defaults?");
 				if (ok) {