@agi-cli/sdk 0.1.49 → 0.1.51

package/src/tools/builtin/plan.ts

@@ -1,58 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import DESCRIPTION from './plan.txt' with { type: 'text' };
-
-const STATUS_ENUM = z.enum(['pending', 'in_progress', 'completed']);
-
-const ITEM_SCHEMA = z
-	.union([
-		z.string().min(1, 'Plan steps must be non-empty'),
-		z.object({
-			step: z.string().min(1, 'Plan steps must be non-empty'),
-			status: STATUS_ENUM.optional(),
-		}),
-	])
-	.describe('Plan item');
-
-type PlanItemInput = z.infer<typeof ITEM_SCHEMA>;
-
-function normalizeItems(
-	raw: PlanItemInput[],
-): Array<{ step: string; status: z.infer<typeof STATUS_ENUM> }> {
-	const normalized = raw.map((item) => {
-		if (typeof item === 'string') {
-			return { step: item.trim(), status: 'pending' as const };
-		}
-		const step = item.step.trim();
-		const status = item.status ?? 'pending';
-		return { step, status };
-	});
-
-	const filtered = normalized.filter((item) => item.step.length > 0);
-	if (!filtered.length) {
-		throw new Error('At least one plan step is required');
-	}
-
-	const inProgressCount = filtered.filter(
-		(item) => item.status === 'in_progress',
-	).length;
-	if (inProgressCount > 1) {
-		throw new Error('Only one plan step may be marked as in_progress');
-	}
-
-	return filtered;
-}
-
-export const updatePlanTool: Tool = tool({
-	description: DESCRIPTION,
-	inputSchema: z.object({
-		items: z.array(ITEM_SCHEMA).min(1).describe('Ordered list of plan steps'),
-		note: z
-			.string()
-			.optional()
-			.describe('Optional note or context for the plan update'),
-	}),
-	async execute({ items, note }: { items: PlanItemInput[]; note?: string }) {
-		return { items: normalizeItems(items), note };
-	},
-});

package/src/tools/builtin/plan.txt

@@ -1,6 +0,0 @@
-- Publish or update the current execution plan
-- Displays ordered steps and optional note/context to the user
-
-Usage tips:
-- Keep steps concise (imperative verbs) and reflect progress updates
-- Update the plan whenever scope changes or new steps emerge

package/src/tools/builtin/progress.ts

@@ -1,55 +0,0 @@
-import { tool } from 'ai';
-import { z } from 'zod';
-import DESCRIPTION from './progress.txt' with { type: 'text' };
-
-// Progress update tool: allows the model to emit lightweight status signals
-// without revealing chain-of-thought. The runner/UI should surface these
-// messages immediately.
-const StageEnum = z.enum([
-	'planning',
-	'discovering',
-	'generating',
-	'preparing',
-	'writing',
-	'verifying',
-]);
-
-export const progressUpdateTool = tool({
-	description: DESCRIPTION,
-	inputSchema: z.object({
-		message: z
-			.string()
-			.min(1)
-			.max(200)
-			.describe('Short, user-facing status message (<= 200 chars).'),
-		pct: z
-			.number()
-			.min(0)
-			.max(100)
-			.optional()
-			.describe('Optional overall progress percent 0-100.'),
-		stage: StageEnum.optional().default('planning'),
-	}),
-	async execute({
-		message,
-		pct,
-		stage,
-	}: {
-		message: string;
-		pct?: number;
-		stage?: z.infer<typeof StageEnum>;
-	}) {
-		// Keep the tool lightweight; no side effects beyond the event itself.
-		// Returning the normalized payload allows generic renderers to inspect it if needed.
-		const normalizedPct =
-			typeof pct === 'number'
-				? Math.min(100, Math.max(0, Math.round(pct)))
-				: undefined;
-		return {
-			ok: true,
-			message,
-			pct: normalizedPct,
-			stage: stage ?? 'planning',
-		} as const;
-	},
-});

package/src/tools/builtin/progress.txt

@@ -1,7 +0,0 @@
-- Emit a short, user-facing progress/status update
-- Supports optional `pct` (0–100) and `stage` indicators
-- Lightweight; intended for immediate UI display
-
-Usage tips:
-- Keep messages short (<= 200 chars) and informative
-- Use multiple updates during long-running tasks

package/src/tools/builtin/ripgrep.ts

