@ottocode/sdk 0.1.173

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

@@ -0,0 +1,244 @@
+import { openai, createOpenAI } from '@ai-sdk/openai';
+import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
+import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import {
+	catalog,
+	createSetuModel,
+	createOpenAIOAuthModel,
+} from '../../../providers/src/index.ts';
+import { createCopilotModel } from '../../../providers/src/copilot-client.ts';
+import type { OAuth } from '../../../types/src/index.ts';
+
+function needsResponsesApi(model: string): boolean {
+	const m = model.toLowerCase();
+	if (m.includes('gpt-5')) return true;
+	if (m.startsWith('o1')) return true;
+	if (m.startsWith('o3')) return true;
+	if (m.startsWith('o4')) return true;
+	if (m.includes('codex-mini')) return true;
+	return false;
+}
+
+function resolveOpenAIModel(
+	instance: ReturnType<typeof createOpenAI>,
+	model: string,
+) {
+	return needsResponsesApi(model) ? instance.responses(model) : instance(model);
+}
+
+export type ProviderName =
+	| 'openai'
+	| 'anthropic'
+	| 'google'
+	| 'openrouter'
+	| 'opencode'
+	| 'copilot'
+	| 'setu'
+	| 'zai'
+	| 'zai-coding'
+	| 'moonshot';
+
+export type ModelConfig = {
+	apiKey?: string;
+	customFetch?: typeof fetch;
+	baseURL?: string;
+	oauth?: OAuth;
+	projectRoot?: string;
+};
+
+export async function resolveModel(
+	provider: ProviderName,
+	model: string,
+	config: ModelConfig = {},
+) {
+	if (provider === 'openai') {
+		if (config.oauth) {
+			return createOpenAIOAuthModel(model, {
+				oauth: config.oauth,
+				projectRoot: config.projectRoot,
+			});
+		}
+		if (config.customFetch) {
+			const instance = createOpenAI({
+				apiKey: config.apiKey || 'oauth-token',
+				fetch: config.customFetch,
+			});
+			return resolveOpenAIModel(instance, model);
+		}
+		if (config.apiKey) {
+			const instance = createOpenAI({ apiKey: config.apiKey });
+			return resolveOpenAIModel(instance, model);
+		}
+		return needsResponsesApi(model) ? openai.responses(model) : openai(model);
+	}
+
+	if (provider === 'anthropic') {
+		if (config.customFetch) {
+			return createAnthropic({
+				apiKey: config.apiKey || '',
+				fetch: config.customFetch as typeof fetch,
+			});
+		}
+		if (config.apiKey) {
+			const instance = createAnthropic({ apiKey: config.apiKey });
+			return instance(model);
+		}
+		return anthropic(model);
+	}
+
+	if (provider === 'google') {
+		if (config.apiKey) {
+			const instance = createGoogleGenerativeAI({ apiKey: config.apiKey });
+			return instance(model);
+		}
+		return google(model);
+	}
+
+	if (provider === 'openrouter') {
+		const apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || '';
+		const openrouter = createOpenRouter({ apiKey });
+		return openrouter.chat(model);
+	}
+
+	if (provider === 'opencode') {
+		const entry = catalog[provider];
+		const normalizedModel = normalizeModelIdentifier(provider, model);
+		const modelInfo =
+			entry?.models.find((m) => m.id === normalizedModel) ??
+			entry?.models.find((m) => m.id === model);
+		const resolvedModelId = modelInfo?.id ?? normalizedModel ?? model;
+		const binding = modelInfo?.provider?.npm ?? entry?.npm;
+		const apiKey = config.apiKey || process.env.OPENCODE_API_KEY || '';
+		const baseURL =
+			config.baseURL ||
+			modelInfo?.provider?.baseURL ||
+			modelInfo?.provider?.api ||
+			entry?.api ||
+			'https://opencode.ai/zen/v1';
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		if (binding === '@ai-sdk/openai') {
+			const instance = createOpenAI({ apiKey, baseURL });
+			return instance(resolvedModelId);
+		}
+		if (binding === '@ai-sdk/anthropic') {
+			const instance = createAnthropic({ apiKey, baseURL });
+			return instance(resolvedModelId);
+		}
+		if (binding === '@ai-sdk/openai-compatible') {
+			const instance = createOpenAICompatible({
+				name: entry?.label ?? 'opencode',
+				baseURL,
+				headers,
+			});
+			return instance(resolvedModelId);
+		}
+
+		const ocOpenAI = createOpenAI({ apiKey, baseURL });
+		const ocAnthropic = createAnthropic({ apiKey, baseURL });
+		const ocCompat = createOpenAICompatible({
+			name: entry?.label ?? 'opencode',
+			baseURL,
+			headers,
+		});
+
+		const id = resolvedModelId.toLowerCase();
+		if (id.includes('claude')) return ocAnthropic(resolvedModelId);
+		if (
+			id.includes('qwen3-coder') ||
+			id.includes('grok-code') ||
+			id.includes('kimi-k2')
+		)
+			return ocCompat(resolvedModelId);
+		return ocOpenAI(resolvedModelId);
+	}
+
+	if (provider === 'copilot') {
+		if (config.oauth) {
+			return createCopilotModel(model, { oauth: config.oauth });
+		}
+		throw new Error(
+			'Copilot provider requires OAuth. Run `otto auth login copilot`.',
+		);
+	}
+
+	if (provider === 'setu') {
+		const privateKey = config.apiKey || process.env.SETU_PRIVATE_KEY || '';
+		if (!privateKey) {
+			throw new Error(
+				'Setu provider requires SETU_PRIVATE_KEY (base58 Solana secret).',
+			);
+		}
+		const baseURL = config.baseURL || process.env.SETU_BASE_URL;
+		const rpcURL = process.env.SETU_SOLANA_RPC_URL;
+		return createSetuModel(
+			model,
+			{ privateKey },
+			{
+				baseURL,
+				rpcURL,
+			},
+		);
+	}
+
+	if (provider === 'zai') {
+		const entry = catalog[provider];
+		const apiKey =
+			config.apiKey ||
+			process.env.ZAI_API_KEY ||
+			process.env.ZHIPU_API_KEY ||
+			'';
+		const baseURL =
+			config.baseURL || entry?.api || 'https://api.z.ai/api/paas/v4';
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		const instance = createOpenAICompatible({
+			name: entry?.label ?? 'Z.AI',
+			baseURL,
+			headers,
+		});
+		return instance(model);
+	}
+
+	if (provider === 'zai-coding') {
+		const entry = catalog[provider];
+		const apiKey =
+			config.apiKey ||
+			process.env.ZAI_API_KEY ||
+			process.env.ZHIPU_API_KEY ||
+			'';
+		const baseURL =
+			config.baseURL || entry?.api || 'https://api.z.ai/api/coding/paas/v4';
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		const instance = createOpenAICompatible({
+			name: entry?.label ?? 'Z.AI Coding',
+			baseURL,
+			headers,
+		});
+		return instance(model);
+	}
+
+	if (provider === 'moonshot') {
+		const entry = catalog[provider];
+		const apiKey = config.apiKey || process.env.MOONSHOT_API_KEY || '';
+		const baseURL =
+			config.baseURL || entry?.api || 'https://api.moonshot.ai/v1';
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		const instance = createOpenAICompatible({
+			name: entry?.label ?? 'Moonshot AI',
+			baseURL,
+			headers,
+		});
+		return instance(model);
+	}
+
+	throw new Error(`Unsupported provider: ${provider}`);
+}
+
+function normalizeModelIdentifier(
+	provider: ProviderName,
+	model: string,
+): string {
+	const prefix = `${provider}/`;
+	return model.startsWith(prefix) ? model.slice(prefix.length) : model;
+}

