@oh-my-pi/pi-coding-agent 15.0.1 → 15.1.0

package/src/tools/todo-write.ts

@@ -1,10 +1,9 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import chalk from "chalk";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
@@ -45,45 +44,38 @@ export interface TodoWriteToolDetails {
 // Schema
 // =============================================================================
 
-const TodoOp = StringEnum(["init", "start", "done", "rm", "drop", "append", "note"] as const, {
-	description: "operation to apply",
-});
+const TodoOp = z
+	.enum(["init", "start", "done", "rm", "drop", "append", "note"] as const)
+	.describe("operation to apply");
 
-const InitListEntry = Type.Object({
-	phase: Type.String({ description: "phase name (short noun phrase)", examples: ["Foundation", "Auth"] }),
-	items: Type.Array(Type.String({ description: "task content (5-10 words)" }), {
-		minItems: 1,
-		description: "tasks for this phase, in execution order; all start as pending",
-	}),
+const InitListEntry = z.object({
+	phase: z.string().describe("phase name (short noun phrase)"),
+	items: z
+		.array(z.string().describe("task content (5-10 words)"))
+		.min(1)
+		.describe("tasks for this phase, in execution order; all start as pending"),
 });
 
-const TodoOpEntry = Type.Object({
+const TodoOpEntry = z.object({
 	op: TodoOp,
-	list: Type.Optional(Type.Array(InitListEntry, { description: "phased task list for op=init" })),
-	task: Type.Optional(
-		Type.String({ description: "task content for start/done/rm/drop/note", examples: ["Run tests"] }),
-	),
-	phase: Type.Optional(Type.String({ description: "phase name for done/rm/drop/append", examples: ["Auth"] })),
-	items: Type.Optional(
-		Type.Array(Type.String({ description: "task content (5-10 words)" }), {
-			minItems: 1,
-			description: "tasks to append to `phase` for op=append",
-		}),
-	),
-	text: Type.Optional(Type.String({ description: "note text for op=note (appended with newline)" })),
+	list: z.array(InitListEntry).optional().describe("phased task list for op=init"),
+	task: z.string().optional().describe("task content for start/done/rm/drop/note"),
+	phase: z.string().optional().describe("phase name for done/rm/drop/append"),
+	items: z
+		.array(z.string().describe("task content (5-10 words)"))
+		.min(1)
+		.optional()
+		.describe("tasks to append to `phase` for op=append"),
+	text: z.string().optional().describe("note text for op=note (appended with newline)"),
 });
 
-const todoWriteSchema = Type.Object(
-	{
-		ops: Type.Array(TodoOpEntry, {
-			minItems: 1,
-			description: "ordered todo operations",
-		}),
-	},
-	{ description: "Apply ordered todo operations" },
-);
+const todoWriteSchema = z
+	.object({
+		ops: z.array(TodoOpEntry).min(1).describe("ordered todo operations"),
+	})
+	.describe("Apply ordered todo operations");
 
-type TodoWriteParams = Static<typeof todoWriteSchema>;
+type TodoWriteParams = z.infer<typeof todoWriteSchema>;
 type TodoOpEntryValue = TodoWriteParams["ops"][number];
 
 // =============================================================================

package/src/tools/vim.ts

@@ -2,8 +2,8 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { extractSegments, sliceWithWidth, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, logger, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import * as Diff from "diff";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
@@ -36,35 +36,19 @@ import { toolResult } from "./tool-result";
 const INTERNAL_URL_PREFIX = /^(agent|artifact|skill|rule|local|mcp):\/\//;
 const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
 
-const vimStepSchema = Type.Object({
-	kbd: Type.Array(Type.String(), {
-		description: "vim key sequences",
-		examples: [["ggdGi"], ["3Go"], ["dd"]],
-	}),
-	insert: Type.Optional(
-		Type.String({
-			description: "raw text to insert",
-			examples: ["hello world"],
-		}),
-	),
+const vimStepSchema = z.object({
+	kbd: z.array(z.string()).describe("vim key sequences"),
+	insert: z.string().optional().describe("raw text to insert"),
 });
 
-const vimSchema = Type.Object({
-	file: Type.String({ description: "file path", examples: ["src/foo.ts"] }),
-	steps: Type.Optional(
-		Type.Array(vimStepSchema, {
-			description: "editing steps",
-		}),
-	),
-	pause: Type.Optional(
-		Type.Boolean({
-			description: "skip auto-save",
-		}),
-	),
+const vimSchema = z.object({
+	file: z.string().describe("file path"),
+	steps: z.array(vimStepSchema).optional().describe("editing steps"),
+	pause: z.boolean().optional().describe("skip auto-save"),
 });
 
-type VimParams = Static<typeof vimSchema>;
-type VimStep = Static<typeof vimStepSchema>;
+type VimParams = z.infer<typeof vimSchema>;
+type VimStep = z.infer<typeof vimStepSchema>;
 
 interface VimRenderStep {
 	kbd?: string[];

package/src/tools/write.ts

@@ -5,9 +5,11 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { stripHashlinePrefixes } from "../edit";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { InternalUrlRouter } from "../internal-urls";
+import { parseInternalUrl } from "../internal-urls/parse";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
@@ -56,12 +58,12 @@ async function loadFflate(): Promise<typeof import("fflate")> {
 	return fflateModulePromise;
 }
 
-const writeSchema = Type.Object({
-	path: Type.String({ description: "file path", examples: ["src/new.ts"] }),
-	content: Type.String({ description: "file content" }),
+const writeSchema = z.object({
+	path: z.string().describe("file path"),
+	content: z.string().describe("file content"),
 });
 
-export type WriteToolInput = Static<typeof writeSchema>;
+export type WriteToolInput = z.infer<typeof writeSchema>;
 
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {
@@ -658,6 +660,24 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		return untilAborted(signal, async () => {
 			// Strip hashline display prefixes (LINE+ID|) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
+			const internalRouter = InternalUrlRouter.instance();
+			if (internalRouter.canHandle(path)) {
+				const parsed = parseInternalUrl(path);
+				const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
+				const handler = internalRouter.getHandler(scheme);
+				if (handler?.write) {
+					await handler.write(parsed, cleanContent, { cwd: this.session.cwd, signal });
+					let resultText = `Successfully wrote ${cleanContent.length} bytes to ${path}`;
+					if (stripped) {
+						resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
+					}
+					return { content: [{ type: "text", text: resultText }], details: {} };
+				}
+				// Schemes without a `write` hook fall through to existing logic
+				// (local:// resolves to a backing file via plan-mode-guard) or are
+				// rejected downstream when no backing file exists.
+			}
+
 			const conflictUri = parseConflictUri(path);
 			if (conflictUri) {
 				if (conflictUri.scope) {

package/src/tools/yield.ts

@@ -4,10 +4,15 @@
  * Subagents must call this tool to finish and return structured JSON output.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { dereferenceJsonSchema, sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/schema";
-import type { Static, TSchema } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
-import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
+import type { TSchema } from "@oh-my-pi/pi-ai/types";
+import {
+	dereferenceJsonSchema,
+	isValidJsonSchema,
+	type JsonSchemaValidationIssue,
+	type JsonSchemaValidationResult,
+	sanitizeSchemaForStrictMode,
+	validateJsonSchemaValue,
+} from "@oh-my-pi/pi-ai/utils/schema";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
 import type { ToolSession } from ".";
 import { jtdToJsonSchema, normalizeSchema } from "./jtd-to-json-schema";
@@ -18,8 +23,6 @@ export interface YieldDetails {
 	error?: string;
 }
 
-const ajv = new Ajv({ allErrors: true, strict: false, logger: false });
-
 function formatSchema(schema: unknown): string {
 	if (schema === undefined) return "No schema provided.";
 	if (typeof schema === "string") return schema;
@@ -30,16 +33,72 @@ function formatSchema(schema: unknown): string {
 	}
 }
 
-function formatAjvErrors(errors: ErrorObject[] | null | undefined): string {
-	if (!errors || errors.length === 0) return "Unknown schema validation error.";
-	return errors
-		.map(err => {
-			const path = err.instancePath ? `${err.instancePath}: ` : "";
-			return `${path}${err.message ?? "invalid"}`;
+function formatJsonSchemaIssues(issues: ReadonlyArray<JsonSchemaValidationIssue> | undefined): string {
+	if (!issues || issues.length === 0) return "Unknown schema validation error.";
+	return issues
+		.map(issue => {
+			const path = issue.path.length === 0 ? "" : `${issue.path.map(seg => String(seg)).join("/")}: `;
+			return `${path}${issue.message}`;
 		})
 		.join("; ");
 }
 
+function looseRecordSchema(description: string): Record<string, unknown> {
+	return {
+		type: "object",
+		additionalProperties: true,
+		description,
+	};
+}
+
+function hasUnresolvedRefs(schema: unknown): boolean {
+	if (schema == null) return false;
+	if (Array.isArray(schema)) {
+		for (const item of schema) {
+			if (hasUnresolvedRefs(item)) return true;
+		}
+		return false;
+	}
+	if (typeof schema !== "object") return false;
+	const record = schema as Record<string, unknown>;
+	if (typeof record.$ref === "string") return true;
+	for (const key in record) {
+		if (key === "const" || key === "default" || key === "enum" || key === "examples") continue;
+		if (hasUnresolvedRefs(record[key])) return true;
+	}
+	return false;
+}
+
+function wrapYieldParameters(dataSchema: Record<string, unknown>): Record<string, unknown> {
+	return {
+		type: "object",
+		additionalProperties: false,
+		description: "submit data or error",
+		properties: {
+			result: {
+				anyOf: [
+					{
+						type: "object",
+						additionalProperties: false,
+						description: "task succeeded",
+						properties: { data: dataSchema },
+						required: ["data"],
+					},
+					{
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							error: { type: "string", description: "error message" },
+						},
+						required: ["error"],
+					},
+				],
+			},
+		},
+		required: ["result"],
+	};
+}
+
 export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	readonly name = "yield";
 	readonly label = "Submit Result";
@@ -52,33 +111,15 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	readonly intent = "omit" as const;
 	lenientArgValidation = true;
 
-	readonly #validate?: ValidateFunction;
+	readonly #validate?: (value: unknown) => JsonSchemaValidationResult;
 	#schemaValidationFailures = 0;
 
 	constructor(session: ToolSession) {
-		const createParameters = (dataSchema: TSchema): TSchema =>
-			Type.Object(
-				{
-					result: Type.Union([
-						Type.Object({ data: dataSchema }, { description: "task succeeded" }),
-						Type.Object({
-							error: Type.String({ description: "error message" }),
-						}),
-					]),
-				},
-				{
-					additionalProperties: false,
-					description: "submit data or error",
-				},
-			) as TSchema;
-
-		let validate: ValidateFunction | undefined;
-		let dataSchema: TSchema;
+		let validate: ((value: unknown) => JsonSchemaValidationResult) | undefined;
 		let parameters: TSchema;
 
 		try {
 			const schemaResult = normalizeSchema(session.outputSchema);
-			// Convert JTD to JSON Schema if needed (auto-detected)
 			const normalizedSchema =
 				schemaResult.normalized !== undefined ? jtdToJsonSchema(schemaResult.normalized) : undefined;
 			let schemaError = schemaResult.error;
@@ -88,10 +129,10 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			}
 
 			if (normalizedSchema !== undefined && normalizedSchema !== false && !schemaError) {
-				try {
-					validate = ajv.compile(normalizedSchema as Record<string, unknown> | boolean);
-				} catch (err) {
-					schemaError = err instanceof Error ? err.message : String(err);
+				if (!isValidJsonSchema(normalizedSchema)) {
+					schemaError = "invalid JSON schema";
+				} else {
+					validate = value => validateJsonSchemaValue(normalizedSchema, value);
 				}
 			}
 
@@ -109,27 +150,29 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 						? {}
 						: undefined;
 
+			let dataSchema: Record<string, unknown>;
 			if (sanitizedSchema !== undefined) {
 				const resolved = dereferenceJsonSchema({
 					...sanitizedSchema,
 					description: schemaDescription,
-				});
-				dataSchema = Type.Unsafe(resolved as Record<string, unknown>);
+				}) as Record<string, unknown>;
+				if (hasUnresolvedRefs(resolved)) {
+					throw new Error("schema contains unresolved $ref after dereferencing");
+				}
+				dataSchema = resolved;
 			} else {
-				dataSchema = Type.Record(Type.String(), Type.Any(), {
-					description: schemaError ? schemaDescription : "Structured JSON output (no schema specified)",
-				});
+				dataSchema = looseRecordSchema(
+					schemaError ? schemaDescription : "Structured JSON output (no schema specified)",
+				);
 			}
-			parameters = createParameters(dataSchema);
+			parameters = wrapYieldParameters(dataSchema);
 			JSON.stringify(parameters);
-			// Verify the final parameters compile with AJV (catches unresolved $ref, etc.)
-			ajv.compile(parameters as Record<string, unknown>);
+			if (!isValidJsonSchema(parameters)) throw new Error("yield parameters schema is invalid");
 		} catch (err) {
 			const errorMsg = err instanceof Error ? err.message : String(err);
-			dataSchema = Type.Record(Type.String(), Type.Any(), {
-				description: `Structured JSON output (schema processing failed: ${errorMsg})`,
-			});
-			parameters = createParameters(dataSchema);
+			parameters = wrapYieldParameters(
+				looseRecordSchema(`Structured JSON output (schema processing failed: ${errorMsg})`),
+			);
 			validate = undefined;
 			this.strict = false;
 		}
@@ -140,7 +183,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 
 	async execute(
 		_toolCallId: string,
-		params: Static<TSchema>,
+		params: unknown,
 		_signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<YieldDetails>,
 		_context?: AgentToolContext,
@@ -170,12 +213,15 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			if (data === undefined || data === null) {
 				throw new Error("data is required when yield indicates success");
 			}
-			if (this.#validate && !this.#validate(data)) {
-				this.#schemaValidationFailures++;
-				if (this.#schemaValidationFailures <= 1) {
-					throw new Error(`Output does not match schema: ${formatAjvErrors(this.#validate.errors)}`);
+			if (this.#validate) {
+				const parsed = this.#validate(data);
+				if (!parsed.success) {
+					this.#schemaValidationFailures++;
+					if (this.#schemaValidationFailures <= 1) {
+						throw new Error(`Output does not match schema: ${formatJsonSchemaIssues(parsed.issues)}`);
+					}
+					schemaValidationOverridden = true;
 				}
-				schemaValidationOverridden = true;
 			}
 		}
 

package/src/web/search/index.ts

@@ -6,9 +6,8 @@
  *
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -21,30 +20,16 @@ import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
 
 /** Web search tool parameters schema */
-export const webSearchSchema = Type.Object({
-	query: Type.String({ description: "Search query" }),
-	recency: Type.Optional(
-		StringEnum(["day", "week", "month", "year"], {
-			description: "Recency filter (Brave, Perplexity)",
-		}),
-	),
-	limit: Type.Optional(Type.Number({ description: "Max results to return" })),
-	max_tokens: Type.Optional(Type.Number({ description: "Maximum output tokens" })),
-	temperature: Type.Optional(Type.Number({ description: "Sampling temperature" })),
-	num_search_results: Type.Optional(Type.Number({ description: "Number of search results to retrieve" })),
+export const webSearchSchema = z.object({
+	query: z.string().describe("Search query"),
+	recency: z.enum(["day", "week", "month", "year"]).describe("Recency filter (Brave, Perplexity)").optional(),
+	limit: z.number().describe("Max results to return").optional(),
+	max_tokens: z.number().describe("Maximum output tokens").optional(),
+	temperature: z.number().describe("Sampling temperature").optional(),
+	num_search_results: z.number().describe("Number of search results to retrieve").optional(),
 });
 
-export type SearchToolParams = {
-	query: string;
-	recency?: "day" | "week" | "month" | "year";
-	limit?: number;
-	/** Maximum output tokens. Defaults to 4096. */
-	max_tokens?: number;
-	/** Sampling temperature (0–1). Lower = more focused/factual. Defaults to 0.2. */
-	temperature?: number;
-	/** Number of search results to retrieve. Defaults to 10. */
-	num_search_results?: number;
-};
+export type SearchToolParams = z.infer<typeof webSearchSchema>;
 
 export interface SearchQueryParams extends SearchToolParams {
 	provider?: SearchProviderId | "auto";

package/src/web/search/providers/anthropic.ts

@@ -38,6 +38,7 @@ export interface AnthropicSearchParams {
 	max_tokens?: number;
 	/** Sampling temperature (0–1). Lower = more focused/factual. */
 	temperature?: number;
+	signal?: AbortSignal;
 }
 
 /**
@@ -86,6 +87,7 @@ async function callSearch(
 	systemPrompt?: string,
 	maxTokens?: number,
 	temperature?: number,
+	signal?: AbortSignal,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
 	const headers = buildAnthropicSearchHeaders(auth);
@@ -116,6 +118,7 @@ async function callSearch(
 		method: "POST",
 		headers,
 		body: JSON.stringify(body),
+		signal,
 	});
 
 	if (!response.ok) {
@@ -253,6 +256,7 @@ export async function searchAnthropic(params: AnthropicSearchParams): Promise<Se
 		params.system_prompt,
 		params.max_tokens,
 		params.temperature,
+		params.signal,
 	);
 
 	const result = parseResponse(response);
@@ -281,6 +285,7 @@ export class AnthropicProvider extends SearchProvider {
 			num_results: params.numSearchResults ?? params.limit,
 			max_tokens: params.maxOutputTokens,
 			temperature: params.temperature,
+			signal: params.signal,
 		});
 	}
 }

package/src/web/search/providers/exa.ts

@@ -29,6 +29,7 @@ export interface ExaSearchParams {
 	exclude_domains?: string[];
 	start_published_date?: string;
 	end_published_date?: string;
+	signal?: AbortSignal;
 }
 
 interface ExaSearchResult {
@@ -179,6 +180,7 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 			"x-api-key": apiKey,
 		},
 		body: JSON.stringify(body),
+		signal: params.signal,
 	});
 
 	if (!response.ok) {
@@ -259,6 +261,7 @@ export class ExaProvider extends SearchProvider {
 		return searchExa({
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
+			signal: params.signal,
 		});
 	}
 }

package/src/web/search/providers/gemini.ts

@@ -39,6 +39,7 @@ export interface GeminiSearchParams extends GeminiToolParams {
 	max_output_tokens?: number;
 	/** Sampling temperature (0–1). Lower = more focused/factual. */
 	temperature?: number;
+	signal?: AbortSignal;
 }
 
 export function buildGeminiRequestTools(params: GeminiToolParams): Array<Record<string, Record<string, unknown>>> {
@@ -235,6 +236,7 @@ async function callGeminiSearch(
 	maxOutputTokens?: number,
 	temperature?: number,
 	toolParams: GeminiToolParams = {},
+	signal?: AbortSignal,
 ): Promise<{
 	answer: string;
 	sources: SearchSource[];
@@ -308,6 +310,7 @@ async function callGeminiSearch(
 			...headers,
 		},
 		body: JSON.stringify(requestBody),
+		signal,
 	});
 	const urlFor = (attempt: number) =>
 		`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`;
@@ -500,6 +503,7 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 			code_execution: params.code_execution,
 			url_context: params.url_context,
 		},
+		params.signal,
 	);
 
 	let sources = result.sources;
@@ -539,6 +543,7 @@ export class GeminiProvider extends SearchProvider {
 			google_search: params.googleSearch,
 			code_execution: params.codeExecution,
 			url_context: params.urlContext,
+			signal: params.signal,
 		});
 	}
 }

package/src/web/search/providers/jina.ts

@@ -17,6 +17,7 @@ const JINA_SEARCH_URL = "https://s.jina.ai";
 export interface JinaSearchParams {
 	query: string;
 	num_results?: number;
+	signal?: AbortSignal;
 }
 
 interface JinaSearchResult {
@@ -33,13 +34,14 @@ export function findApiKey(): string | null {
 }
 
 /** Call Jina Reader search API. */
-async function callJinaSearch(apiKey: string, query: string): Promise<JinaSearchResponse> {
+async function callJinaSearch(apiKey: string, query: string, signal?: AbortSignal): Promise<JinaSearchResponse> {
 	const requestUrl = `${JINA_SEARCH_URL}/${encodeURIComponent(query)}`;
 	const response = await fetch(requestUrl, {
 		headers: {
 			Accept: "application/json",
 			Authorization: `Bearer ${apiKey}`,
 		},
+		signal,
 	});
 
 	if (!response.ok) {
@@ -58,7 +60,7 @@ export async function searchJina(params: JinaSearchParams): Promise<SearchRespon
 		throw new Error("JINA_API_KEY not found. Set it in environment or .env file.");
 	}
 
-	const response = await callJinaSearch(apiKey, params.query);
+	const response = await callJinaSearch(apiKey, params.query, params.signal);
 	const sources: SearchSource[] = [];
 
 	for (const result of response) {
@@ -91,6 +93,7 @@ export class JinaProvider extends SearchProvider {
 		return searchJina({
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
+			signal: params.signal,
 		});
 	}
 }

package/src/web/search/providers/zai.ts

@@ -20,6 +20,7 @@ const DEFAULT_NUM_RESULTS = 10;
 export interface ZaiSearchParams {
 	query: string;
 	num_results?: number;
+	signal?: AbortSignal;
 }
 
 interface ZaiSearchResult {
@@ -55,7 +56,7 @@ export async function findApiKey(): Promise<string | null> {
 	return findCredential(getEnvApiKey("zai"), "zai");
 }
 
-async function callZaiTool(apiKey: string, args: Record<string, unknown>): Promise<unknown> {
+async function callZaiTool(apiKey: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
 	const response = await fetch(ZAI_MCP_URL, {
 		method: "POST",
 		headers: {
@@ -72,6 +73,7 @@ async function callZaiTool(apiKey: string, args: Record<string, unknown>): Promi
 				arguments: args,
 			},
 		}),
+		signal,
 	});
 
 	if (!response.ok) {
@@ -157,7 +159,7 @@ async function callZaiSearch(apiKey: string, params: ZaiSearchParams): Promise<u
 	let lastError: unknown;
 	for (let i = 0; i < attempts.length; i++) {
 		try {
-			return await callZaiTool(apiKey, attempts[i]);
+			return await callZaiTool(apiKey, attempts[i], params.signal);
 		} catch (error) {
 			lastError = error;
 			const isLastAttempt = i === attempts.length - 1;
@@ -302,6 +304,7 @@ export class ZaiProvider extends SearchProvider {
 		return searchZai({
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
+			signal: params.signal,
 		});
 	}
 }

package/src/prompts/compaction/branch-summary-context.md

@@ -1,5 +0,0 @@
-The following is a summary of a branch that this conversation came back from:
-
-<summary>
-{{summary}}
-</summary>

package/src/prompts/compaction/branch-summary-preamble.md

@@ -1,2 +0,0 @@
-The user explored a different conversation branch before returning here.
-Summary of that exploration: