@ottocode/sdk 0.1.298 → 0.1.300

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.298",
+	"version": "0.1.300",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -102,7 +102,7 @@
 		"@modelcontextprotocol/sdk": "^1.12",
 		"@openauthjs/openauth": "^0.4.3",
 		"@openrouter/ai-sdk-provider": "^1.2.0",
-		"@ottorouter/ai-sdk": "0.2.5",
+		"@ottorouter/ai-sdk": "0.2.6",
 		"@solana/web3.js": "^1.98.0",
 		"ai": "^6.0.170",
 		"ai-sdk-ollama": "^3.8.3",

package/src/core/src/index.ts

@@ -56,6 +56,7 @@ export {
 	buildLazyToolsRecord,
 	buildLoadFirstPartyToolsTool,
 	buildSimulatorTool,
+	getLazyToolDefinitions,
 } from './tools/lazy/index';
 
 // =======================

package/src/core/src/providers/resolver.ts

@@ -13,6 +13,7 @@ import {
 	createXaiModel,
 	createZaiCodingModel,
 	createZaiModel,
+	isXaiGrokCliModel,
 	normalizeOllamaBaseURL,
 	resolveOpenAIResponsesModel,
 	shouldUseOpenAIResponsesApi,
@@ -195,10 +196,14 @@ export async function resolveModel(
 	}
 
 	if (provider === 'xai') {
+		if (isXaiGrokCliModel(model) && !config.oauth) {
+			throw new Error('Grok Build and Grok Composer 2.5 require xAI OAuth.');
+		}
 		return createXaiModel(model, {
 			apiKey: config.oauth?.access ?? config.apiKey,
 			baseURL: config.baseURL,
 			useResponses: !!config.oauth,
+			useGrokCliProxy: !!config.oauth && isXaiGrokCliModel(model),
 		});
 	}
 

package/src/core/src/tools/builtin/fs/read.ts

@@ -81,15 +81,25 @@ export function buildReadTool(projectRoot: string): {
 				.describe(
 					'Ending line number (1-indexed, inclusive). Required if startLine is provided.',
 				),
+			maxLines: z
+				.number()
+				.int()
+				.min(1)
+				.optional()
+				.describe(
+					'Number of lines to read starting at startLine. Ignored when endLine is provided.',
+				),
 		}),
 		async execute({
 			path,
 			startLine,
 			endLine,
+			maxLines,
 		}: {
 			path: string;
 			startLine?: number;
 			endLine?: number;
+			maxLines?: number;
 		}): Promise<ToolResponse<ReadResult>> {
 			if (!path || path.trim().length === 0) {
 				return createToolError(
@@ -111,10 +121,12 @@ export function buildReadTool(projectRoot: string): {
 				const indent = detectIndentation(content);
 				await rememberFileRead(projectRoot, abs);
 
-				if (startLine !== undefined && endLine !== undefined) {
+				if (startLine !== undefined) {
 					const lines = content.split('\n');
+					const requestedEndLine =
+						endLine ?? startLine + Math.max(1, maxLines ?? 1) - 1;
 					const start = Math.max(1, startLine) - 1;
-					const end = Math.min(lines.length, endLine);
+					const end = Math.min(lines.length, requestedEndLine);
 					const selectedLines = lines.slice(start, end);
 					content = selectedLines.join('\n');
 					const result: ReadResult = {
@@ -122,7 +134,7 @@ export function buildReadTool(projectRoot: string): {
 						path: req,
 						content,
 						size: content.length,
-						lineRange: `@${startLine}-${endLine}`,
+						lineRange: `@${startLine}-${requestedEndLine}`,
 						totalLines: lines.length,
 					};
 					if (indent) result.indentation = indent;

package/src/core/src/tools/builtin/fs/read.txt

@@ -6,3 +6,5 @@
 Usage tips:
 - Prefer relative project paths when possible (more portable)
 - For large files or searches, use the Grep or Ripgrep tool
+- Use startLine/endLine or startLine/maxLines for targeted reads of large files
+- If startLine is provided without endLine or maxLines, only that one line is read

package/src/core/src/tools/builtin/patch/repair.ts

@@ -1,4 +1,15 @@
-import { PATCH_BEGIN_MARKER, PATCH_END_MARKER } from './constants.ts';
+import {
+	PATCH_ADD_PREFIX,
+	PATCH_BEGIN_MARKER,
+	PATCH_DELETE_LINES_PREFIX,
+	PATCH_DELETE_PREFIX,
+	PATCH_END_MARKER,
+	PATCH_INSERT_AFTER_PREFIX,
+	PATCH_INSERT_BEFORE_PREFIX,
+	PATCH_REPLACE_LINES_PREFIX,
+	PATCH_REPLACE_PREFIX,
+	PATCH_UPDATE_PREFIX,
+} from './constants.ts';
 
 export function repairPatchContent(patch: string): string {
 	patch = extractPatchFromWrappedJson(patch);
@@ -35,12 +46,16 @@ function appendMissingEndMarker(patch: string): string {
 	if (trimmed.includes(PATCH_END_MARKER)) return patch;
 
 	const hasContent =
-		trimmed.includes('*** Update File:') ||
-		trimmed.includes('*** Add File:') ||
-		trimmed.includes('*** Delete File:') ||
-		trimmed.includes('*** Replace in:');
-
-	if (hasContent) {
+		trimmed.includes(PATCH_UPDATE_PREFIX) ||
+		trimmed.includes(PATCH_ADD_PREFIX) ||
+		trimmed.includes(PATCH_DELETE_PREFIX) ||
+		trimmed.includes(PATCH_REPLACE_PREFIX) ||
+		trimmed.includes(PATCH_DELETE_LINES_PREFIX) ||
+		trimmed.includes(PATCH_REPLACE_LINES_PREFIX) ||
+		trimmed.includes(PATCH_INSERT_BEFORE_PREFIX) ||
+		trimmed.includes(PATCH_INSERT_AFTER_PREFIX);
+
+	if (hasContent || trimmed.trim() === PATCH_BEGIN_MARKER) {
 		return `${trimmed}\n${PATCH_END_MARKER}`;
 	}
 

package/src/core/src/tools/builtin/patch.ts

@@ -110,11 +110,24 @@ export function buildApplyPatchTool(projectRoot: string): {
 				const message = error instanceof Error ? error.message : String(error);
 				return createToolError(message, 'validation', {
 					parameter: 'patch',
-					suggestion:
-						'Provide patch content using the enveloped format (*** Begin Patch ... *** End Patch) or standard unified diff format (---/+++ headers).',
+					suggestion: message.includes('Missing "*** End Patch"')
+						? 'The patch tool automatically appends a missing end marker when real patch operations are present. This input appears incomplete; resend the full patch body, not just the begin marker.'
+						: 'Provide patch content using the enveloped format (*** Begin Patch ... *** End Patch) or standard unified diff format (---/+++ headers).',
 				});
 			}
 
+			if (operations.length === 0) {
+				return createToolError(
+					'Patch contains no operations. Do not retry the same empty patch; include at least one Add/Update/Delete/Replace directive between the begin and end markers.',
+					'validation',
+					{
+						parameter: 'patch',
+						suggestion:
+							'Provide a complete patch body such as *** Replace in: path, *** Find:, *** With:, then *** End Patch.',
+					},
+				);
+			}
+
 			try {
 				const result = await applyPatchOperations(projectRoot, operations, {
 					useFuzzy: fuzzyMatch,

package/src/core/src/tools/builtin/ripgrep.ts

@@ -42,6 +42,9 @@ export function buildRipgrepTool(projectRoot: string): {
 			ToolResponse<{
 				count: number;
 				matches: Array<{ file: string; line: number; text: string }>;
+				truncated?: boolean;
+				shownMatches?: number;
+				files?: Array<{ file: string; matches: number }>;
 			}>
 		> {
 			function expandTilde(p: string) {
@@ -54,7 +57,14 @@ export function buildRipgrepTool(projectRoot: string): {
 			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'];
+			const args = [
+				'--no-heading',
+				'--line-number',
+				'--color=never',
+				'--max-columns',
+				'240',
+				'--max-columns-preview',
+			];
 			if (ignoreCase) args.push('-i');
 			if (Array.isArray(glob)) for (const g of glob) args.push('-g', g);
 			args.push('--max-count', String(maxResults));
@@ -65,11 +75,72 @@ export function buildRipgrepTool(projectRoot: string): {
 				const rgBin = await resolveBinary('rg');
 				return await new Promise((resolve) => {
 					const proc = spawn(rgBin, args, { cwd: projectRoot });
-					let stdout = '';
 					let stderr = '';
+					let pendingLine = '';
+					let truncated = false;
+					let settled = false;
+					const TEXT_MAX = 200;
+					const matches: Array<{ file: string; line: number; text: string }> =
+						[];
+					const fileCounts = new Map<string, number>();
+
+					const parseLine = (lineText: string) => {
+						if (!lineText || matches.length >= maxResults) return;
+						const m = lineText.match(/^(.+?):(\d+):(.*)$/s);
+						const match = (() => {
+							if (!m) {
+								return {
+									file: '',
+									line: 0,
+									text:
+										lineText.length > TEXT_MAX
+											? `${lineText.slice(0, TEXT_MAX)}…`
+											: lineText,
+								};
+							}
+							const file = m[1];
+							const line = Number.parseInt(m[2], 10);
+							const raw = m[3];
+							const text =
+								raw.length > TEXT_MAX ? `${raw.slice(0, TEXT_MAX)}…` : raw;
+							return { file, line, text };
+						})();
+						matches.push(match);
+						if (match.file) {
+							fileCounts.set(match.file, (fileCounts.get(match.file) ?? 0) + 1);
+						}
+						if (matches.length >= maxResults) {
+							truncated = true;
+							proc.kill('SIGTERM');
+						}
+					};
+
+					const resolveSuccess = () => {
+						if (settled) return;
+						settled = true;
+						const files = Array.from(fileCounts.entries()).map(
+							([file, count]) => ({ file, matches: count }),
+						);
+						resolve({
+							ok: true,
+							count: matches.length,
+							matches,
+							...(truncated
+								? { truncated: true, shownMatches: matches.length }
+								: {}),
+							...(files.length ? { files } : {}),
+						});
+					};
 
 					proc.stdout.on('data', (data) => {
-						stdout += data.toString();
+						if (matches.length >= maxResults) return;
+						pendingLine += data.toString();
+						const lines = pendingLine.split('\n');
+						pendingLine = lines.pop() ?? '';
+						for (const line of lines) {
+							parseLine(line);
+							if (matches.length >= maxResults) break;
+						}
 					});
 
 					proc.stderr.on('data', (data) => {
@@ -77,7 +148,9 @@ export function buildRipgrepTool(projectRoot: string): {
 					});
 
 					proc.on('close', (code) => {
-						if (code !== 0 && code !== 1) {
+						if (pendingLine && matches.length < maxResults)
+							parseLine(pendingLine);
+						if (!truncated && code !== 0 && code !== 1) {
 							resolve(
 								createToolError(
 									stderr.trim() || 'ripgrep failed',
@@ -91,30 +164,12 @@ export function buildRipgrepTool(projectRoot: string): {
 							return;
 						}
 
-						const lines = stdout
-							.split('\n')
-							.filter(Boolean)
-							.slice(0, maxResults);
-						const TEXT_MAX = 200;
-						const matches = lines.map((l) => {
-							const m = l.match(/^(.+?):(\d+):(.*)$/s);
-							if (!m)
-								return {
-									file: '',
-									line: 0,
-									text: l.length > TEXT_MAX ? `${l.slice(0, TEXT_MAX)}…` : l,
-								};
-							const file = m[1];
-							const line = Number.parseInt(m[2], 10);
-							const raw = m[3];
-							const text =
-								raw.length > TEXT_MAX ? `${raw.slice(0, TEXT_MAX)}…` : raw;
-							return { file, line, text };
-						});
-						resolve({ ok: true, count: matches.length, matches });
+						resolveSuccess();
 					});
 
 					proc.on('error', (err) => {
+						if (settled) return;
+						settled = true;
 						resolve(
 							createToolError(String(err), 'execution', {
 								suggestion: 'Ensure ripgrep (rg) is installed',

package/src/core/src/tools/builtin/ripgrep.txt

@@ -8,5 +8,7 @@ This is the only content-search tool available. Use it for any text search acros
 ## Usage tips
 
 - Narrow the search set with `glob` first if the pattern may match too broadly.
+- Prefer narrow `path` and `glob` values over repo-wide searches.
+- Keep `maxResults` low for broad searches; the tool stops after the global limit.
 - Batch independent searches (e.g. multiple function names) in a single turn for parallel execution.
 - Use `ignoreCase: true` for case-insensitive matching; pass `glob` patterns (e.g. `["*.ts"]`) to limit file types.

package/src/core/src/tools/builtin/shell.ts

@@ -42,9 +42,44 @@ function killProcessTree(pid: number) {
 	}
 }
 
-export type ShellOutputMode = 'full' | 'tail';
+export type ShellOutputMode = 'auto' | 'full' | 'tail';
 
 const DEFAULT_TAIL_LINES = 100;
+const DEFAULT_MAX_OUTPUT_BYTES = 128_000;
+
+type CompactTextResult = {
+	text: string;
+	truncated: boolean;
+	originalBytes: number;
+	shownBytes: number;
+};
+
+function compactTextByBytes(
+	text: string,
+	maxBytes: number,
+	label: string,
+): CompactTextResult {
+	const originalBytes = Buffer.byteLength(text, 'utf8');
+	if (maxBytes <= 0 || originalBytes <= maxBytes) {
+		return { text, truncated: false, originalBytes, shownBytes: originalBytes };
+	}
+
+	const marker = `\n… omitted ${originalBytes - maxBytes} bytes from ${label} …\n`;
+	const markerBytes = Buffer.byteLength(marker, 'utf8');
+	const budget = Math.max(0, maxBytes - markerBytes);
+	const headBytes = Math.floor(budget / 2);
+	const tailBytes = budget - headBytes;
+	const buffer = Buffer.from(text, 'utf8');
+	const compacted = `${buffer.subarray(0, headBytes).toString('utf8')}${marker}${buffer
+		.subarray(buffer.byteLength - tailBytes)
+		.toString('utf8')}`;
+	return {
+		text: compacted,
+		truncated: true,
+		originalBytes,
+		shownBytes: Buffer.byteLength(compacted, 'utf8'),
+	};
+}
 
 export function appendTailLines(
 	current: string,
@@ -66,6 +101,13 @@ type ShellResult = ToolResponse<{
 	stderr: string;
 	outputMode?: ShellOutputMode;
 	tailLines?: number;
+	maxOutputBytes?: number;
+	stdoutTruncated?: boolean;
+	stdoutOriginalBytes?: number;
+	stdoutShownBytes?: number;
+	stderrTruncated?: boolean;
+	stderrOriginalBytes?: number;
+	stderrShownBytes?: number;
 }>;
 
 type ShellStreamChunk =
@@ -110,11 +152,11 @@ const shellInputSchema = z
 			.default(300000)
 			.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
 		outputMode: z
-			.enum(['full', 'tail'])
+			.enum(['auto', 'full', 'tail'])
 			.optional()
-			.default('full')
+			.default('auto')
 			.describe(
-				'Output capture mode. Use "full" for complete stdout/stderr, or "tail" to keep only the last tailLines lines and avoid huge tool results.',
+				'Output capture mode. Use "auto" for bounded output, "full" for full output up to maxOutputBytes, or "tail" to keep only the last tailLines lines.',
 			),
 		tailLines: z
 			.number()
@@ -126,6 +168,16 @@ const shellInputSchema = z
 			.describe(
 				'Number of trailing stdout/stderr lines to keep when outputMode is "tail"',
 			),
+		maxOutputBytes: z
+			.number()
+			.int()
+			.min(0)
+			.max(10_000_000)
+			.optional()
+			.default(DEFAULT_MAX_OUTPUT_BYTES)
+			.describe(
+				'Maximum bytes to keep per stdout/stderr in the final tool result. Use 0 to disable byte capping.',
+			),
 	})
 	.strict();
 
@@ -154,8 +206,9 @@ export function buildShellTool(projectRoot: string): {
 				cwd,
 				allowNonZeroExit,
 				timeout = 300000,
-				outputMode = 'full',
+				outputMode = 'auto',
 				tailLines = DEFAULT_TAIL_LINES,
+				maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES,
 			}: ShellInput,
 			options?: { abortSignal?: AbortSignal },
 		): AsyncIterable<ShellStreamChunk> | ShellResult {
@@ -179,6 +232,7 @@ export function buildShellTool(projectRoot: string): {
 						timeout,
 						outputMode,
 						tailLines,
+						maxOutputBytes,
 					},
 					options,
 				) as AsyncIterable<ShellStreamChunk> | ShellResult;
@@ -217,6 +271,49 @@ export function buildShellTool(projectRoot: string): {
 			const settle = (result: ShellResult) => {
 				if (settled) return;
 				settled = true;
+				if ('stdout' in result && 'stderr' in result) {
+					const stdoutCompact = compactTextByBytes(
+						result.stdout,
+						maxOutputBytes,
+						'shell stdout',
+					);
+					const stderrCompact = compactTextByBytes(
+						result.stderr,
+						maxOutputBytes,
+						'shell stderr',
+					);
+					result.stdout = stdoutCompact.text;
+					result.stderr = stderrCompact.text;
+					result.maxOutputBytes = maxOutputBytes;
+					if (stdoutCompact.truncated) {
+						result.stdoutTruncated = true;
+						result.stdoutOriginalBytes = stdoutCompact.originalBytes;
+						result.stdoutShownBytes = stdoutCompact.shownBytes;
+					}
+					if (stderrCompact.truncated) {
+						result.stderrTruncated = true;
+						result.stderrOriginalBytes = stderrCompact.originalBytes;
+						result.stderrShownBytes = stderrCompact.shownBytes;
+					}
+				} else if ('details' in result && result.details) {
+					const details = result.details;
+					for (const field of ['stdout', 'stderr'] as const) {
+						const value = details[field];
+						if (typeof value !== 'string') continue;
+						const compact = compactTextByBytes(
+							value,
+							maxOutputBytes,
+							`shell ${field}`,
+						);
+						details[field] = compact.text;
+						if (compact.truncated) {
+							details[`${field}Truncated`] = true;
+							details[`${field}OriginalBytes`] = compact.originalBytes;
+							details[`${field}ShownBytes`] = compact.shownBytes;
+						}
+					}
+					details.maxOutputBytes = maxOutputBytes;
+				}
 				if (timeoutId) clearTimeout(timeoutId);
 				if (abortSignal) {
 					abortSignal.removeEventListener('abort', onAbort);
@@ -248,7 +345,7 @@ export function buildShellTool(projectRoot: string): {
 			proc.stdout?.on('data', (chunk) => {
 				const text = chunk.toString();
 				stdout =
-					outputMode === 'tail'
+					outputMode === 'tail' || outputMode === 'auto'
 						? appendTailLines(stdout, text, tailLines)
 						: `${stdout}${text}`;
 				pushDelta(text);
@@ -257,7 +354,7 @@ export function buildShellTool(projectRoot: string): {
 			proc.stderr?.on('data', (chunk) => {
 				const text = chunk.toString();
 				stderr =
-					outputMode === 'tail'
+					outputMode === 'tail' || outputMode === 'auto'
 						? appendTailLines(stderr, text, tailLines)
 						: `${stderr}${text}`;
 				pushDelta(text);
@@ -270,7 +367,9 @@ export function buildShellTool(projectRoot: string): {
 							cmd,
 							stdout,
 							stderr,
-							...(outputMode === 'tail' ? { outputMode, tailLines } : {}),
+							...(outputMode === 'tail' || outputMode === 'auto'
+								? { outputMode, tailLines, maxOutputBytes }
+								: { outputMode, maxOutputBytes }),
 						}),
 					);
 					return;
@@ -286,7 +385,9 @@ export function buildShellTool(projectRoot: string): {
 								value: timeout,
 								stdout,
 								stderr,
-								...(outputMode === 'tail' ? { outputMode, tailLines } : {}),
+								...(outputMode === 'tail' || outputMode === 'auto'
+									? { outputMode, tailLines, maxOutputBytes }
+									: { outputMode, maxOutputBytes }),
 								suggestion: 'Increase timeout or optimize the command',
 							},
 						),
@@ -303,7 +404,9 @@ export function buildShellTool(projectRoot: string): {
 							stdout,
 							stderr,
 							cmd,
-							...(outputMode === 'tail' ? { outputMode, tailLines } : {}),
+							...(outputMode === 'tail' || outputMode === 'auto'
+								? { outputMode, tailLines, maxOutputBytes }
+								: { outputMode, maxOutputBytes }),
 							suggestion: 'Check command syntax or use allowNonZeroExit: true',
 						}),
 					);
@@ -315,7 +418,9 @@ export function buildShellTool(projectRoot: string): {
 					exitCode: exitCode ?? 0,
 					stdout,
 					stderr,
-					...(outputMode === 'tail' ? { outputMode, tailLines } : {}),
+					...(outputMode === 'tail' || outputMode === 'auto'
+						? { outputMode, tailLines, maxOutputBytes }
+						: { outputMode, maxOutputBytes }),
 				});
 			});
 

package/src/core/src/tools/builtin/shell.txt

@@ -7,8 +7,10 @@
 ## Usage tips
 
 - Chain commands with `&&` to fail-fast.
-- For long outputs, redirect to a file and `read` it back.
-- For verbose commands like builds or tests, set `outputMode: "tail"` and optionally `tailLines` to return only the last N stdout/stderr lines in the final tool result while still streaming full output to the UI. Use `outputMode: "full"` when you need complete output in the result.
+- For long outputs, redirect to a file, inspect `wc -c`, then read a small range or tail.
+- `outputMode: "auto"` is the default and keeps bounded tail output. Use `outputMode: "tail"` with `tailLines` for verbose builds/tests, or `outputMode: "full"` only when complete output is truly needed.
+- Final `stdout`/`stderr` are capped by `maxOutputBytes` per stream to avoid huge tool results. Set `maxOutputBytes: 0` only when you intentionally need uncapped output.
+- For binary, minified, or `strings` searches, cap line width explicitly, e.g. `rg -o '.{0,80}needle.{0,120}' | head -50`.
 - For long-running non-interactive commands, set an appropriate `timeout` and ensure the command exits on its own.
 - Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential shell chains when you need results separately.
 - Never use `shell` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.

package/src/core/src/tools/lazy/registry.ts

@@ -42,10 +42,16 @@ export function buildLazyToolsRecord(
 	return record;
 }
 
-export function buildLoadFirstPartyToolsTool(): { name: string; tool: Tool } {
-	const briefs = getLazyToolDefinitions().map(({ name, description }) => ({
-		name,
-		description,
-	}));
+export function buildLoadFirstPartyToolsTool(allowedNames?: Iterable<string>): {
+	name: string;
+	tool: Tool;
+} {
+	const allowed = allowedNames ? new Set(allowedNames) : null;
+	const briefs = getLazyToolDefinitions()
+		.filter(({ name }) => !allowed || allowed.has(name))
+		.map(({ name, description }) => ({
+			name,
+			description,
+		}));
 	return buildLoadToolsTool(briefs);
 }

package/src/index.ts

@@ -144,7 +144,12 @@ export {
 export type { AnthropicOAuthConfig } from './providers/src/index.ts';
 export { createGoogleModel } from './providers/src/index.ts';
 export type { GoogleProviderConfig } from './providers/src/index.ts';
-export { createXaiModel } from './providers/src/index.ts';
+export {
+	createXaiModel,
+	getGrokCliHeaders,
+	isXaiGrokCliModel,
+	XAI_GROK_CLI_MODEL_IDS,
+} from './providers/src/index.ts';
 export type { XaiProviderConfig } from './providers/src/index.ts';
 export { createZaiModel, createZaiCodingModel } from './providers/src/index.ts';
 export type { ZaiProviderConfig } from './providers/src/index.ts';
@@ -306,6 +311,7 @@ export {
 	buildLazyToolsRecord,
 	buildLoadFirstPartyToolsTool,
 	buildSimulatorTool,
+	getLazyToolDefinitions,
 } from './core/src/index.ts';
 export {
 	appendCoAuthorTrailer,