@ottocode/sdk 0.1.173

package/README.md

@@ -0,0 +1,338 @@
+# @ottocode/sdk
+
+> **The single source of truth for ottocode functionality** - Comprehensive, tree-shakable, and developer-friendly.
+
+## Overview
+
+`@ottocode/sdk` is the unified SDK for building AI agents with ottocode. All authentication, configuration, providers, prompts, tools, and core AI functionality are included in this single package.
+
+**Why use the SDK?**
+- ✅ **Single import**: All functionality from one package
+- ✅ **Tree-shakable**: Bundlers only include what you use
+- ✅ **Type-safe**: Full TypeScript support with comprehensive types
+- ✅ **Zero circular dependencies**: Clean architecture
+- ✅ **Consistent API**: No need to remember which module exports what
+
+## Installation
+
+```bash
+bun add @ottocode/sdk
+```
+
+## Quick Start
+
+```typescript
+import { generateText, resolveModel } from '@ottocode/sdk';
+import type { ProviderId } from '@ottocode/sdk';
+
+const model = resolveModel('anthropic', 'claude-sonnet-4-20250514');
+
+const { text } = await generateText({
+  model,
+  prompt: 'What is the meaning of life?',
+});
+
+console.log(text);
+```
+
+## What's Included?
+
+### Types
+
+All shared types are available:
+
+```typescript
+import type { 
+  ProviderId, 
+  ModelInfo, 
+  AuthInfo, 
+  OttoConfig,
+  ProviderConfig,
+  Scope
+} from '@ottocode/sdk';
+```
+
+### Providers
+
+Provider catalog and utilities:
+
+```typescript
+import { 
+  catalog,
+  isProviderId,
+  providerIds,
+  defaultModelFor,
+  hasModel,
+  isProviderAuthorized,
+  validateProviderModel,
+  estimateModelCostUsd,
+  providerEnvVar,
+  readEnvKey,
+  setEnvKey
+} from '@ottocode/sdk';
+
+// Check available providers
+console.log(providerIds); // ['openai', 'anthropic', 'google', 'openrouter', 'opencode', 'setu']
+
+// Get model information
+const models = catalog.anthropic.models;
+
+// Validate provider/model combination
+const result = validateProviderModel('anthropic', 'claude-sonnet-4-20250514');
+```
+
+### Authentication
+
+Manage API keys and OAuth:
+
+```typescript
+import { 
+  getAuth, 
+  setAuth, 
+  removeAuth, 
+  getAllAuth,
+  authorize,
+  createApiKey 
+} from '@ottocode/sdk';
+
+// Set API key
+await setAuth('openai', { apiKey: 'sk-...' });
+
+// Get auth info
+const auth = await getAuth('openai');
+
+// OAuth flow
+const url = await authorize('anthropic');
+console.log(`Visit: ${url}`);
+```
+
+### Configuration
+
+Load and manage configuration:
+
+```typescript
+import { loadConfig } from '@ottocode/sdk';
+import type { OttoConfig } from '@ottocode/sdk';
+
+const config = await loadConfig();
+console.log(config.provider); // 'anthropic'
+console.log(config.model);    // 'claude-sonnet-4-20250514'
+```
+
+### Prompts
+
+Pre-built system prompts:
+
+```typescript
+import { providerBasePrompt } from '@ottocode/sdk';
+
+const prompt = providerBasePrompt('anthropic');
+```
+
+### Core AI Functions
+
+AI SDK re-exports and utilities:
+
+```typescript
+import { 
+  generateText, 
+  streamText, 
+  generateObject, 
+  streamObject,
+  tool,
+  resolveModel,
+  discoverProjectTools,
+  buildFsTools,
+  buildGitTools,
+  createFileDiffArtifact,
+  z
+} from '@ottocode/sdk';
+import type { CoreMessage, Tool, DiscoveredTool } from '@ottocode/sdk';
+
+// Generate text
+const { text } = await generateText({
+  model: resolveModel('anthropic'),
+  prompt: 'Hello!',
+});
+
+// Stream text with tools
+const { textStream } = streamText({
+  model: resolveModel('openai'),
+  prompt: 'What files are in the current directory?',
+  tools: buildFsTools(),
+});
+
+// Generate structured output
+const { object } = await generateObject({
+  model: resolveModel('anthropic'),
+  schema: z.object({
+    name: z.string(),
+    age: z.number(),
+  }),
+  prompt: 'Generate a person',
+});
+
+// Discover project tools
+const tools = await discoverProjectTools('/path/to/project');
+```
+
+### Error Handling
+
+Typed error classes:
+
+```typescript
+import { 
+  OttoError, 
+  AuthError, 
+  ConfigError, 
+  ToolError,
+  ProviderError,
+  DatabaseError,
+  ValidationError,
+  NotFoundError,
+  ServiceError
+} from '@ottocode/sdk';
+
+try {
+  // ... your code
+} catch (error) {
+  if (error instanceof AuthError) {
+    console.error('Authentication failed:', error.message);
+  }
+}
+```
+
+## Tree-Shaking
+
+The SDK is fully tree-shakable. Modern bundlers (Vite, Rollup, esbuild, webpack) will only include the code you actually use:
+
+```typescript
+// Only includes generateText and resolveModel code
+import { generateText, resolveModel } from '@ottocode/sdk';
+```
+
+## Architecture
+
+The SDK contains all functionality internally:
+
+```
+@ottocode/sdk/src/
+├── auth/           ← Authentication (OAuth, API keys)
+├── config/         ← Configuration (global + project)
+├── core/           ← Core AI functionality
+│   ├── providers/     (model resolution)
+│   ├── tools/         (builtin tools)
+│   ├── streaming/     (artifacts)
+│   └── errors.ts      (error classes)
+├── prompts/        ← System prompts
+├── providers/      ← Provider catalog & utilities
+└── index.ts        ← Main exports
+```
+
+Related packages:
+- `@ottocode/database` - SQLite persistence (depends on sdk)
+- `@ottocode/server` - HTTP API (depends on sdk, database)
+- `@ottocode/api` - Type-safe API client (standalone)
+- `@ottocode/web-sdk` - React hooks & components (depends on api)
+
+## Examples
+
+### Basic Agent
+
+```typescript
+import { generateText, resolveModel } from '@ottocode/sdk';
+
+const model = resolveModel('anthropic');
+
+const { text } = await generateText({
+  model,
+  prompt: 'Explain TypeScript generics',
+});
+
+console.log(text);
+```
+
+### Agent with Tools
+
+```typescript
+import { streamText, resolveModel, buildFsTools, buildGitTools } from '@ottocode/sdk';
+
+const tools = {
+  ...buildFsTools(),
+  ...buildGitTools(),
+};
+
+const { textStream } = streamText({
+  model: resolveModel('openai'),
+  prompt: 'What Git branch am I on? List the files in the current directory.',
+  tools,
+});
+
+for await (const chunk of textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+### Structured Output
+
+```typescript
+import { generateObject, resolveModel, z } from '@ottocode/sdk';
+
+const schema = z.object({
+  sentiment: z.enum(['positive', 'negative', 'neutral']),
+  confidence: z.number().min(0).max(1),
+  keywords: z.array(z.string()),
+});
+
+const { object } = await generateObject({
+  model: resolveModel('anthropic'),
+  schema,
+  prompt: 'Analyze: "This SDK is amazing!"',
+});
+
+console.log(object);
+// { sentiment: 'positive', confidence: 0.95, keywords: ['amazing', 'SDK'] }
+```
+
+### With Configuration
+
+```typescript
+import { generateText, resolveModel, loadConfig } from '@ottocode/sdk';
+
+const config = await loadConfig();
+const model = resolveModel(config.provider, config.model);
+
+const { text } = await generateText({
+  model,
+  prompt: 'Hello from ottocode!',
+  temperature: config.temperature,
+});
+```
+
+## TypeScript
+
+Full TypeScript support with comprehensive types:
+
+```typescript
+import type { 
+  ProviderId, 
+  ModelInfo, 
+  OttoConfig,
+  CoreMessage,
+  Tool,
+  DiscoveredTool,
+  Artifact
+} from '@ottocode/sdk';
+
+// All types are fully documented and type-safe
+const providerId: ProviderId = 'anthropic';
+const config: OttoConfig = await loadConfig();
+```
+
+## License
+
+MIT
+
+## Contributing
+
+See the main repository for contribution guidelines.

package/package.json

@@ -0,0 +1,128 @@
+{
+	"name": "@ottocode/sdk",
+	"version": "0.1.173",
+	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
+	"author": "nitishxyz",
+	"license": "MIT",
+	"homepage": "https://github.com/nitishxyz/otto#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nitishxyz/otto.git",
+		"directory": "packages/sdk"
+	},
+	"bugs": {
+		"url": "https://github.com/nitishxyz/otto/issues"
+	},
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"import": "./src/index.ts",
+			"types": "./src/index.ts"
+		},
+		"./browser": {
+			"import": "./src/browser.ts",
+			"types": "./src/browser.ts"
+		},
+		"./tools/builtin/fs": {
+			"import": "./src/core/src/tools/builtin/fs/index.ts",
+			"types": "./src/core/src/tools/builtin/fs/index.ts"
+		},
+		"./tools/builtin/git": {
+			"import": "./src/core/src/tools/builtin/git.ts",
+			"types": "./src/core/src/tools/builtin/git.ts"
+		},
+		"./tools/builtin/bash": {
+			"import": "./src/core/src/tools/builtin/bash.ts",
+			"types": "./src/core/src/tools/builtin/bash.ts"
+		},
+		"./tools/builtin/edit": {
+			"import": "./src/core/src/tools/builtin/edit.ts",
+			"types": "./src/core/src/tools/builtin/edit.ts"
+		},
+		"./tools/builtin/finish": {
+			"import": "./src/core/src/tools/builtin/finish.ts",
+			"types": "./src/core/src/tools/builtin/finish.ts"
+		},
+		"./tools/builtin/grep": {
+			"import": "./src/core/src/tools/builtin/grep.ts",
+			"types": "./src/core/src/tools/builtin/grep.ts"
+		},
+		"./tools/builtin/patch": {
+			"import": "./src/core/src/tools/builtin/patch.ts",
+			"types": "./src/core/src/tools/builtin/patch.ts"
+		},
+		"./tools/builtin/plan": {
+			"import": "./src/core/src/tools/builtin/plan.ts",
+			"types": "./src/core/src/tools/builtin/plan.ts"
+		},
+		"./tools/builtin/progress": {
+			"import": "./src/core/src/tools/builtin/progress.ts",
+			"types": "./src/core/src/tools/builtin/progress.ts"
+		},
+		"./tools/builtin/ripgrep": {
+			"import": "./src/core/src/tools/builtin/ripgrep.ts",
+			"types": "./src/core/src/tools/builtin/ripgrep.ts"
+		},
+		"./tools/builtin/websearch": {
+			"import": "./src/core/src/tools/builtin/websearch.ts",
+			"types": "./src/core/src/tools/builtin/websearch.ts"
+		},
+		"./tools/builtin/terminal": {
+			"import": "./src/core/src/tools/builtin/terminal.ts",
+			"types": "./src/core/src/tools/builtin/terminal.ts"
+		},
+		"./tools/error": {
+			"import": "./src/core/src/tools/error.ts",
+			"types": "./src/core/src/tools/error.ts"
+		},
+		"./prompts/*": "./src/prompts/src/*"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"test": "bun test",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@ai-sdk/anthropic": "^3.0.0",
+		"@ai-sdk/google": "^3.0.0",
+		"@ai-sdk/openai": "^3.0.0",
+		"@ai-sdk/openai-compatible": "^2.0.0",
+		"@openauthjs/openauth": "^0.4.3",
+		"@openrouter/ai-sdk-provider": "^1.2.0",
+		"@solana/web3.js": "^1.95.2",
+		"ai": "^6.0.0",
+		"bs58": "^6.0.0",
+		"bun-pty": "^0.3.2",
+		"diff": "^8.0.2",
+		"fast-glob": "^3.3.2",
+		"hono": "^4.9.9",
+		"opencode-anthropic-auth": "^0.0.2",
+		"tweetnacl": "^1.0.3",
+		"x402": "^1.1.0",
+		"zod": "^4.1.8"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"typescript": "^5"
+	},
+	"keywords": [
+		"ai",
+		"sdk",
+		"agents",
+		"tools",
+		"llm",
+		"anthropic",
+		"openai",
+		"development",
+		"assistant",
+		"tree-shakable",
+		"typescript"
+	]
+}

package/src/agent/types.ts

@@ -0,0 +1,19 @@
+import type { ProviderName } from '../core/src/index.ts';
+
+export type AgentConfig = {
+	name: string;
+	prompt: string;
+	tools: string[];
+	provider?: ProviderName;
+	model?: string;
+};
+
+export type AgentConfigEntry = {
+	tools?: string[];
+	appendTools?: string[];
+	prompt?: string;
+	provider?: string;
+	model?: string;
+};
+
+export type AgentsJson = Record<string, AgentConfigEntry>;

package/src/auth/src/copilot-oauth.ts

@@ -0,0 +1,190 @@
+import { spawn } from 'node:child_process';
+
+const CLIENT_ID = 'Ov23lip6QjVYxHUAeW4d';
+const POLLING_SAFETY_MARGIN_MS = 3000;
+
+const DEVICE_CODE_URL = 'https://github.com/login/device/code';
+const ACCESS_TOKEN_URL = 'https://github.com/login/oauth/access_token';
+
+export type CopilotDeviceCodeResponse = {
+	verification_uri: string;
+	user_code: string;
+	device_code: string;
+	interval: number;
+};
+
+export type CopilotOAuthResult = {
+	access_token: string;
+};
+
+async function openBrowser(url: string) {
+	const platform = process.platform;
+	let command: string;
+	switch (platform) {
+		case 'darwin':
+			command = `open "${url}"`;
+			break;
+		case 'win32':
+			command = `start "${url}"`;
+			break;
+		default:
+			command = `xdg-open "${url}"`;
+			break;
+	}
+	return new Promise<void>((resolve, reject) => {
+		const child = spawn(command, [], { shell: true });
+		child.on('error', reject);
+		child.on('exit', (code) => {
+			if (code === 0) resolve();
+			else reject(new Error(`Failed to open browser (exit code ${code})`));
+		});
+	});
+}
+
+export async function requestDeviceCode(): Promise<CopilotDeviceCodeResponse> {
+	const response = await fetch(DEVICE_CODE_URL, {
+		method: 'POST',
+		headers: {
+			Accept: 'application/json',
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify({
+			client_id: CLIENT_ID,
+			scope: 'read:user',
+		}),
+	});
+
+	if (!response.ok) {
+		throw new Error('Failed to initiate GitHub device authorization');
+	}
+
+	return (await response.json()) as CopilotDeviceCodeResponse;
+}
+
+export async function pollForToken(
+	deviceCode: string,
+	interval: number,
+): Promise<string> {
+	while (true) {
+		const response = await fetch(ACCESS_TOKEN_URL, {
+			method: 'POST',
+			headers: {
+				Accept: 'application/json',
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify({
+				client_id: CLIENT_ID,
+				device_code: deviceCode,
+				grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+			}),
+		});
+
+		if (!response.ok) {
+			throw new Error('Token exchange request failed');
+		}
+
+		const data = (await response.json()) as {
+			access_token?: string;
+			error?: string;
+			interval?: number;
+		};
+
+		if (data.access_token) {
+			return data.access_token;
+		}
+
+		if (data.error === 'authorization_pending') {
+			await Bun.sleep(interval * 1000 + POLLING_SAFETY_MARGIN_MS);
+			continue;
+		}
+
+		if (data.error === 'slow_down') {
+			let newInterval = (interval + 5) * 1000;
+			const serverInterval = data.interval;
+			if (
+				serverInterval &&
+				typeof serverInterval === 'number' &&
+				serverInterval > 0
+			) {
+				newInterval = serverInterval * 1000;
+			}
+			await Bun.sleep(newInterval + POLLING_SAFETY_MARGIN_MS);
+			continue;
+		}
+
+		if (data.error) {
+			throw new Error(`GitHub OAuth error: ${data.error}`);
+		}
+
+		await Bun.sleep(interval * 1000 + POLLING_SAFETY_MARGIN_MS);
+	}
+}
+
+export async function authorizeCopilot(): Promise<{
+	verificationUri: string;
+	userCode: string;
+	deviceCode: string;
+	interval: number;
+}> {
+	const deviceData = await requestDeviceCode();
+	return {
+		verificationUri: deviceData.verification_uri,
+		userCode: deviceData.user_code,
+		deviceCode: deviceData.device_code,
+		interval: deviceData.interval,
+	};
+}
+
+export type CopilotPollResult =
+	| { status: 'complete'; accessToken: string }
+	| { status: 'pending' }
+	| { status: 'error'; error: string };
+
+export async function pollForTokenOnce(
+	deviceCode: string,
+): Promise<CopilotPollResult> {
+	const response = await fetch(ACCESS_TOKEN_URL, {
+		method: 'POST',
+		headers: {
+			Accept: 'application/json',
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify({
+			client_id: CLIENT_ID,
+			device_code: deviceCode,
+			grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+		}),
+	});
+
+	if (!response.ok) {
+		return { status: 'error', error: 'Token exchange request failed' };
+	}
+
+	const data = (await response.json()) as {
+		access_token?: string;
+		error?: string;
+	};
+
+	if (data.access_token) {
+		return { status: 'complete', accessToken: data.access_token };
+	}
+
+	if (data.error === 'authorization_pending' || data.error === 'slow_down') {
+		return { status: 'pending' };
+	}
+
+	if (data.error) {
+		return { status: 'error', error: `GitHub OAuth error: ${data.error}` };
+	}
+
+	return { status: 'pending' };
+}
+
+export async function openCopilotAuthUrl(url: string): Promise<boolean> {
+	try {
+		await openBrowser(url);
+		return true;
+	} catch {
+		return false;
+	}
+}