@agi-cli/sdk 0.1.168 → 0.1.170

package/package.json

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

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

@@ -0,0 +1,190 @@
+import { spawn } from 'node:child_process';
+
+const CLIENT_ID = 'Ov23li8tweQw6odWQebz';
+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;
+	}
+}

package/src/auth/src/index.ts

@@ -89,3 +89,12 @@ export {
 	ensureSetuWallet,
 	type WalletInfo,
 } from './wallet.ts';
+
+export {
+	authorizeCopilot,
+	pollForToken as pollForCopilotToken,
+	pollForTokenOnce as pollForCopilotTokenOnce,
+	openCopilotAuthUrl,
+	type CopilotDeviceCodeResponse,
+	type CopilotPollResult,
+} from './copilot-oauth.ts';

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

@@ -8,6 +8,7 @@ import {
 	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 {
@@ -33,6 +34,7 @@ export type ProviderName =
 	| 'google'
 	| 'openrouter'
 	| 'opencode'
+	| 'copilot'
 	| 'setu'
 	| 'zai'
 	| 'zai-coding'
@@ -152,6 +154,15 @@ export async function resolveModel(
 		return ocOpenAI(resolvedModelId);
 	}
 
+	if (provider === 'copilot') {
+		if (config.oauth) {
+			return createCopilotModel(model, { oauth: config.oauth });
+		}
+		throw new Error(
+			'Copilot provider requires OAuth. Run `agi auth login copilot`.',
+		);
+	}
+
 	if (provider === 'setu') {
 		const privateKey = config.apiKey || process.env.SETU_PRIVATE_KEY || '';
 		if (!privateKey) {

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

@@ -184,6 +184,12 @@ The tool will convert it automatically, but the enveloped format is still recomm
 
 ## Common Errors
 
+**"Missing *** End Patch marker"**: Every patch MUST end with `*** End Patch` on its own line.
+This is the most common error. Double-check your patch ends with:
+```
+*** End Patch
+```
+
 **"Failed to find expected lines"**: The file content doesn't match your patch. Common causes:
 - Missing context lines (lines with space prefix)
 - Using `@@` line as context instead of real context lines

package/src/index.ts

@@ -106,6 +106,11 @@ export { createOpencodeModel } from './providers/src/index.ts';
 export type { OpencodeProviderConfig } from './providers/src/index.ts';
 export { createMoonshotModel } from './providers/src/index.ts';
 export type { MoonshotProviderConfig } from './providers/src/index.ts';
+export {
+	createCopilotFetch,
+	createCopilotModel,
+} from './providers/src/index.ts';
+export type { CopilotOAuthConfig } from './providers/src/index.ts';
 
 // =======================
 // Authentication (from internal auth module)
@@ -140,6 +145,16 @@ export {
 	ensureSetuWallet,
 } from './auth/src/index.ts';
 export type { WalletInfo } from './auth/src/index.ts';
+export {
+	authorizeCopilot,
+	pollForCopilotToken,
+	pollForCopilotTokenOnce,
+	openCopilotAuthUrl,
+} from './auth/src/index.ts';
+export type {
+	CopilotDeviceCodeResponse,
+	CopilotPollResult,
+} from './auth/src/index.ts';
 
 // =======================
 // Configuration (from internal config module)

package/src/providers/src/catalog-manual.ts

@@ -82,7 +82,6 @@ function buildSetuEntry(base: CatalogMap): ProviderCatalogEntry | null {
 
 	if (!setuModels.length) return null;
 
-	// Prefer OpenAI-family models first so defaults are stable
 	setuModels.sort((a, b) => {
 		const providerA = a.provider?.npm ?? '';
 		const providerB = b.provider?.npm ?? '';