@ottocode/sdk 0.1.228 → 0.1.230

package/package.json

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

package/src/config/src/index.ts

@@ -34,6 +34,7 @@ const DEFAULTS: {
 		toolApproval: 'auto',
 		guidedMode: false,
 		reasoningText: true,
+		reasoningLevel: 'high',
 	},
 	providers: DEFAULT_PROVIDER_SETTINGS,
 };

package/src/config/src/manager.ts

@@ -66,6 +66,7 @@ export async function writeDefaults(
 		toolApproval: 'auto' | 'dangerous' | 'all';
 		guidedMode: boolean;
 		reasoningText: boolean;
+		reasoningLevel: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
 		theme: string;
 	}>,
 	projectRoot?: string,

package/src/core/src/terminals/rust-libs.ts

@@ -1,20 +1,15 @@
-// @ts-expect-error Bun file asset import
 import darwinArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.dylib' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import darwinX64 from 'bun-pty/rust-pty/target/release/librust_pty.dylib' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import linuxArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.so' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import linuxX64 from 'bun-pty/rust-pty/target/release/librust_pty.so' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import windowsDll from 'bun-pty/rust-pty/target/release/rust_pty.dll' with {
 	type: 'file',
 };

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

@@ -1,9 +1,9 @@
 import { tool, type Tool } from 'ai';
-import { z } from 'zod/v3';
 import { spawn } from 'node:child_process';
+import { z } from 'zod/v3';
 import DESCRIPTION from './bash.txt' with { type: 'text' };
-import { createToolError, type ToolResponse } from '../error.ts';
 import { getAugmentedPath } from '../bin-manager.ts';
+import { createToolError, type ToolResponse } from '../error.ts';
 import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
 
 function normalizePath(p: string) {
@@ -41,10 +41,26 @@ function killProcessTree(pid: number) {
 	}
 }
 
