@oh-my-pi/pi-coding-agent 17.1.2 → 17.1.4

package/src/slash-commands/builtin-registry.ts

@@ -7,7 +7,12 @@ import { APP_NAME, getProjectDir, setProjectDir } from "@oh-my-pi/pi-utils";
 import { reset as resetCapabilities } from "../capability";
 import { COLLAB_GUEST_ALLOWED_COMMANDS, CollabGuestLink } from "../collab/guest";
 import { CollabHost } from "../collab/host";
-import { expandRoleAlias, getModelMatchPreferences, resolveCliModel } from "../config/model-resolver";
+import {
+	expandRoleAlias,
+	formatModelString,
+	getModelMatchPreferences,
+	resolveCliModel,
+} from "../config/model-resolver";
 import { applyProviderGlobalsFromSettings } from "../config/provider-globals";
 import type { SettingPath, SettingValue } from "../config/settings";
 import { settings } from "../config/settings";
@@ -37,6 +42,8 @@ import type { SessionOAuthAccountList } from "../session/agent-session-types";
 import { COMPACT_MODES, parseCompactArgs } from "../session/compact-modes";
 import { resolveResumableSession } from "../session/session-listing";
 import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
+import type { ComputerTool } from "../tools/computer";
+import { computerExposureMode } from "../tools/computer/exposure";
 import { expandTilde, resolveToCwd } from "../tools/path-utils";
 import { urlHyperlinkAlways } from "../tui";
 import {
@@ -90,9 +97,41 @@ function formatFastModeStatus(session: AgentSession): string {
 	return session.isFastModeEnabled() ? "on" : "off";
 }
 
-/** `/computer status` label for the session-effective `computer.enabled` value. */
+/** Detailed, session-effective `/computer status` diagnostics. */
 function formatComputerUseStatus(session: AgentSession): string {
-	return session.settings.get("computer.enabled") ? "on" : "off";
+	const enabled = session.settings.get("computer.enabled");
+	const active = session.getEnabledToolNames().includes("computer");
+	const model = session.model;
+	const modelName = model ? formatModelString(model) : "none";
+	const exposure = !enabled || !active ? "not exposed" : computerExposureMode(model);
+	const toolState = active ? "active" : enabled ? "unavailable" : "inactive";
+	const configured = {
+		backend: session.settings.get("computer.backend"),
+		display: session.settings.get("computer.display"),
+		maxWidth: session.settings.get("computer.maxWidth"),
+		maxHeight: session.settings.get("computer.maxHeight"),
+	};
+	const computerTool = session.getToolByName("computer") as Pick<ComputerTool, "effectiveConfiguration"> | undefined;
+	const effective = computerTool?.effectiveConfiguration ?? configured;
+	const configurationChanged =
+		effective.backend !== configured.backend ||
+		effective.display !== configured.display ||
+		effective.maxWidth !== configured.maxWidth ||
+		effective.maxHeight !== configured.maxHeight;
+	return [
+		`Computer use: ${enabled ? "enabled" : "disabled"}`,
+		`tool: ${toolState}`,
+		`backend: ${effective.backend}`,
+		`display: ${effective.display}`,
+		`capture: ${effective.maxWidth}×${effective.maxHeight}`,
+		...(configurationChanged
+			? [
+					`next-session settings: backend=${configured.backend}, display=${configured.display}, capture=${configured.maxWidth}×${configured.maxHeight}`,
+				]
+			: []),
+		`model: ${modelName}`,
+		`exposure: ${exposure}`,
+	].join(" · ");
 }
 
 /**
@@ -107,7 +146,9 @@ async function applyComputerUseToggle(session: AgentSession, enable: boolean): P
 		return "Computer use is unavailable in this session.";
 	}
 	session.settings.override("computer.enabled", enable);
-	return `Computer use ${enable ? "enabled" : "disabled"} for this session.`;
+	return enable
+		? `Computer use enabled for this session. ${formatComputerUseStatus(session)}`
+		: "Computer use disabled for this session.";
 }
 
 const AUTOCOMPLETE_DETAIL_LIMIT = 48;
@@ -573,11 +614,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			{ name: "status", description: "Show computer use status" },
 		],
 		allowArgs: true,
-		getTuiAutocompleteDescription: runtime => `Computer: ${formatComputerUseStatus(runtime.ctx.session)}`,
+		getTuiAutocompleteDescription: runtime =>
+			`Computer: ${runtime.ctx.session.settings.get("computer.enabled") ? "on" : "off"}`,
 		handle: async (command, runtime) => {
 			const arg = command.args.trim().toLowerCase();
 			if (arg === "status") {
-				await runtime.output(`Computer use is ${formatComputerUseStatus(runtime.session)}.`);
+				await runtime.output(formatComputerUseStatus(runtime.session));
 				return commandConsumed();
 			}
 			if (!arg || arg === "toggle" || arg === "on" || arg === "off") {
@@ -590,7 +632,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		handleTui: async (command, runtime) => {
 			const arg = command.args.trim().toLowerCase();
 			if (arg === "status") {
-				runtime.ctx.showStatus(`Computer use is ${formatComputerUseStatus(runtime.ctx.session)}.`);
+				runtime.ctx.showStatus(formatComputerUseStatus(runtime.ctx.session));
 				runtime.ctx.editor.setText("");
 				return;
 			}

package/src/stt/asr-worker.ts

@@ -35,6 +35,7 @@ import {
 	type SttModelKey,
 	type TransformersSttModelSpec,
 } from "./models";
+import { loadSourceSherpaRuntime, type SherpaOfflineRecognizer, type SherpaRuntime } from "./sherpa-runtime";
 
 const ASR_TASK = "automatic-speech-recognition";
 const SHERPA_PACKAGE = "sherpa-onnx-node";
@@ -50,7 +51,6 @@ const HF_RESOLVE_BASE = "https://huggingface.co";
 // Coalesce download progress so streaming a multi-hundred-MB model file doesn't
 // flood the IPC channel with one event per chunk.
 const PROGRESS_EMIT_BYTES = 4_000_000;
-const sourceRequire = createRequire(import.meta.url);
 
 const sttModelDevicePreference = resolveTinyModelDevicePreference();
 const sttModelDtypeOverride = resolveTinyModelDtypeOverride();
@@ -90,41 +90,6 @@ interface TransformersRuntime {
 	) => Promise<AutomaticSpeechRecognitionPipeline>;
 }
 
-/** Recognition result returned by `sherpa-onnx-node`'s offline recognizer. */
-interface SherpaOfflineResult {
-	text?: string;
-}
-
-/** A sherpa-onnx offline stream that accepts a single waveform before decoding. */
-interface SherpaOfflineStream {
-	acceptWaveform(audio: { samples: Float32Array; sampleRate: number }): void;
-}
-
-interface SherpaOfflineRecognizer {
-	createStream(): SherpaOfflineStream;
-	decodeAsync(stream: SherpaOfflineStream): Promise<SherpaOfflineResult>;
-}
-
-/** Offline recognizer config passed to `sherpa-onnx-node` (transducer family). */
-interface SherpaOfflineConfig {
-	modelConfig: {
-		transducer: { encoder: string; decoder: string; joiner: string };
-		tokens: string;
-		modelType: string;
-		numThreads: number;
-		provider: string;
-		debug: number;
-	};
-	decodingMethod: string;
-}
-
-/** Subset of the native `sherpa-onnx-node` module surface we use. */
-interface SherpaRuntime {
-	OfflineRecognizer: {
-		createAsync(config: SherpaOfflineConfig): Promise<SherpaOfflineRecognizer>;
-	};
-}
-
 /** A warm model plus the engine that loaded it; cached per tier key. */
 type LoadedModel =
 	| { engine: "transformers"; pipeline: AutomaticSpeechRecognitionPipeline }
@@ -182,7 +147,7 @@ function getSherpaRuntimeDir(): string {
  */
 function loadSherpaRuntime(transport: SttTransport, requestId: string, modelKey: SttModelKey): Promise<SherpaRuntime> {
 	return sherpaRuntime.load(async () => {
-		if (!isCompiledBinary()) return sourceRequire(SHERPA_PACKAGE) as SherpaRuntime;
+		if (!isCompiledBinary()) return loadSourceSherpaRuntime(import.meta.url);
 		const runtimeDir = await ensureRuntimeInstalled({
 			runtimeDir: getSherpaRuntimeDir(),
 			install: { dependencies: { [SHERPA_PACKAGE]: getSherpaVersionSpec() } },

package/src/stt/sherpa-runtime.ts

@@ -0,0 +1,71 @@
+import { createRequire } from "node:module";
+import * as os from "node:os";
+import { resolveRuntimeModule } from "@oh-my-pi/pi-utils";
+
+const SHERPA_PACKAGE = "sherpa-onnx-node";
+
+interface SherpaOfflineResult {
+	text?: string;
+}
+
+interface SherpaOfflineStream {
+	acceptWaveform(audio: { samples: Float32Array; sampleRate: number }): void;
+}
+
+interface SherpaOfflineConfig {
+	modelConfig: {
+		transducer: { encoder: string; decoder: string; joiner: string };
+		tokens: string;
+		modelType: string;
+		numThreads: number;
+		provider: string;
+		debug: number;
+	};
+	decodingMethod: string;
+}
+
+/** A sherpa-onnx recognizer instance used by the STT worker. */
+export interface SherpaOfflineRecognizer {
+	createStream(): SherpaOfflineStream;
+	decodeAsync(stream: SherpaOfflineStream): Promise<SherpaOfflineResult>;
+}
+
+/** The native sherpa-onnx module surface used by the STT worker. */
+export interface SherpaRuntime {
+	OfflineRecognizer: {
+		createAsync(config: SherpaOfflineConfig): Promise<SherpaOfflineRecognizer>;
+	};
+}
+
+/** Loads the nearest working source-workspace sherpa wrapper, including hoisted fallbacks. */
+export function loadSourceSherpaRuntime(sourceUrl: string): SherpaRuntime {
+	const sourceRequire = createRequire(sourceUrl);
+	const nearestEntry = sourceRequire.resolve(SHERPA_PACKAGE);
+	try {
+		return createRequire(nearestEntry)(nearestEntry);
+	} catch (error) {
+		if (!(error instanceof Error && error.message.startsWith("Could not find sherpa-onnx-node. Tried"))) {
+			throw error;
+		}
+		const platform = os.platform();
+		const platformPackage = `sherpa-onnx-${platform === "win32" ? "win" : platform}-${os.arch()}`;
+		for (const nodeModules of sourceRequire.resolve.paths(SHERPA_PACKAGE) ?? []) {
+			if (!resolveRuntimeModule(nodeModules, platformPackage)) continue;
+			const entry = resolveRuntimeModule(nodeModules, SHERPA_PACKAGE);
+			if (!entry || entry === nearestEntry) continue;
+			try {
+				return createRequire(entry)(entry);
+			} catch (candidateError) {
+				if (
+					!(
+						candidateError instanceof Error &&
+						candidateError.message.startsWith("Could not find sherpa-onnx-node. Tried")
+					)
+				) {
+					throw candidateError;
+				}
+			}
+		}
+		throw error;
+	}
+}

package/src/task/executor.ts

@@ -46,7 +46,7 @@ import type { AuthStorage } from "../session/auth-storage";
 import { SKILL_PROMPT_MESSAGE_TYPE, USER_INTERRUPT_LABEL } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
 import { truncateTail } from "../session/streaming-output";
-import { type ConfiguredThinkingLevel, resolveTaskEffortLevel, type TaskEffort } from "../thinking";
+import { type ConfiguredThinkingLevel, prewalkWouldBeNoop, resolveTaskEffortLevel, type TaskEffort } from "../thinking";
 import type { ContextFileEntry, ToolSession } from "../tools";
 import { resolveEvalBackends } from "../tools/eval-backends";
 import { isIrcEnabled } from "../tools/hub";
@@ -2683,10 +2683,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						pattern: prewalkPattern,
 						warning: resolvedPrewalk.warning,
 					});
-				} else if (model && target.provider === model.provider && target.id === model.id) {
-					// Switching to the starting model is a no-op that would still inject
-					// the plan/checklist nudges — skip.
-					logger.debug("Subagent prewalk target equals starting model; skipping prewalk", {
+				} else if (prewalkWouldBeNoop(model, effectiveThinkingLevel, target, resolvedPrewalk.thinkingLevel)) {
+					// Same model AND same effective thinking level: switching would only
+					// inject the plan/checklist nudges for no gain — skip. An effort-only
+					// delta on the same model still arms (it is a real cheapening hand-off).
+					logger.debug("Subagent prewalk target matches starting model and thinking level; skipping prewalk", {
 						agent: agent.name,
 						pattern: prewalkPattern,
 					});

package/src/thinking.ts

@@ -1,6 +1,7 @@
 import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { Effort, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { clampThinkingLevelForModel, getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 
 /**
  * Metadata used to render thinking selector values in the coding-agent UI.
@@ -142,6 +143,44 @@ export function concreteThinkingLevel(level: ConfiguredThinkingLevel | undefined
 	return level === AUTO_THINKING ? undefined : level;
 }
 
+/**
+ * True when a prewalk hand-off from `current`/`currentLevel` to
+ * `target`/`targetLevel` would change nothing observable: same model id, same
+ * auto/fixed mode, and the same model-clamped effective effort. Prewalk arms and
+ * switches only when this is false.
+ *
+ * An effort-only delta on the same model id is a legitimate cheapening hand-off
+ * — on a reasoning model the effort is the bulk of the cost — so it is NOT a
+ * no-op and must still switch. A `targetLevel` of `undefined` means the prewalk
+ * pattern carried no explicit `:level` suffix (no effort change requested),
+ * which on the same model is a no-op.
+ *
+ * `auto` mode is compared before efforts: `auto` and a fixed selector that both
+ * resolve to `undefined` effort (e.g. `:inherit`) are NOT interchangeable —
+ * applying the fixed selector clears per-turn classification, so switching
+ * auto↔fixed is always a real change even when the clamped efforts match.
+ *
+ * Efforts are otherwise compared AFTER model clamping, so a target the model
+ * cannot honor (e.g. `:xhigh` on a model capped at `high`) — which
+ * `setThinkingLevel` would clamp straight back to the active effort — is
+ * recognized as a no-op instead of triggering an ephemeral reset and the
+ * plan/checklist nudges for nothing.
+ */
+export function prewalkWouldBeNoop(
+	current: Model | undefined,
+	currentLevel: ConfiguredThinkingLevel | undefined,
+	target: Model,
+	targetLevel: ConfiguredThinkingLevel | undefined,
+): boolean {
+	if (!modelsAreEqual(current, target)) return false;
+	if (targetLevel === undefined) return true;
+	if ((targetLevel === AUTO_THINKING) !== (currentLevel === AUTO_THINKING)) return false;
+	return (
+		resolveThinkingLevelForModel(target, concreteThinkingLevel(targetLevel)) ===
+		resolveThinkingLevelForModel(target, concreteThinkingLevel(currentLevel))
+	);
+}
+
 /** Metadata used to render the `auto` selector value alongside concrete levels. */
 export interface ConfiguredThinkingLevelMetadata {
 	value: ConfiguredThinkingLevel;

package/src/tools/auto-generated-guard.ts

@@ -7,7 +7,8 @@
 import * as path from "node:path";
 import { isEnoent, peekFile } from "@oh-my-pi/pi-utils";
 import { LRUCache } from "lru-cache/raw";
-import { settings } from "../config/settings";
+import { settings as globalSettings, isSettingsInitialized, type Settings } from "../config/settings";
+import { getDefault } from "../config/settings-schema";
 import { ToolError } from "./tool-errors";
 
 /**
@@ -283,15 +284,26 @@ async function getAutoGeneratedMarker(filePath: string): Promise<string | undefi
 	return marker;
 }
 
+function shouldBlockAutoGeneratedFiles(activeSettings?: Settings): boolean {
+	if (activeSettings) return activeSettings.get("edit.blockAutoGenerated");
+	if (isSettingsInitialized()) return globalSettings.get("edit.blockAutoGenerated");
+	return getDefault("edit.blockAutoGenerated");
+}
+
 /**
  * Check if a file is auto-generated by examining its content.
  * Throws ToolError if the file appears to be auto-generated.
  *
  * @param absolutePath - Absolute path to the file
  * @param displayPath - Path to show in error messages (relative or as provided)
+ * @param activeSettings - Session settings; falls back to global settings or the schema default
  */
-export async function assertEditableFile(absolutePath: string, displayPath?: string) {
-	if (!settings.get("edit.blockAutoGenerated")) {
+export async function assertEditableFile(
+	absolutePath: string,
+	displayPath?: string,
+	activeSettings?: Settings,
+): Promise<void> {
+	if (!shouldBlockAutoGeneratedFiles(activeSettings)) {
 		return;
 	}
 	const pathForDisplay = displayPath ?? absolutePath;
@@ -308,9 +320,10 @@ export async function assertEditableFile(absolutePath: string, displayPath?: str
  *
  * @param content - File content to check (can be full content or prefix)
  * @param displayPath - Path to show in error messages
+ * @param activeSettings - Session settings; falls back to global settings or the schema default
  */
-export function assertEditableFileContent(content: string, displayPath: string): void {
-	if (!settings.get("edit.blockAutoGenerated")) {
+export function assertEditableFileContent(content: string, displayPath: string, activeSettings?: Settings): void {
+	if (!shouldBlockAutoGeneratedFiles(activeSettings)) {
 		return;
 	}
 

package/src/tools/bash.ts

@@ -48,6 +48,7 @@ import {
 	previewWindowRows,
 	replaceTabs,
 } from "./render-utils";
+import { tokenizeShellSegments } from "./shell-tokenize";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout, TOOL_TIMEOUTS } from "./tool-timeouts";
@@ -71,12 +72,13 @@ const BASH_PATTERN_APPROVAL_VALUES = new Set(["allow", "deny", "prompt"]);
  * containing a space, pipe, `&&`, redirect, or `$(...)`.
  *
  * The wrap reuses the same shell binary + args the local `bash-executor` would
- * pick via `settings.getShellConfig()` — Git Bash / `bash.exe` on Windows,
+ * pick via `settings.getShellConfig()` — Git Bash / `bash.exe` on Windows
+ * (`cmd.exe /c` as the last-resort fallback when no bash exists on the host),
  * `$SHELL` (bash/zsh) with the `sh` fallback on POSIX — so the ACP path
  * preserves `bash` tool semantics (`$VAR`, `$(...)`, `source`, POSIX quoting,
- * `-l`) instead of dropping to `cmd.exe` on Windows. The agent host's shell
- * path is used as a proxy for the client's, matching the near-universal
- * ACP deployment shape of an editor spawning omp as a co-hosted subprocess.
+ * `-l`) wherever a POSIX shell is available. The agent host's shell path is
+ * used as a proxy for the client's, matching the near-universal ACP
+ * deployment shape of an editor spawning omp as a co-hosted subprocess.
  */
 export function wrapShellLineForClientTerminal(
 	line: string,
@@ -189,16 +191,43 @@ function commandMatchesBashApprovalPattern(command: string, pattern: string): bo
 	return bashApprovalPatternToRegExp(pattern).test(normalizedCommand);
 }
 
+// `deny`/`prompt` rules are matched per segment so a dangerous command buried in
+// a compound line (`cd x && rm -rf /`, `sleep 1 & rm -rf /`) is still caught.
+// Reuse the shared shell tokenizer so segmentation stays in one place and honors
+// every command boundary (`;`, `&&`, `||`, `|`, `&`, subshells, newlines).
+function bashCommandSegments(command: string): string[] {
+	return tokenizeShellSegments(command)
+		.map(segment => segment.join(" "))
+		.filter(segment => segment.length > 0);
+}
+
+// `deny`/`prompt` matching: the rule fires when its glob matches the whole
+// command or any single segment of a compound command.
+function commandSegmentMatchesBashApprovalPattern(command: string, pattern: string): boolean {
+	const regex = bashApprovalPatternToRegExp(pattern);
+	const normalizedCommand = normalizeBashApprovalPattern(command);
+	if (normalizedCommand.length === 0) return false;
+	if (regex.test(normalizedCommand)) return true;
+	return bashCommandSegments(command).some(segment => regex.test(segment));
+}
+
+// A rule "applies" to a command under approval-specific semantics: `allow` must
+// vouch for the ENTIRE command and never rides a compound line (shell control
+// syntax could smuggle an unsafe segment past a narrow allow), while `deny` and
+// `prompt` fire on any matching segment so they mean what they appear to.
+function bashApprovalRuleMatches(command: string, rule: BashApprovalPatternRule): boolean {
+	if (rule.approval === "allow") {
+		if (BASH_APPROVAL_SHELL_CONTROL_RE.test(command)) return false;
+		return commandMatchesBashApprovalPattern(command, rule.match);
+	}
+	return commandSegmentMatchesBashApprovalPattern(command, rule.match);
+}
+
 function findBashApprovalPatternRule(
 	command: string,
 	rules: readonly BashApprovalPatternRule[],
 ): BashApprovalPatternRule | undefined {
-	return rules.find(rule => {
-		if (rule.approval === "allow" && BASH_APPROVAL_SHELL_CONTROL_RE.test(command)) {
-			return false;
-		}
-		return commandMatchesBashApprovalPattern(command, rule.match);
-	});
+	return rules.find(rule => bashApprovalRuleMatches(command, rule));
 }
 
 async function saveBashOriginalArtifact(session: ToolSession, originalText: string): Promise<string | undefined> {
@@ -459,7 +488,7 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		const rawCommand = (args as Partial<BashToolInput>).command;
 		const command = typeof rawCommand === "string" ? rawCommand : "";
 		const patternRules = getBashApprovalPatternRules(this.session.settings.get("bash.patterns"));
-		const patternRule = patternRules.find(rule => commandMatchesBashApprovalPattern(command, rule.match));
+		const patternRule = findBashApprovalPatternRule(command, patternRules);
 		if (patternRule?.approval === "deny") {
 			return {
 				tier: "exec",
@@ -471,14 +500,13 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		if (command !== "" && CRITICAL_BASH_PATTERNS.some(pattern => pattern.test(command))) {
 			return { tier: "exec", override: true, reason: "Critical pattern detected" };
 		}
-		const safePatternRule = findBashApprovalPatternRule(command, patternRules);
-		if (safePatternRule?.approval === "allow") return { tier: "write", policy: "allow" };
-		if (safePatternRule?.approval === "prompt") {
+		if (patternRule?.approval === "allow") return { tier: "write", policy: "allow" };
+		if (patternRule?.approval === "prompt") {
 			return {
 				tier: "exec",
 				override: true,
 				policy: "prompt",
-				reason: `Prompt required by bash pattern: ${safePatternRule.match}`,
+				reason: `Prompt required by bash pattern: ${patternRule.match}`,
 			};
 		}
 		return "exec";

package/src/tools/computer/exposure.ts

@@ -0,0 +1,38 @@
+import type { Model } from "@oh-my-pi/pi-ai";
+
+export type ComputerExposureMode = "native" | "function" | "unavailable";
+
+export interface ComputerExposureOptions {
+	azureBaseUrl?: string;
+	azureResourceName?: string;
+}
+
+function isFirstPartyAzureEndpoint(baseUrl: string): boolean {
+	try {
+		const url = new URL(baseUrl);
+		return (
+			url.protocol === "https:" &&
+			(url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")
+		);
+	} catch {
+		return false;
+	}
+}
+
+/** Match the provider transport's effective Computer Use tool representation. */
+export function computerExposureMode(
+	model: Model | undefined,
+	options?: ComputerExposureOptions,
+): ComputerExposureMode {
+	if (!model) return "unavailable";
+	if (model.supportsComputerUse !== true) return "function";
+	if (model.api !== "azure-openai-responses" || model.supportsComputerUseConfig !== undefined) return "native";
+	const baseUrl =
+		options?.azureBaseUrl?.trim() ||
+		process.env.AZURE_OPENAI_BASE_URL?.trim() ||
+		(options?.azureResourceName || process.env.AZURE_OPENAI_RESOURCE_NAME
+			? `https://${options?.azureResourceName || process.env.AZURE_OPENAI_RESOURCE_NAME}.openai.azure.com/openai/v1`
+			: undefined) ||
+		model.baseUrl;
+	return baseUrl && isFirstPartyAzureEndpoint(baseUrl) ? "native" : "function";
+}

package/src/tools/computer/supervisor.ts

@@ -1,5 +1,7 @@
 import type { DesktopAction, DesktopCapabilities, DesktopCapture, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
-import { withTimeout, workerHostEntry } from "@oh-my-pi/pi-utils";
+import { withTimeout } from "@oh-my-pi/pi-utils/async";
+import * as logger from "@oh-my-pi/pi-utils/logger";
+import { workerHostEntry } from "@oh-my-pi/pi-utils/worker-host";
 import { ToolAbortError, ToolError } from "../tool-errors";
 import {
 	COMPUTER_WORKER_ARG,
@@ -138,11 +140,23 @@ export class ComputerSupervisor implements ComputerController {
 		if (this.#startPromise) return this.#startPromise;
 		const ready = Promise.withResolvers<void>();
 		try {
+			logger.debug("Starting native computer worker", {
+				backend: this.options.backend,
+				display: this.options.display,
+				maxWidth: this.options.maxWidth,
+				maxHeight: this.options.maxHeight,
+			});
 			const worker = this.createWorker();
 			this.#worker = worker;
 			this.#unsubscribeMessage = worker.onMessage(message => {
 				if (message.type === "ready") {
 					this.#capabilities = message.capabilities;
+					logger.debug("Native computer worker ready", {
+						backend: message.capabilities.backend,
+						capturePermission: message.capabilities.capturePermission,
+						inputPermission: message.capabilities.inputPermission,
+						displayCount: message.capabilities.displayCount,
+					});
 					ready.resolve();
 					return;
 				}
@@ -151,10 +165,22 @@ export class ComputerSupervisor implements ComputerController {
 					const pending = this.#pending.get(message.id);
 					this.#pending.delete(message.id);
 					pending?.resolve(message.capture);
+					logger.debug("Native computer capture completed", {
+						requestId: message.id,
+						backend: message.capture.backend,
+						capturePermission: message.capture.capturePermission,
+						inputPermission: message.capture.inputPermission,
+						width: message.capture.width,
+						height: message.capture.height,
+					});
 					return;
 				}
 				if (message.type === "error") {
 					const error = workerError(message.error);
+					logger.warn("Native computer worker request failed", {
+						requestId: message.id,
+						errorName: message.error.name,
+					});
 					if (message.id) {
 						const pending = this.#pending.get(message.id);
 						this.#pending.delete(message.id);
@@ -184,6 +210,9 @@ export class ComputerSupervisor implements ComputerController {
 	}
 
 	async #terminate(reason: unknown): Promise<void> {
+		logger.debug("Terminating native computer worker", {
+			reason: reason instanceof Error ? reason.name : typeof reason,
+		});
 		const worker = this.#worker;
 		this.#worker = undefined;
 		this.#startPromise = undefined;
@@ -239,20 +268,39 @@ export async function releaseComputerSessionsForOwner(ownerId: string | undefine
 	await Promise.allSettled(Array.from(controllers, controller => controller.close()));
 }
 
-export async function smokeTestComputerWorker(timeoutMs = SMOKE_TIMEOUT_MS): Promise<void> {
-	const worker = spawnComputerWorker();
-	const id = "computer-smoke";
-	const pong = Promise.withResolvers<void>();
-	const unsubscribeMessage = worker.onMessage(message => {
-		if (message.type === "pong" && message.id === id) pong.resolve();
-	});
-	const unsubscribeError = worker.onError(error => pong.reject(error));
+export async function smokeTestComputerWorker(
+	timeoutMs = SMOKE_TIMEOUT_MS,
+	createWorker: ComputerWorkerFactory = spawnComputerWorker,
+): Promise<void> {
+	const worker = createWorker();
+	const exchange = async (
+		message: ComputerWorkerInbound,
+		expected: ComputerWorkerOutbound["type"],
+		failureMessage: string,
+	): Promise<void> => {
+		const response = Promise.withResolvers<void>();
+		const unsubscribeMessage = worker.onMessage(received => {
+			if (received.type === expected) response.resolve();
+			else if (received.type === "error") response.reject(workerError(received.error));
+		});
+		const unsubscribeError = worker.onError(error => response.reject(error));
+		try {
+			worker.send(message);
+			await withTimeout(response.promise, timeoutMs, failureMessage);
+		} finally {
+			unsubscribeMessage();
+			unsubscribeError();
+		}
+	};
+
 	try {
-		worker.send({ type: "ping", id });
-		await withTimeout(pong.promise, timeoutMs, "Computer worker smoke ping timed out");
+		await exchange(
+			{ type: "init", options: { backend: "auto", display: "all", maxWidth: 1920, maxHeight: 1200 } },
+			"ready",
+			"Computer worker smoke initialization timed out",
+		);
+		await exchange({ type: "close" }, "closed", "Computer worker smoke close timed out");
 	} finally {
-		unsubscribeMessage();
-		unsubscribeError();
 		await worker.terminate();
 	}
 }