@ottocode/sdk 0.1.286 → 0.1.288

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.286",
+	"version": "0.1.288",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/core/src/index.ts

@@ -52,6 +52,11 @@ export type {
 export { buildFsTools } from './tools/builtin/fs/index';
 export { buildGitTools } from './tools/builtin/git';
 export { buildTerminalTool } from './tools/builtin/terminal';
+export {
+	buildLazyToolsRecord,
+	buildLoadFirstPartyToolsTool,
+	buildSimulatorTool,
+} from './tools/lazy/index';
 
 // =======================
 // Terminals

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

@@ -1,11 +1,9 @@
 import type { Tool } from 'ai';
 import { buildEditTool } from './edit.ts';
 import { buildReadTool } from './read.ts';
-import { buildReadImageTool } from './read-image.ts';
 import { buildMultiEditTool } from './multiedit.ts';
 import { buildWriteTool } from './write.ts';
 import { buildCopyIntoTool } from './copy-into.ts';
-import { buildCopyAttachmentTool } from './copy-attachment.ts';
 import { buildLsTool } from './ls.ts';
 import { buildTreeTool } from './tree.ts';
 import { buildPwdTool } from './pwd.ts';
@@ -16,12 +14,10 @@ export function buildFsTools(
 ): Array<{ name: string; tool: Tool }> {
 	const out: Array<{ name: string; tool: Tool }> = [];
 	out.push(buildReadTool(projectRoot));
-	out.push(buildReadImageTool(projectRoot));
 	out.push(buildEditTool(projectRoot));
 	out.push(buildMultiEditTool(projectRoot));
 	out.push(buildWriteTool(projectRoot));
 	out.push(buildCopyIntoTool(projectRoot));
-	out.push(buildCopyAttachmentTool(projectRoot));
 	out.push(buildLsTool(projectRoot));
 	out.push(buildTreeTool(projectRoot));
 	out.push(buildPwdTool());

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

@@ -58,6 +58,17 @@ new block after line 200
 Line-number mode is concise but fragile if the file changes after you read it.
 Prefer text/context patches for small edits.
 
+When deleting a contiguous block larger than 10 lines, prefer line-number deletion:
+
+```text
+*** Begin Patch
+*** Delete Lines in: path/to/file.ts
+*** Lines: start-end
+*** End Patch
+```
+
+Do not reproduce the whole deleted block unless line numbers are unavailable or uncertain.
+
 ---
 
 ## Standard mode: Add / Update / Delete

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

@@ -0,0 +1,12 @@
+export {
+	buildLazyToolCatalogDescription,
+	buildLoadToolsTool,
+	type LazyToolBrief,
+} from './load-tools.ts';
+export {
+	buildLazyToolsRecord,
+	buildLoadFirstPartyToolsTool,
+	getLazyToolDefinitions,
+	type LazyToolDefinition,
+} from './registry.ts';
+export { buildSimulatorTool } from './simulator.ts';

package/src/core/src/tools/lazy/load-tools.ts

@@ -0,0 +1,56 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+
+export type LazyToolBrief = {
+	name: string;
+	description: string;
+};
+
+export function buildLazyToolCatalogDescription(
+	briefs: LazyToolBrief[],
+): string {
+	if (briefs.length === 0) return 'No lazy tools available.';
+	return briefs
+		.map((brief) => `- ${brief.name}: ${brief.description.slice(0, 180)}`)
+		.join('\n');
+}
+
+export function buildLoadToolsTool(briefs: LazyToolBrief[]): {
+	name: string;
+	tool: Tool;
+} {
+	const catalog = buildLazyToolCatalogDescription(briefs);
+	const validNames = new Set(briefs.map((brief) => brief.name));
+
+	return {
+		name: 'load_tools',
+		tool: tool({
+			description: `Load first-party tools by name so they become available for use in the next step. Call this before using a listed tool.\n\nAvailable tools:\n${catalog}`,
+			inputSchema: z.object({
+				tools: z
+					.array(z.string())
+					.describe('Array of first-party tool names to load.'),
+			}),
+			execute: async ({ tools: requested }) => {
+				const loaded: string[] = [];
+				const notFound: string[] = [];
+				for (const name of requested) {
+					if (validNames.has(name)) {
+						loaded.push(name);
+					} else {
+						notFound.push(name);
+					}
+				}
+				return {
+					ok: true,
+					loaded,
+					...(notFound.length > 0 ? { notFound } : {}),
+					message:
+						loaded.length > 0
+							? `Loaded ${loaded.length} tool(s). They are now available for use.`
+							: 'No valid tools to load.',
+				};
+			},
+		}),
+	};
+}

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

@@ -0,0 +1,51 @@
+import type { Tool } from 'ai';
+import { buildCopyAttachmentTool } from '../builtin/fs/copy-attachment.ts';
+import { buildReadImageTool } from '../builtin/fs/read-image.ts';
+import { buildSimulatorTool } from './simulator.ts';
+import { buildLoadToolsTool, type LazyToolBrief } from './load-tools.ts';
+
+export type LazyToolDefinition = LazyToolBrief & {
+	build: (projectRoot: string) => { name: string; tool: Tool };
+};
+
+export function getLazyToolDefinitions(): LazyToolDefinition[] {
+	return [
+		{
+			name: 'simulator',
+			description:
+				'Control Apple Simulator via serve-sim: start, status, click, type, button, rotate, screenshot, accessibility tree, foreground app, logs, stop.',
+			build: buildSimulatorTool,
+		},
+		{
+			name: 'read_image',
+			description:
+				'Read and inspect a local image file such as a screenshot, icon, or diagram.',
+			build: buildReadImageTool,
+		},
+		{
+			name: 'copy_attachment_to_project',
+			description:
+				'Copy an original uploaded chat attachment into the project without recompression.',
+			build: buildCopyAttachmentTool,
+		},
+	];
+}
+
+export function buildLazyToolsRecord(
+	projectRoot: string,
+): Record<string, Tool> {
+	const record: Record<string, Tool> = {};
+	for (const definition of getLazyToolDefinitions()) {
+		const built = definition.build(projectRoot);
+		record[built.name] = built.tool;
+	}
+	return record;
+}
+
+export function buildLoadFirstPartyToolsTool(): { name: string; tool: Tool } {
+	const briefs = getLazyToolDefinitions().map(({ name, description }) => ({
+		name,
+		description,
+	}));
+	return buildLoadToolsTool(briefs);
+}