@@ -1,71 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import { $ } from 'bun';
-import { join } from 'node:path';
-import DESCRIPTION from './ripgrep.txt' with { type: 'text' };
-
-export function buildRipgrepTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const rg = tool({
-		description: DESCRIPTION,
-		inputSchema: z.object({
-			query: z.string().min(1).describe('Search pattern (regex by default)'),
-			path: z
-				.string()
-				.optional()
-				.default('.')
-				.describe('Relative path to search in'),
-			ignoreCase: z.boolean().optional().default(false),
-			glob: z
-				.array(z.string())
-				.optional()
-				.describe('One or more glob patterns to include'),
-			maxResults: z.number().int().min(1).max(5000).optional().default(500),
-		}),
-		async execute({
-			query,
-			path = '.',
-			ignoreCase,
-			glob,
-			maxResults = 500,
-		}: {
-			query: string;
-			path?: string;
-			ignoreCase?: boolean;
-			glob?: string[];
-			maxResults?: number;
-		}) {
-			function expandTilde(p: string) {
-				const home = process.env.HOME || process.env.USERPROFILE || '';
-				if (!home) return p;
-				if (p === '~') return home;
-				if (p.startsWith('~/')) return `${home}/${p.slice(2)}`;
-				return p;
-			}
-			const p = expandTilde(String(path ?? '.')).trim();
-			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
-			const target = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
-			const args = ['--no-heading', '--line-number', '--color=never'];
-			if (ignoreCase) args.push('-i');
-			if (Array.isArray(glob)) for (const g of glob) args.push('-g', g);
-			args.push('--max-count', String(maxResults));
-			args.push(query, target);
-			try {
-				const output = await $`rg ${args}`.quiet().text();
-				const lines = output.split('\n').filter(Boolean).slice(0, maxResults);
-				const matches = lines.map((l) => {
-					const m = l.match(/^(.*?):(\d+):(.*)$/);
-					if (!m) return { file: '', line: 0, text: l };
-					return { file: m[1], line: Number(m[2]), text: m[3] };
-				});
-				return { count: matches.length, matches };
-			} catch (err) {
-				const stderr = (err as { stderr?: string })?.stderr ?? String(err);
-				return { count: 0, matches: [], error: stderr?.trim() };
-			}
-		},
-	});
-	return { name: 'ripgrep', tool: rg };
-}

package/src/tools/builtin/ripgrep.txt

@@ -1,7 +0,0 @@
-- Search files using ripgrep (rg) with regex patterns
-- Returns a flat list of matches with `file`, `line`, and `text`
-- Supports include globs and case-insensitive search
-
-Usage tips:
-- Use the Grep tool for a friendly summary grouped by file
-- Use the Glob tool first to limit the search set if needed

package/src/tools/builtin/websearch.ts