+type BashResult = ToolResponse<{
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}>;
+
+type BashStreamChunk =
+	| {
+			channel: 'output';
+			delta: string;
+	  }
+	| {
+			result: BashResult;
+	  };
+
 export function buildBashTool(projectRoot: string): {
 	name: string;
 	tool: Tool;
 } {
+	// biome-ignore lint/suspicious/noExplicitAny: AI SDK tool typings do not model async-iterable execute results yet.
 	const bash = tool({
 		description: DESCRIPTION,
 		inputSchema: z
@@ -66,7 +82,7 @@ export function buildBashTool(projectRoot: string): {
 					.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
 			})
 			.strict(),
-		async execute(
+		execute(
 			{
 				cmd,
 				cwd,
@@ -79,13 +95,7 @@ export function buildBashTool(projectRoot: string): {
 				timeout?: number;
 			},
 			options?: { abortSignal?: AbortSignal },
-		): Promise<
-			ToolResponse<{
-				exitCode: number;
-				stdout: string;
-				stderr: string;
-			}>
-		> {
+		): AsyncIterable<BashStreamChunk> | BashResult {
 			const abortSignal = options?.abortSignal;
 
 			if (abortSignal?.aborted) {
@@ -95,126 +105,162 @@ export function buildBashTool(projectRoot: string): {
 			}
 
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
-
 			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
 
-			return new Promise((resolve) => {
-				const proc = spawn(finalCmd, {
-					cwd: absCwd,
-					shell: true,
-					stdio: ['ignore', 'pipe', 'pipe'],
-					env: { ...process.env, PATH: getAugmentedPath() },
-					detached: true,
-				});
+			const proc = spawn(finalCmd, {
+				cwd: absCwd,
+				shell: true,
+				stdio: ['ignore', 'pipe', 'pipe'],
+				env: { ...process.env, PATH: getAugmentedPath() },
+				detached: true,
+			});
 
-				let stdout = '';
-				let stderr = '';
-				let didTimeout = false;
-				let didAbort = false;
-				let settled = false;
-				let timeoutId: ReturnType<typeof setTimeout> | null = null;
-
-				const settle = (
-					result: ToolResponse<{
-						exitCode: number;
-						stdout: string;
-						stderr: string;
-					}>,
-				) => {
-					if (settled) return;
-					settled = true;
-					if (timeoutId) clearTimeout(timeoutId);
-					if (abortSignal) {
-						abortSignal.removeEventListener('abort', onAbort);
-					}
-					resolve(result);
-				};
+			let stdout = '';
+			let stderr = '';
+			let didTimeout = false;
+			let didAbort = false;
+			let settled = false;
+			let done = false;
+			let timeoutId: ReturnType<typeof setTimeout> | null = null;
+			const queue: BashStreamChunk[] = [];
+			let notify: (() => void) | null = null;
 
-				const onAbort = () => {
-					if (settled) return;
-					didAbort = true;
-					if (proc.pid) killProcessTree(proc.pid);
-					else proc.kill('SIGTERM');
-				};
+			const wake = () => {
+				if (!notify) return;
+				notify();
+				notify = null;
+			};
+
+			const pushDelta = (text: string) => {
+				if (!text) return;
+				queue.push({ channel: 'output', delta: text });
+				wake();
+			};
 
+			const settle = (result: BashResult) => {
+				if (settled) return;
+				settled = true;
+				if (timeoutId) clearTimeout(timeoutId);
 				if (abortSignal) {
-					abortSignal.addEventListener('abort', onAbort, { once: true });
+					abortSignal.removeEventListener('abort', onAbort);
 				}
+				queue.push({ result });
+				done = true;
+				wake();
+			};
 
-				if (timeout > 0) {
-					timeoutId = setTimeout(() => {
-						didTimeout = true;
-						if (proc.pid) killProcessTree(proc.pid);
-						else proc.kill();
-					}, timeout);
-				}
+			const onAbort = () => {
+				if (settled) return;
+				didAbort = true;
+				if (proc.pid) killProcessTree(proc.pid);
+				else proc.kill('SIGTERM');
+			};
 
-				proc.stdout?.on('data', (chunk) => {
-					stdout += chunk.toString();
-				});
+			if (abortSignal) {
+				abortSignal.addEventListener('abort', onAbort, { once: true });
+			}
 
-				proc.stderr?.on('data', (chunk) => {
-					stderr += chunk.toString();
-				});
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					didTimeout = true;
+					if (proc.pid) killProcessTree(proc.pid);
+					else proc.kill();
+				}, timeout);
+			}
 
-				proc.on('close', (exitCode) => {
-					if (didAbort) {
-						settle(
-							createToolError(`Command aborted by user: ${cmd}`, 'abort', {
-								cmd,
-								stdout,
-								stderr,
-							}),
-						);
-					} else if (didTimeout) {
-						settle(
-							createToolError(
-								`Command timed out after ${timeout}ms: ${cmd}`,
-								'timeout',
-								{
-									parameter: 'timeout',
-									value: timeout,
-									suggestion: 'Increase timeout or optimize the command',
-								},
-							),
-						);
-					} else if (exitCode !== 0 && !allowNonZeroExit) {
-						const errorDetail = stderr.trim() || stdout.trim() || '';
-						const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
-						settle(
-							createToolError(errorMsg, 'execution', {
-								exitCode,
-								stdout,
-								stderr,
-								cmd,
-								suggestion:
-									'Check command syntax or use allowNonZeroExit: true',
-							}),
-						);
-					} else {
-						settle({
-							ok: true,
-							exitCode: exitCode ?? 0,
+			proc.stdout?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stdout += text;
+				pushDelta(text);
+			});
+
+			proc.stderr?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stderr += text;
+				pushDelta(text);
+			});
+
+			proc.on('close', (exitCode) => {
+				if (didAbort) {
+					settle(
+						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
+							cmd,
 							stdout,
 							stderr,
-						});
-					}
-				});
+						}),
+					);
+					return;
+				}
 
-				proc.on('error', (err) => {
+				if (didTimeout) {
 					settle(
 						createToolError(
-							`Command execution failed: ${err.message}`,
-							'execution',
+							`Command timed out after ${timeout}ms: ${cmd}`,
+							'timeout',
 							{
-								cmd,
-								originalError: err.message,
+								parameter: 'timeout',
+								value: timeout,
+								stdout,
+								stderr,
+								suggestion: 'Increase timeout or optimize the command',
 							},
 						),
 					);
+					return;
+				}
+
+				if (exitCode !== 0 && !allowNonZeroExit) {
+					const errorDetail = stderr.trim() || stdout.trim() || '';
+					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
+					settle(
+						createToolError(errorMsg, 'execution', {
+							exitCode,
+							stdout,
+							stderr,
+							cmd,
+							suggestion: 'Check command syntax or use allowNonZeroExit: true',
+						}),
+					);
+					return;
+				}
+
+				settle({
+					ok: true,
+					exitCode: exitCode ?? 0,
+					stdout,
+					stderr,
 				});
 			});
+
+			proc.on('error', (err) => {
+				settle(
+					createToolError(
+						`Command execution failed: ${err.message}`,
+						'execution',
+						{
+							cmd,
+							originalError: err.message,
+						},
+					),
+				);
+			});
+
+			const stream = async function* (): AsyncGenerator<BashStreamChunk> {
+				while (!done || queue.length > 0) {
+					if (queue.length === 0) {
+						await new Promise<void>((resolve) => {
+							notify = resolve;
+						});
+					}
+					while (queue.length > 0) {
+						const chunk = queue.shift();
+						if (chunk) yield chunk;
+					}
+				}
+			};
+
+			return stream();
 		},
