@oh-my-pi/pi-coding-agent 3.25.0 → 3.30.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [3.30.0] - 2026-01-07
+### Added
+
+- Added environment variable configuration for task limits: `OMP_TASK_MAX_PARALLEL`, `OMP_TASK_MAX_CONCURRENCY`, `OMP_TASK_MAX_OUTPUT_BYTES`, `OMP_TASK_MAX_OUTPUT_LINES`, and `OMP_TASK_MAX_AGENTS_IN_DESCRIPTION`
+- Added specialized web-fetch handlers for 50+ platforms including GitHub, GitLab, npm, PyPI, crates.io, Stack Overflow, Wikipedia, arXiv, PubMed, Hacker News, Reddit, Mastodon, Bluesky, and many more
+- Added automatic yt-dlp installation for YouTube transcript extraction
+- Added YouTube video support with automatic transcript extraction via yt-dlp
+
+### Changed
+
+- Changed task executor to gracefully handle worker termination with proper cleanup and timeout handling
+
+### Fixed
+
+- Fixed Lobsters front page handler to use correct API endpoint (`/hottest.json` instead of invalid `.json`)
+- Fixed task worker error handling to prevent hanging on worker crashes, uncaught errors, and unhandled rejections
+- Fixed double-stringified JSON output from subagents being returned as escaped strings instead of parsed objects
+- Fixed markitdown tool installation to use automatic tool installer instead of requiring manual installation
+
 ## [3.25.0] - 2026-01-07
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.25.0",
+	"version": "3.30.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,9 +40,9 @@
 	},
 	"dependencies": {
 		"@mariozechner/pi-ai": "^0.37.4",
-		"@oh-my-pi/pi-agent-core": "3.25.0",
-		"@oh-my-pi/pi-git-tool": "3.25.0",
-		"@oh-my-pi/pi-tui": "3.25.0",
+		"@oh-my-pi/pi-agent-core": "3.30.0",
+		"@oh-my-pi/pi-git-tool": "3.30.0",
+		"@oh-my-pi/pi-tui": "3.30.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/tools/complete.ts

@@ -74,7 +74,7 @@ export function createCompleteTool(session: ToolSession) {
 	const dataSchema = normalizedSchema
 		? Type.Unsafe({
 				...(normalizedSchema as object),
-				description: "Structured output matching the schema:\n" + schemaHint,
+				description: `Structured output matching the schema:\n${schemaHint}`,
 			})
 		: Type.Any({ description: "Structured JSON output (no schema specified)" });
 
@@ -110,9 +110,7 @@ export function createCompleteTool(session: ToolSession) {
 			}
 
 			const responseText =
-				status === "aborted"
-					? `Task aborted: ${params.error || "No reason provided"}`
-					: "Completion recorded.";
+				status === "aborted" ? `Task aborted: ${params.error || "No reason provided"}` : "Completion recorded.";
 
 			return {
 				content: [{ type: "text", text: responseText }],

package/src/core/tools/jtd-to-json-schema.ts

@@ -9,211 +9,199 @@
  */
 
 type JTDPrimitive =
-   | "boolean"
-   | "string"
-   | "timestamp"
-   | "float32"
-   | "float64"
-   | "int8"
-   | "uint8"
-   | "int16"
-   | "uint16"
-   | "int32"
-   | "uint32";
+	| "boolean"
+	| "string"
+	| "timestamp"
+	| "float32"
+	| "float64"
+	| "int8"
+	| "uint8"
+	| "int16"
+	| "uint16"
+	| "int32"
+	| "uint32";
 
 interface JTDType {
-   type: JTDPrimitive;
+	type: JTDPrimitive;
 }
 
 interface JTDEnum {
-   enum: string[];
+	enum: string[];
 }
 
 interface JTDElements {
-   elements: JTDSchema;
+	elements: JTDSchema;
 }
 
 interface JTDValues {
-   values: JTDSchema;
+	values: JTDSchema;
 }
 
 interface JTDProperties {
-   properties?: Record<string, JTDSchema>;
-   optionalProperties?: Record<string, JTDSchema>;
+	properties?: Record<string, JTDSchema>;
+	optionalProperties?: Record<string, JTDSchema>;
 }
 
 interface JTDDiscriminator {
-   discriminator: string;
-   mapping: Record<string, JTDProperties>;
+	discriminator: string;
+	mapping: Record<string, JTDProperties>;
 }
 
 interface JTDRef {
-   ref: string;
+	ref: string;
 }
 
 interface JTDEmpty {}
 
-type JTDSchema =
-   | JTDType
-   | JTDEnum
-   | JTDElements
-   | JTDValues
-   | JTDProperties
-   | JTDDiscriminator
-   | JTDRef
-   | JTDEmpty;
+type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | JTDEmpty;
 
 const primitiveMap: Record<JTDPrimitive, string> = {
-   boolean: "boolean",
-   string: "string",
-   timestamp: "string", // ISO 8601
-   float32: "number",
-   float64: "number",
-   int8: "integer",
-   uint8: "integer",
-   int16: "integer",
-   uint16: "integer",
-   int32: "integer",
-   uint32: "integer",
+	boolean: "boolean",
+	string: "string",
+	timestamp: "string", // ISO 8601
+	float32: "number",
+	float64: "number",
+	int8: "integer",
+	uint8: "integer",
+	int16: "integer",
+	uint16: "integer",
+	int32: "integer",
+	uint32: "integer",
 };
 
 function isJTDType(schema: unknown): schema is JTDType {
-   return typeof schema === "object" && schema !== null && "type" in schema;
+	return typeof schema === "object" && schema !== null && "type" in schema;
 }
 
 function isJTDEnum(schema: unknown): schema is JTDEnum {
-   return typeof schema === "object" && schema !== null && "enum" in schema;
+	return typeof schema === "object" && schema !== null && "enum" in schema;
 }
 
 function isJTDElements(schema: unknown): schema is JTDElements {
-   return typeof schema === "object" && schema !== null && "elements" in schema;
+	return typeof schema === "object" && schema !== null && "elements" in schema;
 }
 
 function isJTDValues(schema: unknown): schema is JTDValues {
-   return typeof schema === "object" && schema !== null && "values" in schema;
+	return typeof schema === "object" && schema !== null && "values" in schema;
 }
 
 function isJTDProperties(schema: unknown): schema is JTDProperties {
-   return (
-      typeof schema === "object" &&
-      schema !== null &&
-      ("properties" in schema || "optionalProperties" in schema)
-   );
+	return typeof schema === "object" && schema !== null && ("properties" in schema || "optionalProperties" in schema);
 }
 
 function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator {
-   return typeof schema === "object" && schema !== null && "discriminator" in schema;
+	return typeof schema === "object" && schema !== null && "discriminator" in schema;
 }
 
 function isJTDRef(schema: unknown): schema is JTDRef {
-   return typeof schema === "object" && schema !== null && "ref" in schema;
+	return typeof schema === "object" && schema !== null && "ref" in schema;
 }
 
 function convertSchema(schema: unknown): unknown {
-   if (schema === null || typeof schema !== "object") {
-      return {};
-   }
-
-   // Type form: { type: "string" } → { type: "string" }
-   if (isJTDType(schema)) {
-      const jsonType = primitiveMap[schema.type as JTDPrimitive];
-      if (!jsonType) {
-         return { type: schema.type };
-      }
-      const result: Record<string, unknown> = { type: jsonType };
-      // Add format for timestamp
-      if (schema.type === "timestamp") {
-         result.format = "date-time";
-      }
-      return result;
-   }
-
-   // Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
-   if (isJTDEnum(schema)) {
-      return { enum: schema.enum };
-   }
-
-   // Elements form: { elements: { type: "string" } } → { type: "array", items: ... }
-   if (isJTDElements(schema)) {
-      return {
-         type: "array",
-         items: convertSchema(schema.elements),
-      };
-   }
-
-   // Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
-   if (isJTDValues(schema)) {
-      return {
-         type: "object",
-         additionalProperties: convertSchema(schema.values),
-      };
-   }
-
-   // Properties form: { properties: {...}, optionalProperties: {...} }
-   if (isJTDProperties(schema)) {
-      const properties: Record<string, unknown> = {};
-      const required: string[] = [];
-
-      // Required properties
-      if (schema.properties) {
-         for (const [key, value] of Object.entries(schema.properties)) {
-            properties[key] = convertSchema(value);
-            required.push(key);
-         }
-      }
-
-      // Optional properties
-      if (schema.optionalProperties) {
-         for (const [key, value] of Object.entries(schema.optionalProperties)) {
-            properties[key] = convertSchema(value);
-         }
-      }
-
-      const result: Record<string, unknown> = {
-         type: "object",
-         properties,
-         additionalProperties: false,
-      };
-
-      if (required.length > 0) {
-         result.required = required;
-      }
-
-      return result;
-   }
-
-   // Discriminator form: { discriminator: "type", mapping: { ... } }
-   if (isJTDDiscriminator(schema)) {
-      const oneOf: unknown[] = [];
-
-      for (const [tag, props] of Object.entries(schema.mapping)) {
-         const converted = convertSchema(props) as Record<string, unknown>;
-         // Add the discriminator property
-         const properties = (converted.properties || {}) as Record<string, unknown>;
-         properties[schema.discriminator] = { const: tag };
-
-         const required = ((converted.required as string[]) || []).slice();
-         if (!required.includes(schema.discriminator)) {
-            required.push(schema.discriminator);
-         }
-
-         oneOf.push({
-            ...converted,
-            properties,
-            required,
-         });
-      }
-
-      return { oneOf };
-   }
-
-   // Ref form: { ref: "MyType" } → { $ref: "#/$defs/MyType" }
-   if (isJTDRef(schema)) {
-      return { $ref: `#/$defs/${schema.ref}` };
-   }
-
-   // Empty form: {} → {} (accepts anything)
-   return {};
+	if (schema === null || typeof schema !== "object") {
+		return {};
+	}
+
+	// Type form: { type: "string" } → { type: "string" }
+	if (isJTDType(schema)) {
+		const jsonType = primitiveMap[schema.type as JTDPrimitive];
+		if (!jsonType) {
+			return { type: schema.type };
+		}
+		const result: Record<string, unknown> = { type: jsonType };
+		// Add format for timestamp
+		if (schema.type === "timestamp") {
+			result.format = "date-time";
+		}
+		return result;
+	}
+
+	// Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
+	if (isJTDEnum(schema)) {
+		return { enum: schema.enum };
+	}
+
+	// Elements form: { elements: { type: "string" } } → { type: "array", items: ... }
+	if (isJTDElements(schema)) {
+		return {
+			type: "array",
+			items: convertSchema(schema.elements),
+		};
+	}
+
+	// Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
+	if (isJTDValues(schema)) {
+		return {
+			type: "object",
+			additionalProperties: convertSchema(schema.values),
+		};
+	}
+
+	// Properties form: { properties: {...}, optionalProperties: {...} }
+	if (isJTDProperties(schema)) {
+		const properties: Record<string, unknown> = {};
+		const required: string[] = [];
+
+		// Required properties
+		if (schema.properties) {
+			for (const [key, value] of Object.entries(schema.properties)) {
+				properties[key] = convertSchema(value);
+				required.push(key);
+			}
+		}
+
+		// Optional properties
+		if (schema.optionalProperties) {
+			for (const [key, value] of Object.entries(schema.optionalProperties)) {
+				properties[key] = convertSchema(value);
+			}
+		}
+
+		const result: Record<string, unknown> = {
+			type: "object",
+			properties,
+			additionalProperties: false,
+		};
+
+		if (required.length > 0) {
+			result.required = required;
+		}
+
+		return result;
+	}
+
+	// Discriminator form: { discriminator: "type", mapping: { ... } }
+	if (isJTDDiscriminator(schema)) {
+		const oneOf: unknown[] = [];
+
+		for (const [tag, props] of Object.entries(schema.mapping)) {
+			const converted = convertSchema(props) as Record<string, unknown>;
+			// Add the discriminator property
+			const properties = (converted.properties || {}) as Record<string, unknown>;
+			properties[schema.discriminator] = { const: tag };
+
+			const required = ((converted.required as string[]) || []).slice();
+			if (!required.includes(schema.discriminator)) {
+				required.push(schema.discriminator);
+			}
+
+			oneOf.push({
+				...converted,
+				properties,
+				required,
+			});
+		}
+
+		return { oneOf };
+	}
+
+	// Ref form: { ref: "MyType" } → { $ref: "#/$defs/MyType" }
+	if (isJTDRef(schema)) {
+		return { $ref: `#/$defs/${schema.ref}` };
+	}
+
+	// Empty form: {} → {} (accepts anything)
+	return {};
 }
 
 /**
@@ -223,43 +211,33 @@ function convertSchema(schema: unknown): unknown {
  * JSON Schema uses: type: "object", type: "array", items, additionalProperties, etc.
  */
 export function isJTDSchema(schema: unknown): boolean {
-   if (schema === null || typeof schema !== "object") {
-      return false;
-   }
-
-   const obj = schema as Record<string, unknown>;
-
-   // JTD-specific keywords
-   if ("elements" in obj) return true;
-   if ("values" in obj) return true;
-   if ("optionalProperties" in obj) return true;
-   if ("discriminator" in obj) return true;
-   if ("ref" in obj) return true;
-
-   // JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
-   if ("type" in obj) {
-      const jtdPrimitives = [
-         "timestamp",
-         "float32",
-         "float64",
-         "int8",
-         "uint8",
-         "int16",
-         "uint16",
-         "int32",
-         "uint32",
-      ];
-      if (jtdPrimitives.includes(obj.type as string)) {
-         return true;
-      }
-   }
-
-   // JTD properties form without type: "object" (JSON Schema requires it)
-   if ("properties" in obj && !("type" in obj)) {
-      return true;
-   }
-
-   return false;
+	if (schema === null || typeof schema !== "object") {
+		return false;
+	}
+
+	const obj = schema as Record<string, unknown>;
+
+	// JTD-specific keywords
+	if ("elements" in obj) return true;
+	if ("values" in obj) return true;
+	if ("optionalProperties" in obj) return true;
+	if ("discriminator" in obj) return true;
+	if ("ref" in obj) return true;
+
+	// JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
+	if ("type" in obj) {
+		const jtdPrimitives = ["timestamp", "float32", "float64", "int8", "uint8", "int16", "uint16", "int32", "uint32"];
+		if (jtdPrimitives.includes(obj.type as string)) {
+			return true;
+		}
+	}
+
+	// JTD properties form without type: "object" (JSON Schema requires it)
+	if ("properties" in obj && !("type" in obj)) {
+		return true;
+	}
+
+	return false;
 }
 
 /**
@@ -267,8 +245,8 @@ export function isJTDSchema(schema: unknown): boolean {
  * If already JSON Schema, returns as-is.
  */
 export function jtdToJsonSchema(schema: unknown): unknown {
-   if (!isJTDSchema(schema)) {
-      return schema;
-   }
-   return convertSchema(schema);
+	if (!isJTDSchema(schema)) {
+		return schema;
+	}
+	return convertSchema(schema);
 }

package/src/core/tools/read.ts

@@ -311,10 +311,10 @@ async function findReadPathSuggestions(
 	return { suggestions, scopeLabel, truncated };
 }
 
-function convertWithMarkitdown(filePath: string): { content: string; ok: boolean; error?: string } {
-	const cmd = Bun.which("markitdown");
+async function convertWithMarkitdown(filePath: string): Promise<{ content: string; ok: boolean; error?: string }> {
+	const cmd = await ensureTool("markitdown", true);
 	if (!cmd) {
-		return { content: "", ok: false, error: "markitdown not found" };
+		return { content: "", ok: false, error: "markitdown not found (uv/pip unavailable)" };
 	}
 
 	const result = Bun.spawnSync([cmd, filePath], {
@@ -449,7 +449,7 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 					}
 				} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
 					// Convert document via markitdown
-					const result = convertWithMarkitdown(absolutePath);
+					const result = await convertWithMarkitdown(absolutePath);
 					if (result.ok) {
 						// Apply truncation to converted content
 						const truncation = truncateHead(result.content);