package/src/core/src/streaming/artifacts.ts

@@ -0,0 +1,41 @@
+// Shared types and helpers for tool artifacts persisted in message parts.
+
+export type FileDiffArtifact = {
+	kind: 'file_diff';
+	patchFormat: 'unified';
+	patch: string; // full unified patch text
+	summary?: { files?: number; additions?: number; deletions?: number };
+};
+
+export type FileArtifact = {
+	kind: 'file';
+	path: string; // repository-relative path
+	mime?: string;
+	size?: number;
+	sha256?: string;
+};
+
+export type Artifact =
+	| FileDiffArtifact
+	| FileArtifact
+	| { kind: string; [k: string]: unknown };
+
+export function createFileDiffArtifact(
+	patch: string,
+	summary?: { files?: number; additions?: number; deletions?: number },
+): FileDiffArtifact {
+	return { kind: 'file_diff', patchFormat: 'unified', patch, summary };
+}
+
+export function createToolResultPayload(
+	name: string,
+	result?: unknown,
+	artifact?: Artifact,
+) {
+	const payload: { name: string; result?: unknown; artifact?: Artifact } = {
+		name,
+	};
+	if (result !== undefined) payload.result = result;
+	if (artifact) payload.artifact = artifact;
+	return payload;
+}

package/src/core/src/terminals/bun-pty.ts

