@oh-my-pi/pi-coding-agent 16.1.5 → 16.1.7

package/dist/types/config/models-config-schema.d.ts

@@ -44,6 +44,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
     supportsReasoningParams?: boolean | undefined;
     alwaysSendMaxTokens?: boolean | undefined;
     strictResponsesPairing?: boolean | undefined;
+    supportsImageDetailOriginal?: boolean | undefined;
     requiresToolResultId?: boolean | undefined;
     replayUnsignedThinking?: boolean | undefined;
     whenThinking?: {
@@ -92,6 +93,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
         supportsReasoningParams?: boolean | undefined;
         alwaysSendMaxTokens?: boolean | undefined;
         strictResponsesPairing?: boolean | undefined;
+        supportsImageDetailOriginal?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
     } | undefined;
@@ -182,6 +184,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
         supportsReasoningParams?: boolean | undefined;
         alwaysSendMaxTokens?: boolean | undefined;
         strictResponsesPairing?: boolean | undefined;
+        supportsImageDetailOriginal?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
         whenThinking?: {
@@ -230,6 +233,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
             supportsReasoningParams?: boolean | undefined;
             alwaysSendMaxTokens?: boolean | undefined;
             strictResponsesPairing?: boolean | undefined;
+            supportsImageDetailOriginal?: boolean | undefined;
             requiresToolResultId?: boolean | undefined;
             replayUnsignedThinking?: boolean | undefined;
         } | undefined;
@@ -298,6 +302,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                 supportsReasoningParams?: boolean | undefined;
                 alwaysSendMaxTokens?: boolean | undefined;
                 strictResponsesPairing?: boolean | undefined;
+                supportsImageDetailOriginal?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -346,6 +351,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     supportsReasoningParams?: boolean | undefined;
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
+                    supportsImageDetailOriginal?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -444,6 +450,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     supportsReasoningParams?: boolean | undefined;
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
+                    supportsImageDetailOriginal?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -492,6 +499,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         supportsReasoningParams?: boolean | undefined;
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
+                        supportsImageDetailOriginal?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -585,6 +593,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         supportsReasoningParams?: boolean | undefined;
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
+                        supportsImageDetailOriginal?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -633,6 +642,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                             supportsReasoningParams?: boolean | undefined;
                             alwaysSendMaxTokens?: boolean | undefined;
                             strictResponsesPairing?: boolean | undefined;
+                            supportsImageDetailOriginal?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

package/dist/types/config/models-config.d.ts

@@ -81,6 +81,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                 supportsReasoningParams?: boolean | undefined;
                 alwaysSendMaxTokens?: boolean | undefined;
                 strictResponsesPairing?: boolean | undefined;
+                supportsImageDetailOriginal?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -129,6 +130,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     supportsReasoningParams?: boolean | undefined;
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
+                    supportsImageDetailOriginal?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -212,6 +214,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     supportsReasoningParams?: boolean | undefined;
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
+                    supportsImageDetailOriginal?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -260,6 +263,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         supportsReasoningParams?: boolean | undefined;
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
+                        supportsImageDetailOriginal?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -338,6 +342,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         supportsReasoningParams?: boolean | undefined;
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
+                        supportsImageDetailOriginal?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -386,6 +391,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                             supportsReasoningParams?: boolean | undefined;
                             alwaysSendMaxTokens?: boolean | undefined;
                             strictResponsesPairing?: boolean | undefined;
+                            supportsImageDetailOriginal?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

package/dist/types/modes/interactive-mode.d.ts

@@ -177,7 +177,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
      * user submits becomes the new loop prompt and resumes iteration.
      */
     pauseLoop(): void;