-	});
+	} as any);
 	return { name: 'bash', tool: bash };
 }

package/src/index.ts

@@ -29,6 +29,7 @@ export type {
 	DefaultConfig,
 	PathConfig,
 	OttoConfig,
+	ReasoningLevel,
 } from './types/src/index.ts';
 
 // =======================

package/src/prompts/src/providers.ts

@@ -49,6 +49,25 @@ async function readIfExists(path: string): Promise<string | undefined> {
 	return undefined;
 }
 
+function getPromptOverridePaths(args: {
+	projectRoot: string;
+	provider: string;
+	modelId?: string;
+}): { modelPaths: string[]; providerPaths: string[] } {
+	const { projectRoot, provider, modelId } = args;
+	const modelPaths: string[] = [];
+	const providerPaths: string[] = [];
+
+	if (modelId) {
+		const sanitized = sanitizeModelId(modelId);
+		modelPaths.push(`${projectRoot}/.otto/prompts/models/${sanitized}.txt`);
+	}
+
+	providerPaths.push(`${projectRoot}/.otto/prompts/providers/${provider}.txt`);
+
+	return { modelPaths, providerPaths };
+}
+
 export type ProviderPromptResult = {
 	prompt: string;
 	resolvedType: string;
@@ -57,21 +76,37 @@ export type ProviderPromptResult = {
 export async function providerBasePrompt(
 	provider: string,
 	modelId: string | undefined,
-	_projectRoot: string,
+	projectRoot: string,
 ): Promise<ProviderPromptResult> {
 	const id = String(provider || '').toLowerCase();
+	const { modelPaths, providerPaths } = getPromptOverridePaths({
+		projectRoot,
+		provider: id,
+		modelId,
+	});
 
 	if (modelId) {
 		const sanitized = sanitizeModelId(modelId);
-		const modelPath = `src/prompts/models/${sanitized}.txt`;
-		const modelText = await readIfExists(modelPath);
-		if (modelText) {
+		for (const modelPath of modelPaths) {
+			const modelText = await readIfExists(modelPath);
+			if (!modelText) continue;
 			const promptType = `model:${sanitized}`;
-			debugLog(`[provider] prompt: ${promptType} (${modelText.length} chars)`);
+			debugLog(
+				`[provider] prompt: ${promptType} (${modelText.length} chars) from ${modelPath}`,
+			);
 			return { prompt: modelText, resolvedType: promptType };
 		}
 	}
 
+	for (const providerPath of providerPaths) {
+		const providerText = await readIfExists(providerPath);
+		if (!providerText) continue;
+		debugLog(
+			`[provider] prompt: custom:${id} (${providerText.length} chars) from ${providerPath}`,
+		);
+		return { prompt: providerText, resolvedType: `custom:${id}` };
+	}
+
 	if (isProviderId(id) && modelId) {
 		const info = getModelInfo(id, modelId);
 		if (info?.ownedBy) {
@@ -119,13 +154,6 @@ export async function providerBasePrompt(
 		return { prompt: result, resolvedType: 'glm' };
 	}
 
-	const providerPath = `src/prompts/providers/${id}.txt`;
-	const providerText = await readIfExists(providerPath);
-	if (providerText) {
-		debugLog(`[provider] prompt: custom:${id} (${providerText.length} chars)`);
-		return { prompt: providerText, resolvedType: `custom:${id}` };
-	}
-
 	const result = PROVIDER_DEFAULT.trim();
 	debugLog(`[provider] prompt: default (${result.length} chars)`);
 	return { prompt: result, resolvedType: 'default' };

package/src/tunnel/qr.ts

@@ -1,4 +1,3 @@
-// @ts-expect-error No bundled types for qrcode-terminal in all workspace builds
 import qrcode from 'qrcode-terminal';
 
 export function generateQRCode(data: string): Promise<string> {

package/src/types/src/config.ts

@@ -9,6 +9,13 @@ export type Scope = 'global' | 'local';
  * Default settings for the CLI
  */
 export type ToolApprovalMode = 'auto' | 'dangerous' | 'all';
+export type ReasoningLevel =
+	| 'minimal'
+	| 'low'
+	| 'medium'
+	| 'high'
+	| 'max'
+	| 'xhigh';
 
 export type DefaultConfig = {
 	agent: string;
@@ -17,6 +24,7 @@ export type DefaultConfig = {
 	toolApproval?: ToolApprovalMode;
 	guidedMode?: boolean;
 	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 	theme?: string;
 };
 

package/src/types/src/index.ts

@@ -19,4 +19,5 @@ export type {
 	ProviderSettings,
 	OttoConfig,
 	ToolApprovalMode,
+	ReasoningLevel,
 } from './config';