@@ -0,0 +1,13 @@
+import { ensureBunPtyLibrary } from './ensure-bun-pty.ts';
+
+await ensureBunPtyLibrary();
+
+const bunPty = await import('bun-pty');
+
+export const spawn = bunPty.spawn;
+
+export type {
+	IPty,
+	IPtyForkOptions as PtyOptions,
+	IExitEvent,
+} from 'bun-pty';

package/src/core/src/terminals/circular-buffer.ts

@@ -0,0 +1,30 @@
+export class CircularBuffer {
+	private buffer: string[] = [];
+	private maxSize: number;
+
+	constructor(maxSize = 500) {
+		this.maxSize = maxSize;
+	}
+
+	push(line: string): void {
+		this.buffer.push(line);
+		if (this.buffer.length > this.maxSize) {
+			this.buffer.shift();
+		}
+	}
+
+	read(lines?: number): string[] {
+		if (lines === undefined) {
+			return [...this.buffer];
+		}
+		return this.buffer.slice(-lines);
+	}
+
+	clear(): void {
+		this.buffer = [];
+	}
+
+	get length(): number {
+		return this.buffer.length;
+	}
+}

package/src/core/src/terminals/ensure-bun-pty.ts

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getGlobalConfigDir } from '../../../../src/config/src/paths.ts';
+import { RUST_PTY_LIBS } from './rust-libs.ts';
+
+function resolveLibraryFilename(): string {
+	const platform = process.platform;
+	const arch = process.arch;
+
+	if (platform === 'darwin') {
+		return arch === 'arm64' ? 'librust_pty_arm64.dylib' : 'librust_pty.dylib';
+	}
+
+	if (platform === 'win32') {
+		return 'rust_pty.dll';
+	}
+
+	return arch === 'arm64' ? 'librust_pty_arm64.so' : 'librust_pty.so';
+}
+
+function tryUseExistingPath(path?: string | null): string | null {
+	if (!path) return null;
+	if (existsSync(path)) {
+		process.env.BUN_PTY_LIB = path;
+		return path;
+	}
+	return null;
+}
+
+export async function ensureBunPtyLibrary(): Promise<string | null> {
+	const already = tryUseExistingPath(process.env.BUN_PTY_LIB);
+	if (already) return already;
+
+	const filename = resolveLibraryFilename();
+	const candidates: string[] = [];
+
+	candidates.push(
+		join(
+			process.cwd(),
+			'node_modules',
+			'bun-pty',
+			'rust-pty',
+			'target',
+			'release',
+			filename,
+		),
+	);
+
+	for (const candidate of candidates) {
+		const path = tryUseExistingPath(candidate);
+		if (path) return path;
+	}
+
+	const platformLibs =
+		RUST_PTY_LIBS[process.platform as keyof typeof RUST_PTY_LIBS];
+	const embeddedPath =
+		platformLibs?.[process.arch === 'arm64' ? 'arm64' : 'x64'];
+
+	if (embeddedPath) {
+		const targetDir = join(getGlobalConfigDir(), 'runtime', 'bun-pty');
+		mkdirSync(targetDir, { recursive: true });
+		const targetPath = join(targetDir, filename);
+		const source = Bun.file(embeddedPath);
+		await Bun.write(targetPath, source);
+		process.env.BUN_PTY_LIB = targetPath;
+		return targetPath;
+	}
+
+	return null;
+}

package/src/core/src/terminals/index.ts

@@ -0,0 +1,8 @@
+export { TerminalManager, type CreateTerminalOptions } from './manager.ts';
+export {
+	Terminal,
+	type TerminalOptions,
+	type TerminalStatus,
+	type TerminalCreator,
+} from './terminal.ts';
+export { CircularBuffer } from './circular-buffer.ts';

package/src/core/src/terminals/manager.ts

