@oh-my-pi/pi-coding-agent 3.21.0 → 3.24.0

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [3.24.0] - 2026-01-07
+### Added
+
+- Added `ToolSession` interface to unify tool creation with session context including cwd, UI availability, and rulebook rules
+- Added Bun Worker-based execution for subagent tasks, replacing subprocess spawning for improved performance and event streaming
+- Added `toolNames` option to filter which built-in tools are included in agent sessions
+- Added `BUILTIN_TOOLS` registry constant for programmatic access to available tool factories
+- Added unit tests for `createTools` function covering tool filtering and conditional tool creation
+
+### Changed
+
+- Changed subagent execution from spawning separate `omp` processes to running in Bun Workers with direct event streaming
+- Changed tool factories to accept `ToolSession` parameter instead of separate cwd and options arguments
+- Changed `createTools` to return tools as a Map and support conditional tool creation based on session context
+- Changed system prompt builder to dynamically generate tool descriptions from the tool registry
+- Changed task tool description to be generated from a template with dynamic agent list injection
+- Changed tool creation to use a unified `ToolSession` interface instead of separate parameters for cwd, options, and callbacks
+- Changed `createTools` to return tools as a Map instead of an array for consistent tool registry access
+- Changed system prompt builder to receive tool registry Map for dynamic tool description generation
+- Changed subprocess usage tracking to accumulate incrementally from message_end events rather than parsing stored events after completion
+
+### Removed
+
+- Removed `browser` embedded agent from task tool agent discovery
+- Removed `recursive` property from agent definitions
+- Removed environment variables `OMP_NO_SUBAGENTS`, `OMP_BLOCKED_AGENT`, and `OMP_SPAWNS` for subagent control
+- Removed pre-instantiated tool exports (`readTool`, `bashTool`, `editTool`, `writeTool`, `grepTool`, `findTool`, `lsTool`) in favor of factory functions
+- Removed `createCodingTools` and `createReadOnlyTools` helper functions
+- Removed `codingTools` and `readOnlyTools` convenience exports
+- Removed `wrapToolsWithExtensions` function from extensions API
+- Removed `hidden` property support from custom tools
+- Removed subagent and question custom tool examples
+
+### Fixed
+
+- Fixed memory accumulation in task subprocess by streaming events directly to disk instead of storing in memory
+- Fixed session persistence to exclude transient streaming data (partialJson, jsonlEvents) that was causing unnecessary storage bloat
+- Fixed createTools respecting explicit tool lists instead of returning all non-hidden tools
+
 ## [3.21.0] - 2026-01-06
 
 ### Changed
@@ -1756,4 +1795,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/docs/sdk.md