-    handleLoopCommand(args?: string): Promise<void>;
+    handleLoopCommand(args?: string): Promise<string | undefined>;
     recordLocalSubmission(text: string, imageCount?: number): () => void;
     withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: {
         imageCount?: number;

package/dist/types/modes/loop-limit.d.ts

@@ -14,7 +14,20 @@ export type LoopLimitRuntime = {
     durationMs: number;
     deadlineMs: number;
 };
-export declare function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string;
+export interface ParsedLoopArgs {
+    /** Iteration/duration budget, when the user supplied a leading limit token. */
+    limit?: LoopLimitConfig;
+    /** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+    prompt?: string;
+}
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export declare function parseLoopLimitArgs(args: string): ParsedLoopArgs | string;
 export declare function createLoopLimitRuntime(config: LoopLimitConfig | undefined, nowMs?: number): LoopLimitRuntime | undefined;
 export declare function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
 export declare function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;

package/dist/types/modes/types.d.ts

@@ -339,7 +339,7 @@ export interface InteractiveModeContext {
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
     handleGuidedGoalCommand(rest?: string): Promise<void>;
-    handleLoopCommand(args?: string): Promise<void>;
+    handleLoopCommand(args?: string): Promise<string | undefined>;
     disableLoopMode(): void;
     pauseLoop(): void;
     handlePlanApproval(details: PlanApprovalDetails): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.5",
+	"version": "16.1.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.5",
-		"@oh-my-pi/omp-stats": "16.1.5",
-		"@oh-my-pi/pi-agent-core": "16.1.5",
-		"@oh-my-pi/pi-ai": "16.1.5",
-		"@oh-my-pi/pi-catalog": "16.1.5",
-		"@oh-my-pi/pi-mnemopi": "16.1.5",
-		"@oh-my-pi/pi-natives": "16.1.5",
-		"@oh-my-pi/pi-tui": "16.1.5",
-		"@oh-my-pi/pi-utils": "16.1.5",
-		"@oh-my-pi/pi-wire": "16.1.5",
-		"@oh-my-pi/snapcompact": "16.1.5",
+		"@oh-my-pi/hashline": "16.1.7",
+		"@oh-my-pi/omp-stats": "16.1.7",
+		"@oh-my-pi/pi-agent-core": "16.1.7",
+		"@oh-my-pi/pi-ai": "16.1.7",
+		"@oh-my-pi/pi-catalog": "16.1.7",
+		"@oh-my-pi/pi-mnemopi": "16.1.7",
+		"@oh-my-pi/pi-natives": "16.1.7",
+		"@oh-my-pi/pi-tui": "16.1.7",
+		"@oh-my-pi/pi-utils": "16.1.7",
+		"@oh-my-pi/pi-wire": "16.1.7",
+		"@oh-my-pi/snapcompact": "16.1.7",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/config/models-config-schema.ts

@@ -57,6 +57,7 @@ const OpenAICompatFields = {
 	"supportsReasoningParams?": "boolean",
 	"alwaysSendMaxTokens?": "boolean",
 	"strictResponsesPairing?": "boolean",
+	"supportsImageDetailOriginal?": "boolean",
 	// anthropic-messages compat flags (same `compat` slot, per-api interpretation)
 	"requiresToolResultId?": "boolean",
 	"replayUnsignedThinking?": "boolean",

package/src/modes/interactive-mode.ts

@@ -1128,27 +1128,33 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#cancelLoopAutoSubmit();
 	}
 
-	async handleLoopCommand(args = ""): Promise<void> {
+	async handleLoopCommand(args = ""): Promise<string | undefined> {
 		if (this.loopModeEnabled) {
 			this.disableLoopMode();
-			return;
+			return undefined;
 		}
-		const parsedLimit = parseLoopLimitArgs(args);
-		if (typeof parsedLimit === "string") {
-			this.showError(parsedLimit);
-			return;
+		const parsed = parseLoopLimitArgs(args);
+		if (typeof parsed === "string") {
+			this.showError(parsed);
+			return undefined;
 		}
 		this.loopModeEnabled = true;
 		this.loopPrompt = undefined;
-		this.loopLimit = createLoopLimitRuntime(parsedLimit);
+		this.loopLimit = createLoopLimitRuntime(parsed.limit);
 		this.statusLine.setLoopModeStatus({ enabled: true });
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
-		const limitSuffix = parsedLimit ? ` Limited to ${describeLoopLimit(parsedLimit)}.` : "";
+		const limitSuffix = parsed.limit ? ` Limited to ${describeLoopLimit(parsed.limit)}.` : "";
 		const remainingSuffix = this.loopLimit ? ` ${describeLoopLimitRuntime(this.loopLimit)}.` : "";
+		const tail = parsed.prompt ? "Repeating it after each turn." : "Your next prompt will repeat after each turn.";
 		this.showStatus(
-			`Loop mode enabled.${limitSuffix}${remainingSuffix} Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.`,
+			`Loop mode enabled.${limitSuffix}${remainingSuffix} ${tail} Esc cancels the current iteration; /loop again to disable.`,
 		);
+		// Hand any inline prompt back to the dispatcher so the normal submit flow
+		// runs the first iteration — it records the text as the loop prompt and
+		// auto-resubmits it after each yield, identical to typing the prompt right
+		// after enabling loop mode.
+		return parsed.prompt;
 	}
 
 	recordLocalSubmission(text: string, imageCount = 0): () => void {

package/src/modes/loop-limit.ts

@@ -38,53 +38,105 @@ const TIME_UNITS_MS = new Map<string, number>([
 	["hours", 3_600_000],
 ]);
 
-export function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string {
-	const trimmed = args.trim().toLowerCase();
-	if (!trimmed) return undefined;
+const LOOP_USAGE = "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
 
-	const parts = trimmed.split(/\s+/);
-	if (parts.length > 2) {
-		return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
-	}
+export interface ParsedLoopArgs {
+	/** Iteration/duration budget, when the user supplied a leading limit token. */
+	limit?: LoopLimitConfig;
+	/** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+	prompt?: string;
+}
 
-	if (parts.length === 2) {
-		return parseDurationParts(parts[0], parts[1]);
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export function parseLoopLimitArgs(args: string): ParsedLoopArgs | string {
+	const trimmed = args.trim();
+	if (!trimmed) return {};
+
+	const firstSpace = trimmed.search(/\s/);
+	const firstToken = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+	const rest = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
+	const token = firstToken.toLowerCase();
+
+	// Not a limit attempt (prose like "keep going") → unbounded loop, prompt = full args.
+	if (!/^[+-]?\d/.test(token)) {
+		return { prompt: trimmed };
 	}
 
-	const token = parts[0];
-	const iterationMatch = /^(\d+)$/.exec(token);
-	if (iterationMatch) {
-		const iterations = Number(iterationMatch[1]);
-		if (!Number.isSafeInteger(iterations) || iterations <= 0) {
-			return "Loop count must be a positive integer.";
+	// Bare integer: iteration count, unless the next token is a time unit ("10 minutes").
+	if (/^\d+$/.test(token)) {
+		if (rest) {
+			const restTokens = rest.split(/\s+/);
+			const unitMs = TIME_UNITS_MS.get(restTokens[0].toLowerCase());
+			if (unitMs !== undefined) {
+				const limit = makeDuration(token, unitMs);
+				if (typeof limit === "string") return limit;
+				return { limit, prompt: restTokens.slice(1).join(" ").trim() || undefined };
+			}
 		}
-		return { kind: "iterations", iterations };
+		const limit = makeIterations(token);
+		if (typeof limit === "string") return limit;
+		return { limit, prompt: rest || undefined };
 	}
 
-	const durationMatch = /^(\d+)([a-z]+)$/.exec(token);
-	if (durationMatch) {
-		return parseDurationParts(durationMatch[1], durationMatch[2]);
+	// Compact / compound duration: "10m", "90s", "1h30m".
+	const duration = parseCompoundDuration(token);
+	if (duration !== undefined) {
+		if (typeof duration === "string") return duration;
+		return { limit: duration, prompt: rest || undefined };
 	}
 
-	return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+	// Limit-shaped but unparseable ("-1", "1.5h", "10x10").
+	return LOOP_USAGE;
 }
 
-function parseDurationParts(amountText: string, unitText: string): LoopLimitConfig | string {
-	if (!/^\d+$/.test(amountText)) {
-		return "Loop duration must use a positive integer amount.";
+function makeIterations(amountText: string): LoopLimitConfig | string {
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop count must be a positive integer.";
 	}
+	return { kind: "iterations", iterations: amount };
+}
 
+function makeDuration(amountText: string, unitMs: number): LoopLimitConfig | string {
 	const amount = Number(amountText);
 	if (!Number.isSafeInteger(amount) || amount <= 0) {
 		return "Loop duration must be positive.";
 	}
+	return { kind: "duration", durationMs: amount * unitMs };
+}
 
-	const unitMs = TIME_UNITS_MS.get(unitText);
-	if (unitMs === undefined) {
-		return "Loop duration unit must be seconds, minutes, or hours.";
+/**
+ * Parse a compact duration token such as `10m`, or a compound one like `1h30m`.
+ * Returns `undefined` when the token is not duration-shaped, or an error string
+ * when it is shaped like a duration but uses an unknown unit / non-positive
+ * amount.
+ */
+function parseCompoundDuration(token: string): LoopLimitConfig | string | undefined {
+	if (!/^(?:\d+[a-z]+)+$/.test(token)) return undefined;
+	const segments = token.match(/\d+[a-z]+/g);
+	if (!segments) return undefined;
+	let totalMs = 0;
+	for (const segment of segments) {
+		const match = /^(\d+)([a-z]+)$/.exec(segment);
+		if (!match) return LOOP_USAGE;
+		const unitMs = TIME_UNITS_MS.get(match[2]);
+		if (unitMs === undefined) {
+			return "Loop duration unit must be seconds, minutes, or hours.";
+		}
+		const amount = Number(match[1]);
+		if (!Number.isSafeInteger(amount) || amount <= 0) {
+			return "Loop duration must be positive.";
+		}
+		totalMs += amount * unitMs;
 	}
-
-	return { kind: "duration", durationMs: amount * unitMs };
+	if (totalMs <= 0) return "Loop duration must be positive.";
+	return { kind: "duration", durationMs: totalMs };
 }
 
 export function createLoopLimitRuntime(

package/src/modes/types.ts

@@ -362,7 +362,7 @@ export interface InteractiveModeContext {
 	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
 	handleGoalModeCommand(rest?: string): Promise<void>;
 	handleGuidedGoalCommand(rest?: string): Promise<void>;
-	handleLoopCommand(args?: string): Promise<void>;
+	handleLoopCommand(args?: string): Promise<string | undefined>;
 	disableLoopMode(): void;
 	pauseLoop(): void;
 	handlePlanApproval(details: PlanApprovalDetails): Promise<void>;