@@ -0,0 +1,158 @@
+import { randomBytes } from 'node:crypto';
+import type { PtyOptions } from './bun-pty.ts';
+import { spawn as spawnPty } from './bun-pty.ts';
+import { Terminal } from './terminal.ts';
+import { logger } from '../utils/logger.ts';
+import { getAugmentedPath } from '../tools/bin-manager.ts';
+
+const MAX_TERMINALS = 10;
+const CLEANUP_DELAY_MS = 5 * 60 * 1000;
+
+export interface CreateTerminalOptions {
+	command: string;
+	args?: string[];
+	cwd: string;
+	purpose: string;
+	createdBy: 'user' | 'llm';
+	title?: string;
+}
+
+export class TerminalManager {
+	private terminals = new Map<string, Terminal>();
+	private cleanupTimers = new Map<string, NodeJS.Timeout>();
+
+	create(options: CreateTerminalOptions): Terminal {
+		if (this.terminals.size >= MAX_TERMINALS) {
+			throw new Error(`Maximum ${MAX_TERMINALS} terminals reached`);
+		}
+
+		const id = this.generateId();
+
+		try {
+			logger.debug('TerminalManager: creating terminal', {
+				id,
+				command: options.command,
+				args: options.args,
+				cwd: options.cwd,
+				purpose: options.purpose,
+			});
+
+			const ptyOptions: PtyOptions = {
+				name: 'xterm-256color',
+				cols: 80,
+				rows: 30,
+				cwd: options.cwd,
+				env: {
+					...process.env,
+					TERM: 'xterm-256color',
+					PATH: getAugmentedPath(),
+					PROMPT_EOL_MARK: '',
+				} as Record<string, string>,
+			};
+
+			const pty = spawnPty(options.command, options.args || [], ptyOptions);
+
+			logger.debug('TerminalManager: PTY created', {
+				pid: pty.pid,
+			});
+
+			const terminal = new Terminal(id, pty, options);
+
+			terminal.onExit((_exitCode) => {
+				const timer = setTimeout(() => {
+					this.delete(id);
+				}, CLEANUP_DELAY_MS);
+
+				this.cleanupTimers.set(id, timer);
+			});
+
+			this.terminals.set(id, terminal);
+
+			logger.debug('TerminalManager: terminal added to map', { id });
+
+			return terminal;
+		} catch (error) {
+			logger.error('TerminalManager: failed to create terminal', error);
+			throw error;
+		}
+	}
+
+	get(id: string): Terminal | undefined {
+		return this.terminals.get(id);
+	}
+
+	list(): Terminal[] {
+		return Array.from(this.terminals.values());
+	}
+
+	async kill(id: string): Promise<void> {
+		const terminal = this.terminals.get(id);
+		if (!terminal) {
+			throw new Error(`Terminal ${id} not found`);
+		}
+
+		terminal.kill();
+
+		await new Promise<void>((resolve) => {
+			if (terminal.status === 'exited') {
+				resolve();
+				return;
+			}
+
+			const exitHandler = () => {
+				terminal.removeExitListener(exitHandler);
+				resolve();
+			};
+
+			terminal.onExit(exitHandler);
+
+			setTimeout(() => {
+				terminal.removeExitListener(exitHandler);
+				resolve();
+			}, 5000);
+		});
+
+		this.delete(id);
+	}
+
+	async killAll(): Promise<void> {
+		const killPromises = Array.from(this.terminals.keys()).map((id) =>
+			this.kill(id).catch((err) =>
+				logger.error(`Failed to kill terminal ${id}`, err),
+			),
+		);
+
+		await Promise.all(killPromises);
+	}
+
+	delete(id: string): boolean {
+		const timer = this.cleanupTimers.get(id);
+		if (timer) {
+			clearTimeout(timer);
+			this.cleanupTimers.delete(id);
+		}
+
+		return this.terminals.delete(id);
+	}
+
+	private generateId(): string {
+		return `term-${randomBytes(8).toString('hex')}`;
+	}
+
+	getContext(): string {
+		const terminals = this.list();
+
+		if (terminals.length === 0) {
+			return '';
+		}
+
+		const summary = terminals
+			.map(
+				(t) =>
+					`- [${t.id}] ${t.purpose} (${t.status}, ${t.createdBy}, pid: ${t.pid})`,
+			)
+			.join('\n');
+
+		return `\n\n## Active Terminals (${terminals.length}):\n${summary}\n\nYou can read from any terminal using the 'terminal' tool with operation: 'read'.`;
+	}
+}

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

@@ -0,0 +1,30 @@
+import darwinArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.dylib' with {
+	type: 'file',
+};
+import darwinX64 from 'bun-pty/rust-pty/target/release/librust_pty.dylib' with {
+	type: 'file',
+};
+import linuxArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.so' with {
+	type: 'file',
+};
+import linuxX64 from 'bun-pty/rust-pty/target/release/librust_pty.so' with {
+	type: 'file',
+};
+import windowsDll from 'bun-pty/rust-pty/target/release/rust_pty.dll' with {
+	type: 'file',
+};
+
+export const RUST_PTY_LIBS = {
+	darwin: {
+		arm64: darwinArm64,
+		x64: darwinX64,
+	},
+	linux: {
+		arm64: linuxArm64,
+		x64: linuxX64,
+	},
+	win32: {
+		arm64: windowsDll,
+		x64: windowsDll,
+	},
+} as const;