@@ -347,60 +347,60 @@ const { session } = await createAgentSession({
 
 ### Tools
 
-```typescript
-import {
-	codingTools, // read, bash, edit, write (default)
-	readOnlyTools, // read, grep, find, ls
-	readTool,
-	bashTool,
-	editTool,
-	writeTool,
-	grepTool,
-	findTool,
-	lsTool,
-} from "@oh-my-pi/pi-coding-agent";
+By default, `createAgentSession` creates all built-in tools automatically. You can filter which tools are available using `toolNames`:
 
-// Use built-in tool set
-const { session } = await createAgentSession({
-	tools: readOnlyTools,
-});
+```typescript
+// Use all built-in tools (default)
+const { session } = await createAgentSession();
 
-// Pick specific tools
+// Filter to specific tools
 const { session } = await createAgentSession({
-	tools: [readTool, bashTool, grepTool],
+	toolNames: ["read", "grep", "find", "ls"], // Read-only tools
 });
 ```
 
-#### Tools with Custom cwd
+#### Available Built-in Tools
+
+All tools are defined in `BUILTIN_TOOLS`:
 
-**Important:** The pre-built tool instances (`readTool`, `bashTool`, etc.) use `process.cwd()` for path resolution. When you specify a custom `cwd` AND provide explicit `tools`, you must use the tool factory functions to ensure paths resolve correctly:
+- `ask` - Interactive user prompts (requires UI)
+- `bash` - Shell command execution
+- `edit` - Surgical file editing
+- `find` - File search by glob patterns
+- `git` - Git operations (can be disabled via settings)
+- `grep` - Content search with regex
+- `ls` - Directory listing
+- `lsp` - Language server protocol integration
+- `notebook` - Jupyter notebook editing
+- `output` - Task output retrieval
+- `read` - File reading (text and images)
+- `rulebook` - Rule reference (requires rules)
+- `task` - Subagent spawning
+- `web_fetch` - Web page fetching
+- `web_search` - Web search
+- `write` - File writing
+
+#### Creating Tools Manually
+
+For advanced use cases, you can create tools directly using `createTools`:
 
 ```typescript
 import {
-	createCodingTools, // Creates [read, bash, edit, write] for specific cwd
-	createReadOnlyTools, // Creates [read, grep, find, ls] for specific cwd
-	createReadTool,
-	createBashTool,
-	createEditTool,
-	createWriteTool,
-	createGrepTool,
-	createFindTool,
-	createLsTool,
+	BUILTIN_TOOLS,
+	createTools,
+	type ToolSession,
 } from "@oh-my-pi/pi-coding-agent";
 
-const cwd = "/path/to/project";
-
-// Use factory for tool sets
-const { session } = await createAgentSession({
-	cwd,
-	tools: createCodingTools(cwd), // Tools resolve paths relative to cwd
-});
+const session: ToolSession = {
+	cwd: "/path/to/project",
+	hasUI: false,
+	rulebookRules: [],
+	getSessionFile: () => null,
+	getSessionSpawns: () => "*",
+	getAvailableTools: () => Object.keys(BUILTIN_TOOLS),
+};
 
-// Or pick specific tools
-const { session } = await createAgentSession({
-	cwd,
-	tools: [createReadTool(cwd), createBashTool(cwd), createGrepTool(cwd)],
-});
+const tools = await createTools(session);
 ```
 
 **When you don't need factories:**
@@ -943,17 +943,14 @@ buildSystemPrompt
 SessionManager
 SettingsManager
 
-// Built-in tools (use process.cwd())
-codingTools
-readOnlyTools
-readTool, bashTool, editTool, writeTool
-grepTool, findTool, lsTool
+// Tool registry and factory
+BUILTIN_TOOLS              // Map of tool name to factory
+createTools                // Create all tools from ToolSession
+type ToolSession           // Session context for tool creation
 
-// Tool factories (for custom cwd)
-createCodingTools
-createReadOnlyTools
+// Individual tool factories
 createReadTool, createBashTool, createEditTool, createWriteTool
-createGrepTool, createFindTool, createLsTool
+createGrepTool, createFindTool, createLsTool, createGitTool
 
 // Types
 type CreateAgentSessionOptions

package/examples/custom-tools/README.md

@@ -10,10 +10,6 @@ Each example uses the `subdirectory/index.ts` structure required for tool discov
 
 Minimal example showing the basic structure of a custom tool.
 
-### question/
-
-Demonstrates `pi.ui.select()` for asking the user questions with options.
-
 ### todo/
 
 Full-featured example demonstrating:
@@ -23,17 +19,6 @@ Full-featured example demonstrating:
 - Proper branching support via details storage
 - State management without external files
 
-### subagent/
-
-Delegate tasks to specialized subagents with isolated context windows. Includes:
-
-- `index.ts` - The custom tool (single, parallel, and chain modes)
-- `agents.ts` - Agent discovery helper
-- `agents/` - Sample agent definitions (scout, planner, reviewer, worker)
-- `commands/` - Workflow presets (/implement, /scout-and-plan, /implement-and-review)
-
-See [subagent/README.md](subagent/README.md) for full documentation.
-
 ## Usage
 
 ```bash

package/examples/hooks/custom-compaction.ts

@@ -42,9 +42,7 @@ export default function (pi: HookAPI) {
 		const allMessages = [...messagesToSummarize, ...turnPrefixMessages];
 
 		ctx.ui.notify(
-			`Custom compaction: summarizing ${allMessages.length} messages (${tokensBefore.toLocaleString()} tokens) with ${
-				model.id
-			}...`,
+			`Custom compaction: summarizing ${allMessages.length} messages (${tokensBefore.toLocaleString()} tokens) with ${model.id}...`,
 			"info",
 		);
 

package/examples/sdk/README.md

@@ -44,12 +44,8 @@ import {
 	buildSystemPrompt,
 	ModelRegistry,
 	SessionManager,
-	codingTools,
-	readOnlyTools,
-	readTool,
-	bashTool,
-	editTool,
-	writeTool,
+	BUILTIN_TOOLS,
+	createTools,
 } from "@oh-my-pi/pi-coding-agent";
 
 // Auth and models setup
@@ -70,8 +66,8 @@ const { session } = await createAgentSession({
 	modelRegistry,
 });
 
-// Read-only
-const { session } = await createAgentSession({ tools: readOnlyTools, authStorage, modelRegistry });
+// Read-only tools
+const { session } = await createAgentSession({ toolNames: ["read", "grep", "find", "ls"], authStorage, modelRegistry });
 
 // In-memory
 const { session } = await createAgentSession({
@@ -90,7 +86,7 @@ const { session } = await createAgentSession({
 	authStorage: customAuth,
 	modelRegistry: customRegistry,
 	systemPrompt: "You are helpful.",
-	tools: [readTool, bashTool],
+	toolNames: ["read", "bash"],
 	customTools: [{ tool: myTool }],
 	hooks: [{ factory: myHook }],
 	skills: [],
@@ -119,7 +115,7 @@ await session.prompt("Hello");
 | `model`                     | From settings/first available | Model to use                      |
 | `thinkingLevel`             | From settings/"off"           | off, low, medium, high            |
 | `systemPrompt`              | Discovered                    | String or `(default) => modified` |
-| `tools`                     | `codingTools`                 | Built-in tools                    |
+| `toolNames`                 | All built-in tools            | Filter which tools to include     |
 | `customTools`               | Discovered                    | Replaces discovery                |
 | `additionalCustomToolPaths` | `[]`                          | Merge with discovery              |
 | `hooks`                     | Discovered                    | Replaces discovery                |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.21.0",
+	"version": "3.24.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -29,7 +29,7 @@
 		"CHANGELOG.md"
 	],
 	"scripts": {
-		"check": "tsgo --noEmit",
+		"check": "tsgo -p tsconfig.check.json",
 		"clean": "rm -rf dist",
 		"build": "tsgo -p tsconfig.build.json && chmod +x dist/cli.js",
 		"build:binary": "bun build --compile ./src/cli.ts --outfile dist/omp",
@@ -40,9 +40,9 @@
 	},
 	"dependencies": {
 		"@mariozechner/pi-ai": "^0.37.4",
-		"@oh-my-pi/pi-agent-core": "3.21.0",
-		"@oh-my-pi/pi-git-tool": "3.21.0",
-		"@oh-my-pi/pi-tui": "3.21.0",
+		"@oh-my-pi/pi-agent-core": "3.24.0",
+		"@oh-my-pi/pi-git-tool": "3.24.0",
+		"@oh-my-pi/pi-tui": "3.24.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/cli/args.ts

@@ -5,11 +5,12 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import chalk from "chalk";
 import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config";
-import { allTools, type ToolName } from "../core/tools/index";
+import { BUILTIN_TOOLS } from "../core/tools/index";
 
 export type Mode = "text" | "json" | "rpc";
 
 export interface Args {
+	cwd?: string;
 	provider?: string;
 	model?: string;
 	smol?: string;
@@ -27,7 +28,7 @@ export interface Args {
 	session?: string;
 	sessionDir?: string;
 	models?: string[];
-	tools?: ToolName[];
+	tools?: string[];
 	hooks?: string[];
 	extensions?: string[];
 	print?: boolean;
@@ -94,13 +95,15 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			result.models = args[++i].split(",").map((s) => s.trim());
 		} else if (arg === "--tools" && i + 1 < args.length) {
 			const toolNames = args[++i].split(",").map((s) => s.trim());
-			const validTools: ToolName[] = [];
+			const validTools: string[] = [];
 			for (const name of toolNames) {
-				if (name in allTools) {
-					validTools.push(name as ToolName);
+				if (name in BUILTIN_TOOLS) {
+					validTools.push(name);
 				} else {
 					console.error(
-						chalk.yellow(`Warning: Unknown tool "${name}". Valid tools: ${Object.keys(allTools).join(", ")}`),
+						chalk.yellow(
+							`Warning: Unknown tool "${name}". Valid tools: ${Object.keys(BUILTIN_TOOLS).join(", ")}`,
+						),
 					);
 				}
 			}

package/src/core/agent-session.ts

@@ -90,7 +90,7 @@ export interface AgentSessionConfig {
 	/** Tool registry for LSP and settings */
 	toolRegistry?: Map<string, AgentTool>;
 	/** System prompt builder that can consider tool availability */
-	rebuildSystemPrompt?: (toolNames: string[]) => string;
+	rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => string;
 	/** TTSR manager for time-traveling stream rules */
 	ttsrManager?: TtsrManager;
 }
@@ -222,7 +222,7 @@ export class AgentSession {
 
 	// Tool registry and prompt builder for extensions
 	private _toolRegistry: Map<string, AgentTool>;
-	private _rebuildSystemPrompt: ((toolNames: string[]) => string) | undefined;
+	private _rebuildSystemPrompt: ((toolNames: string[], tools: Map<string, AgentTool>) => string) | undefined;
 	private _baseSystemPrompt: string;
 
 	// TTSR manager for time-traveling stream rules
@@ -603,7 +603,7 @@ export class AgentSession {
 
 		// Rebuild base system prompt with new tool set
 		if (this._rebuildSystemPrompt) {
-			this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
+			this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames, this._toolRegistry);
 			this.agent.setSystemPrompt(this._baseSystemPrompt);
 		}
 	}

package/src/core/custom-tools/wrapper.ts

@@ -16,7 +16,6 @@ export function wrapCustomTool(tool: CustomTool, getContext: () => CustomToolCon
 		label: tool.label,
 		description: tool.description,
 		parameters: tool.parameters,
-		hidden: tool.hidden,
 		execute: (toolCallId, params, signal, onUpdate, context) =>
 			tool.execute(toolCallId, params, onUpdate, context ?? getContext(), signal),
 		renderCall: tool.renderCall ? (args, theme) => tool.renderCall?.(args, theme as Theme) : undefined,

package/src/core/extensions/index.ts

@@ -92,9 +92,4 @@ export {
 	isReadToolResult,
 	isWriteToolResult,
 } from "./types";
-export {
-	wrapRegisteredTool,
-	wrapRegisteredTools,
-	wrapToolsWithExtensions,
-	wrapToolWithExtensions,
-} from "./wrapper";
+export { wrapRegisteredTool, wrapRegisteredTools, wrapToolWithExtensions } from "./wrapper";

package/src/core/extensions/wrapper.ts

@@ -138,10 +138,3 @@ export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: Exten
 		},
 	};
 }
-
-/**
- * Wrap all tools with extension callbacks.
- */
-export function wrapToolsWithExtensions<T>(tools: AgentTool<any, T>[], runner: ExtensionRunner): AgentTool<any, T>[] {
-	return tools.map((tool) => wrapToolWithExtensions(tool, runner));
-}

package/src/core/file-mentions.ts

@@ -6,9 +6,9 @@
  * so the agent doesn't need to read them manually.
  */
 
+import path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { FileMentionMessage } from "./messages";
-import { createReadTool } from "./tools/read";
 
 /** Regex to match @filepath patterns in text */
 const FILE_MENTION_REGEX = /@((?:[^\s@]+\/)*[^\s@]+\.[a-zA-Z0-9]+)/g;
@@ -26,17 +26,14 @@ export function extractFileMentions(text: string): string[] {
 export async function generateFileMentionMessages(filePaths: string[], cwd: string): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
-	const readTool = createReadTool(cwd);
 	const files: FileMentionMessage["files"] = [];
 
 	for (const filePath of filePaths) {
 		try {
-			const result = await readTool.execute("auto-read", { path: filePath });
-			const textContent = result.content.find((c) => c.type === "text");
-			if (textContent && textContent.type === "text") {
-				const lineCount = textContent.text.split("\n").length;
-				files.push({ path: filePath, content: textContent.text, lineCount });
-			}
+			const absolutePath = path.resolve(cwd, filePath);
+			const content = await Bun.file(absolutePath).text();
+			const lineCount = content.split("\n").length;
+			files.push({ path: filePath, content, lineCount });
 		} catch {
 			// File doesn't exist or isn't readable - skip silently
 		}