@@ -1,219 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import DESCRIPTION from './websearch.txt' with { type: 'text' };
-
-export function buildWebSearchTool(): {
-	name: string;
-	tool: Tool;
-} {
-	const websearch = tool({
-		description: DESCRIPTION,
-		inputSchema: z
-			.object({
-				url: z
-					.string()
-					.optional()
-					.describe(
-						'URL to fetch content from (mutually exclusive with query)',
-					),
-				query: z
-					.string()
-					.optional()
-					.describe(
-						'Search query to search the web (mutually exclusive with url)',
-					),
-				maxLength: z
-					.number()
-					.optional()
-					.default(50000)
-					.describe(
-						'Maximum content length to return (default: 50000 characters)',
-					),
-			})
-			.strict()
-			.refine((data) => (data.url ? !data.query : !!data.query), {
-				message: 'Must provide either url or query, but not both',
-			}),
-		async execute({
-			url,
-			query,
-			maxLength,
-		}: {
-			url?: string;
-			query?: string;
-			maxLength?: number;
-		}) {
-			const maxLen = maxLength ?? 50000;
-
-			if (url) {
-				// Fetch URL content
-				try {
-					const response = await fetch(url, {
-						headers: {
-							'User-Agent':
-								'Mozilla/5.0 (compatible; AGI-Bot/1.0; +https://github.com/anthropics/agi)',
-							Accept:
-								'text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7',
-						},
-						redirect: 'follow',
-						signal: AbortSignal.timeout(30000), // 30 second timeout
-					});
-
-					if (!response.ok) {
-						throw new Error(
-							`HTTP error! status: ${response.status} ${response.statusText}`,
-						);
-					}
-
-					const contentType = response.headers.get('content-type') || '';
-					let content = '';
-
-					if (
-						contentType.includes('text/') ||
-						contentType.includes('application/json') ||
-						contentType.includes('application/xml') ||
-						contentType.includes('application/xhtml')
-					) {
-						content = await response.text();
-					} else {
-						return {
-							error: `Unsupported content type: ${contentType}. Only text-based content can be fetched.`,
-						};
-					}
-
-					// Strip HTML tags for better readability (basic cleaning)
-					const cleanContent = content
-						.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-						.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
-						.replace(/<[^>]+>/g, ' ')
-						.replace(/\s+/g, ' ')
-						.trim();
-
-					const truncated = cleanContent.slice(0, maxLen);
-					const wasTruncated = cleanContent.length > maxLen;
-
-					return {
-						url,
-						content: truncated,
-						contentLength: cleanContent.length,
-						truncated: wasTruncated,
-						contentType,
-					};
-				} catch (error) {
-					const errorMessage =
-						error instanceof Error ? error.message : String(error);
-					return {
-						error: `Failed to fetch URL: ${errorMessage}`,
-					};
-				}
-			}
-
-			if (query) {
-				// Web search functionality
-				// Use DuckDuckGo's HTML search (doesn't require API key)
-				try {
-					const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-					const response = await fetch(searchUrl, {
-						headers: {
-							'User-Agent':
-								'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-							Accept: 'text/html',
-						},
-						redirect: 'follow',
-						signal: AbortSignal.timeout(30000),
-					});
-
-					if (!response.ok) {
-						throw new Error(`Search failed: ${response.status}`);
-					}
-
-					const html = await response.text();
-
-					// Parse DuckDuckGo results (basic parsing)
-					const results: Array<{
-						title: string;
-						url: string;
-						snippet: string;
-					}> = [];
-
-					// Match result blocks
-					const resultPattern =
-						/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
-
-					let match: RegExpExecArray | null = null;
-					match = resultPattern.exec(html);
-					while (match !== null && results.length < 10) {
-						const url = match[1]?.trim();
-						const title = match[2]?.trim();
-						let snippet = match[3]?.trim();
-
-						if (url && title) {
-							// Clean snippet
-							snippet = snippet
-								?.replace(/<[^>]+>/g, '')
-								.replace(/\s+/g, ' ')
-								.trim();
-
-							results.push({
-								title,
-								url,
-								snippet: snippet || '',
-							});
-						}
-						match = resultPattern.exec(html);
-					}
-
-					// Fallback: simpler pattern if the above doesn't work
-					if (results.length === 0) {
-						const simplePattern =
-							/<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/gi;
-						match = simplePattern.exec(html);
-						while (match !== null && results.length < 10) {
-							const url = match[1]?.trim();
-							const title = match[2]?.trim();
-							if (url && title && url.startsWith('http')) {
-								results.push({
-									title,
-									url,
-									snippet: '',
-								});
-							}
-							match = simplePattern.exec(html);
-						}
-					}
-
-					if (results.length === 0) {
-						return {
-							error:
-								'No search results found. The search service may have changed its format or blocked the request.',
-							query,
-							suggestion:
-								'Try using the url parameter to fetch a specific webpage instead.',
-						};
-					}
-
-					return {
-						query,
-						results,
-						count: results.length,
-					};
-				} catch (error) {
-					const errorMessage =
-						error instanceof Error ? error.message : String(error);
-					return {
-						error: `Search failed: ${errorMessage}`,
-						query,
-						suggestion:
-							'Search services may be temporarily unavailable. Try using the url parameter to fetch a specific webpage instead.',
-					};
-				}
-			}
-
-			return {
-				error: 'Must provide either url or query parameter',
-			};
-		},
-	});
-
-	return { name: 'websearch', tool: websearch };
-}

package/src/tools/builtin/websearch.txt

@@ -1,12 +0,0 @@
-- Search the web or fetch content from URLs
-- Use `query` to search the web and get a list of results with titles, URLs, and snippets
-- Use `url` to fetch and read the content of a specific webpage
-- Returns cleaned, text-based content (HTML tags are stripped)
-- Cannot be used for both search and URL fetch in the same call
-
-Usage tips:
-- For research: use `query` to find relevant pages, then `url` to read specific ones
-- Search returns up to 10 results with titles, URLs, and snippets
-- URL fetching works for text-based content (HTML, JSON, XML, plain text)
-- Content is automatically truncated if it exceeds maxLength (default 50,000 chars)
-- Use this to gather current information, read documentation, or verify facts