@gajae-code/coding-agent 0.2.3 → 0.2.5

package/src/tools/index.ts

@@ -31,6 +31,7 @@ import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
+import { CronCreateTool, CronDeleteTool, CronListTool } from "./cron";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
 import { FindTool } from "./find";
@@ -41,6 +42,7 @@ import { HindsightRetainTool } from "./hindsight-retain";
 import { InspectImageTool } from "./inspect-image";
 import { IrcTool } from "./irc";
 import { JobTool } from "./job";
+import { MonitorTool } from "./monitor";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
 import { RecipeTool } from "./recipe";
@@ -69,6 +71,7 @@ export * from "./bash";
 export * from "./browser";
 export * from "./calculator";
 export * from "./checkpoint";
+export * from "./cron";
 export * from "./debug";
 export * from "./eval";
 export * from "./find";
@@ -80,6 +83,7 @@ export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
+export * from "./monitor";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -164,6 +168,8 @@ export interface ToolSession {
 	getToolByName?: (name: string) => AgentTool | undefined;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;
+	/** Optional restricted bash command prefixes for read-only role agents. */
+	bashAllowedPrefixes?: string[];
 	/** Get artifacts directory for artifact:// URLs */
 	getArtifactsDir?: () => string | null;
 	/** Get the ArtifactManager backing this session (shared across parent + subagents). */
@@ -319,6 +325,10 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	task: s => TaskTool.create(s),
 	subagent: s => new SubagentTool(s),
 	job: JobTool.createIf,
+	monitor: MonitorTool.createIf,
+	CronCreate: CronCreateTool.createIf,
+	CronList: CronListTool.createIf,
+	CronDelete: CronDeleteTool.createIf,
 	recipe: RecipeTool.createIf,
 	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
@@ -466,6 +476,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const discoveryActive = effectiveDiscoveryMode !== "off";
 
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const allToolFactoryEntries = Object.entries(allTools) as Array<[string, ToolFactory]>;
+	const allToolsByRequestName = new Map<string, [string, ToolFactory]>();
+	for (const [name, factory] of allToolFactoryEntries) {
+		allToolsByRequestName.set(name.toLowerCase(), [name, factory]);
+	}
 	const isToolAllowed = (name: string) => {
 		if (name === "goal") return goalEnabled && session.getGoalRuntime !== undefined;
 		if (goalStateToolNames.includes(name as (typeof GOAL_MODE_TOOL_NAMES)[number])) return goalEnabled;
@@ -509,10 +524,13 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		requestedTools.push("yield");
 	}
 
-	const filteredRequestedTools = requestedTools?.filter(name => name in allTools && isToolAllowed(name));
+	const filteredRequestedTools = requestedTools
+		?.map(name => allToolsByRequestName.get(name))
+		.filter((entry): entry is [string, ToolFactory] => entry !== undefined)
+		.filter(([name]) => isToolAllowed(name));
 	const baseEntries =
 		filteredRequestedTools !== undefined
-			? filteredRequestedTools.filter(name => name !== "resolve").map(name => [name, allTools[name]] as const)
+			? filteredRequestedTools.filter(([name]) => name !== "resolve")
 			: [
 					...Object.entries(BUILTIN_TOOLS)
 						.filter(([name]) => isToolAllowed(name))

package/src/tools/monitor.ts

@@ -0,0 +1,136 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import { logger, prompt } from "@gajae-code/utils";
+import * as z from "zod/v4";
+import { AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
+import monitorDescription from "../prompts/tools/monitor.md" with { type: "text" };
+import { BashTool } from "./bash";
+import type { ToolSession } from "./index";
+import { ToolError } from "./tool-errors";
+
+const monitorKindEnum = z.enum(["log", "poll", "watch", "other"]);
+
+const monitorSchema = z.object({
+	command: z
+		.string()
+		.describe(
+			"Shell command to run as a background monitor. Each stdout line is delivered as a separate task-notification event.",
+		),
+	kind: monitorKindEnum.describe(
+		"Category of monitor. 'log' tails a log file, 'poll' polls a status endpoint, 'watch' watches a directory, 'other' for arbitrary streams.",
+	),
+	description: z
+		.string()
+		.describe("Short human-readable description of what is being monitored. Appears in task listings."),
+	timeout: z
+		.number()
+		.min(1)
+		.optional()
+		.describe(
+			"Optional maximum wall-clock seconds the monitor may run before automatic shutdown. Omit for indefinite (subject to session lifetime).",
+		),
+	persistent: z
+		.boolean()
+		.optional()
+		.describe(
+			"Whether to keep the monitor running past the originating turn. Persistent monitors survive until session end or explicit kill via the background-task stop tool.",
+		),
+});
+
+export type MonitorParams = z.infer<typeof monitorSchema>;
+
+export interface MonitorToolDetails {
+	taskId: string;
+	kind: z.infer<typeof monitorKindEnum>;
+	description: string;
+	command: string;
+	persistent: boolean;
+}
+
+const MONITOR_LABEL_MAX = 120;
+
+function buildMonitorLabel(params: MonitorParams): string {
+	const base = `[monitor:${params.kind}] ${params.description}`;
+	if (base.length <= MONITOR_LABEL_MAX) return base;
+	return `${base.slice(0, MONITOR_LABEL_MAX - 3)}...`;
+}
+
+export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolDetails> {
+	readonly name = "monitor";
+	readonly label = "Monitor";
+	readonly summary = "Start a background monitor that streams stdout lines as task notifications";
+	readonly description: string;
+	readonly parameters = monitorSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+
+	constructor(private readonly session: ToolSession) {
+		this.description = prompt.render(monitorDescription);
+	}
+
+	static createIf(session: ToolSession): MonitorTool | null {
+		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
+		return new MonitorTool(session);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: MonitorParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<MonitorToolDetails>,
+		context?: AgentToolContext,
+	): Promise<AgentToolResult<MonitorToolDetails>> {
+		const manager = AsyncJobManager.instance();
+		if (!manager) {
+			throw new ToolError("Async execution is disabled; the monitor tool is unavailable in this session.");
+		}
+
+		const persistent = params.persistent ?? false;
+		const label = buildMonitorLabel(params);
+		const ownerId = this.session.getAgentId?.() ?? undefined;
+		const bash = new BashTool(this.session);
+		let deliveredFirstLine = false;
+		const monitorJob = await bash.startMonitorJob(
+			{ command: params.command, timeout: params.timeout },
+			{
+				ownerId,
+				label,
+				ctx: context,
+				onRawLine: (line, jobId) => {
+					if (!persistent && deliveredFirstLine) return;
+					deliveredFirstLine = true;
+					const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted:\n${line}\n</task-notification>`;
+					const details = { taskId: jobId, kind: params.kind, description: params.description };
+					const sendPromise = this.session.sendCustomMessage?.(
+						{ customType: "task-notification", content, display: false, attribution: "agent", details },
+						{ triggerTurn: true, deliverAs: "followUp" },
+					);
+					if (sendPromise) {
+						void sendPromise.catch(error => {
+							logger.warn("Monitor task-notification delivery failed", {
+								error: error instanceof Error ? error.message : String(error),
+							});
+						});
+					} else {
+						this.session.steer?.({ customType: "task-notification", content, details });
+					}
+					if (!persistent) {
+						manager.cancel(jobId, ownerId ? { ownerId } : undefined);
+					}
+				},
+			},
+		);
+
+		const startedText = `Monitor started · task ${monitorJob.jobId} · persistent: ${persistent}`;
+
+		return {
+			content: [{ type: "text", text: startedText }],
+			details: {
+				taskId: monitorJob.jobId,
+				kind: params.kind,
+				description: params.description,
+				command: params.command,
+				persistent,
+			},
+		};
+	}
+}

package/src/vim/engine.ts

@@ -858,7 +858,7 @@ export class VimEngine {
 			}
 			case "r": {
 				const replacement = tokens[nextIndex + 1];
-				if (!replacement || replacement.value.length !== 1) {
+				if (replacement?.value.length !== 1) {
 					throw new VimError("Visual replace requires a literal character", opToken);
 				}
 				const visual = expandVisualOffsets(
@@ -1109,7 +1109,7 @@ export class VimEngine {
 				return nextIndex + 1;
 			case "r": {
 				const replacement = tokens[nextIndex + 1];
-				if (!replacement || replacement.value.length !== 1) {
+				if (replacement?.value.length !== 1) {
 					throw new VimError("r requires a replacement character", token);
 				}
 				await this.#applyAtomicChange(["r", replacement.value], () => {
@@ -1746,7 +1746,7 @@ export class VimEngine {
 			case "t":
 			case "T": {
 				const searchToken = tokens[index + 1];
-				if (!searchToken || searchToken.value.length !== 1) {
+				if (searchToken?.value.length !== 1) {
 					throw new VimError(`${token.value} requires a literal character`, token);
 				}
 				this.lastCharFind = { char: searchToken.value, mode: token.value as "f" | "F" | "t" | "T" };

package/src/web/search/index.ts

@@ -8,6 +8,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { AuthStorage } from "@gajae-code/ai";
 import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import { parseModelString } from "../../config/model-resolver";
 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" };
@@ -16,7 +17,7 @@ import { discoverAuthStorage } from "../../sdk";
 import type { ToolSession } from "../../tools";
 import { formatAge } from "../../tools/render-utils";
 import { throwIfAborted } from "../../tools/tool-errors";
-import { getSearchProvider, getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
+import { getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
 import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
 import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
@@ -115,10 +116,21 @@ function formatForLLM(response: SearchResponse): string {
 	return parts.join("\n");
 }
 
+/** Best-effort active model provider: prefer the resolved Model, fall back to parsing the model string. */
+function resolveActiveModelProvider(
+	modelProvider: string | undefined,
+	modelString: string | undefined,
+): string | undefined {
+	if (modelProvider) return modelProvider;
+	if (modelString) return parseModelString(modelString)?.provider;
+	return undefined;
+}
+
 interface ExecuteSearchOptions {
 	authStorage: AuthStorage;
 	sessionId?: string;
 	signal?: AbortSignal;
+	activeModelProvider?: string;
 }
 
 /** Execute web search */
@@ -127,20 +139,11 @@ async function executeSearch(
 	params: SearchQueryParams,
 	options: ExecuteSearchOptions,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
-	const { authStorage, sessionId, signal } = options;
-	const providers =
-		params.provider && params.provider !== "auto"
-			? await getSearchProvider(params.provider).then(async provider =>
-					(await provider.isAvailable(authStorage)) ? [provider] : resolveProviderChain(authStorage, "auto"),
-				)
-			: await resolveProviderChain(authStorage);
-	if (providers.length === 0) {
-		const message = "No web search provider configured.";
-		return {
-			content: [{ type: "text" as const, text: `Error: ${message}` }],
-			details: { response: { provider: "none", sources: [] }, error: message },
-		};
-	}
+	const { authStorage, sessionId, signal, activeModelProvider } = options;
+	// Pass `params.provider` straight through: when omitted (the normal model-facing
+	// path) it is `undefined`, so `resolveProviderChain` applies the settings-configured
+	// preferred provider. Coalescing to "auto" here would silently bypass that preference.
+	const providers = await resolveProviderChain(authStorage, params.provider, activeModelProvider);
 
 	const failures: Array<{ provider: SearchProvider; error: unknown }> = [];
 	let lastProvider = providers[0];
@@ -207,13 +210,14 @@ async function executeSearch(
  */
 export async function runSearchQuery(
 	params: SearchQueryParams,
-	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal } = {},
+	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal; activeModelProvider?: string } = {},
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
 	const authStorage = options.authStorage ?? (await discoverAuthStorage());
 	return executeSearch("cli-web-search", params, {
 		authStorage,
 		sessionId: options.sessionId,
 		signal: options.signal,
+		activeModelProvider: options.activeModelProvider,
 	});
 }
 
@@ -247,7 +251,11 @@ export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRe
 	): Promise<AgentToolResult<SearchRenderDetails>> {
 		const authStorage = this.#session.authStorage ?? (await discoverAuthStorage());
 		const sessionId = this.#session.getSessionId?.() ?? undefined;
-		return executeSearch(_toolCallId, params, { authStorage, sessionId, signal });
+		const activeModelProvider = resolveActiveModelProvider(
+			this.#session.model?.provider,
+			this.#session.getActiveModelString?.(),
+		);
+		return executeSearch(_toolCallId, params, { authStorage, sessionId, signal, activeModelProvider });
 	}
 }
 
@@ -267,7 +275,12 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRende
 	) {
 		const authStorage = ctx.modelRegistry?.authStorage ?? (await discoverAuthStorage());
 		const sessionId = ctx.sessionManager.getSessionId();
-		return executeSearch(toolCallId, params, { authStorage, sessionId, signal });
+		return executeSearch(toolCallId, params, {
+			authStorage,
+			sessionId,
+			signal,
+			activeModelProvider: ctx.model?.provider,
+		});
 	},
 
 	renderCall(args: SearchToolParams, options: RenderResultOptions, theme: Theme) {

package/src/web/search/provider.ts

@@ -93,6 +93,11 @@ const PROVIDER_META: Record<SearchProviderId, ProviderMeta> = {
 		label: "SearXNG",
 		load: async () => new (await import("./providers/searxng")).SearXNGProvider(),
 	},
+	duckduckgo: {
+		id: "duckduckgo",
+		label: "DuckDuckGo",
+		load: async () => new (await import("./providers/duckduckgo")).DuckDuckGoProvider(),
+	},
 };
 
 const instanceCache = new Map<SearchProviderId, SearchProvider>();
@@ -119,6 +124,7 @@ export async function getSearchProvider(id: SearchProviderId): Promise<SearchPro
 }
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
+	"duckduckgo",
 	"tavily",
 	"perplexity",
 	"brave",
@@ -135,6 +141,30 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"searxng",
 ];
 
+/**
+ * Map an active model's provider string to its own native web-search provider.
+ * Keys are real model provider ids (see packages/ai/src/types.ts KnownProvider);
+ * a few aliases (gemini/kimi) and API strings (openai-responses) are tolerated
+ * defensively. Providers absent from this map (custom/unknown) fall through to
+ * DuckDuckGo.
+ */
+const MODEL_PROVIDER_TO_SEARCH: Record<string, SearchProviderId> = {
+	openai: "codex",
+	"openai-codex": "codex",
+	"openai-responses": "codex",
+	anthropic: "anthropic",
+	google: "gemini",
+	"google-gemini-cli": "gemini",
+	"google-antigravity": "gemini",
+	gemini: "gemini",
+	moonshot: "kimi",
+	"kimi-code": "kimi",
+	kimi: "kimi",
+	zai: "zai",
+	perplexity: "perplexity",
+	synthetic: "synthetic",
+};
+
 /** Preferred provider set via settings (default: auto) */
 let preferredProvId: SearchProviderId | "auto" = "auto";
 
@@ -144,30 +174,45 @@ export function setPreferredSearchProvider(provider: SearchProviderId | "auto"):
 }
 
 /**
- * Determine which providers are configured and currently available.
- * Each candidate is loaded (and its `isAvailable()` called) only as the chain
- * is walked, so unconfigured providers never pay the load cost.
+ * Resolve the ordered provider chain for a search request.
+ *
+ * Resolution is active-model-gated, never credential-scanning:
+ *   1. An explicitly preferred provider (settings) that is available is primary.
+ *   2. Otherwise the active model's own native search is primary, but only when
+ *      that provider's own credentials are present (its `isAvailable()`).
+ *   3. DuckDuckGo (keyless) is always appended as the terminal fallback, so a
+ *      missing primary — or a primary runtime failure — still returns results
+ *      with zero configuration. Keyed standalone providers are never
+ *      auto-selected; they are reachable only via explicit selection (step 1).
  */
 export async function resolveProviderChain(
 	authStorage: AuthStorage,
 	preferredProvider: SearchProviderId | "auto" = preferredProvId,
+	activeModelProvider?: string,
 ): Promise<SearchProvider[]> {
-	const providers: SearchProvider[] = [];
+	const chain: SearchProviderId[] = [];
 
 	if (preferredProvider !== "auto") {
 		const provider = await getSearchProvider(preferredProvider);
 		if (await provider.isAvailable(authStorage)) {
-			providers.push(provider);
+			chain.push(preferredProvider);
 		}
-	}
-
-	for (const id of SEARCH_PROVIDER_ORDER) {
-		if (id === preferredProvider) continue;
-		const provider = await getSearchProvider(id);
-		if (await provider.isAvailable(authStorage)) {
-			providers.push(provider);
+	} else if (activeModelProvider) {
+		const nativeId = MODEL_PROVIDER_TO_SEARCH[activeModelProvider.toLowerCase()];
+		if (nativeId) {
+			const provider = await getSearchProvider(nativeId);
+			if (await provider.isAvailable(authStorage)) {
+				chain.push(nativeId);
+			}
 		}
 	}
 
+	// DuckDuckGo is the permissionless terminal fallback (deduped).
+	if (!chain.includes("duckduckgo")) chain.push("duckduckgo");
+
+	const providers: SearchProvider[] = [];
+	for (const id of chain) {
+		providers.push(await getSearchProvider(id));
+	}
 	return providers;
 }