@agi-cli/sdk 0.1.169 → 0.1.170

package/src/providers/src/copilot-client.ts

@@ -0,0 +1,40 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import type { OAuth } from '../../types/src/index.ts';
+
+const COPILOT_BASE_URL = 'https://api.githubcopilot.com';
+
+export type CopilotOAuthConfig = {
+	oauth: OAuth;
+};
+
+export function createCopilotFetch(config: CopilotOAuthConfig): typeof fetch {
+	return async (
+		input: string | URL | Request,
+		init?: RequestInit,
+	): Promise<Response> => {
+		const headers = new Headers(init?.headers);
+		headers.delete('Authorization');
+		headers.delete('authorization');
+		headers.set('Authorization', `Bearer ${config.oauth.refresh}`);
+		headers.set('Openai-Intent', 'conversation-edits');
+		headers.set('User-Agent', 'agi-cli');
+
+		return fetch(input, {
+			...init,
+			headers,
+		});
+	};
+}
+
+export function createCopilotModel(model: string, config: CopilotOAuthConfig) {
+	const customFetch = createCopilotFetch(config);
+
+	const provider = createOpenAICompatible({
+		name: 'github-copilot',
+		baseURL: COPILOT_BASE_URL,
+		apiKey: 'copilot-oauth',
+		fetch: customFetch,
+	});
+
+	return provider.chatModel(model);
+}

package/src/providers/src/env.ts

@@ -6,6 +6,7 @@ const ENV_VARS: Record<ProviderId, string> = {
 	google: 'GOOGLE_GENERATIVE_AI_API_KEY',
 	openrouter: 'OPENROUTER_API_KEY',
 	opencode: 'OPENCODE_API_KEY',
+	copilot: 'GITHUB_TOKEN',
 	setu: 'SETU_PRIVATE_KEY',
 	zai: 'ZAI_API_KEY',
 	'zai-coding': 'ZAI_API_KEY',

package/src/providers/src/index.ts

@@ -71,3 +71,5 @@ export { createOpencodeModel } from './opencode-client.ts';
 export type { OpencodeProviderConfig } from './opencode-client.ts';
 export { createMoonshotModel } from './moonshot-client.ts';
 export type { MoonshotProviderConfig } from './moonshot-client.ts';
+export { createCopilotFetch, createCopilotModel } from './copilot-client.ts';
+export type { CopilotOAuthConfig } from './copilot-client.ts';

package/src/providers/src/openai-oauth-client.ts

@@ -3,25 +3,18 @@ import type { OAuth } from '../../types/src/index.ts';
 import { refreshOpenAIToken } from '../../auth/src/openai-oauth.ts';
 import { setAuth, getAuth } from '../../auth/src/index.ts';
 
-const CHATGPT_BACKEND_URL = 'https://chatgpt.com/backend-api';
-const OPENAI_API_URL = 'https://api.openai.com/v1';
-
-const DEFAULT_INSTRUCTIONS = `You are a helpful coding assistant. Be concise and direct.`;
+const CODEX_API_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
 
 export type OpenAIOAuthConfig = {
 	oauth: OAuth;
 	projectRoot?: string;
-	instructions?: string;
-	reasoningEffort?: 'none' | 'low' | 'medium' | 'high' | 'xhigh';
-	reasoningSummary?: 'auto' | 'detailed';
 };
 
 async function ensureValidToken(
 	oauth: OAuth,
 	projectRoot?: string,
 ): Promise<{ access: string; accountId?: string }> {
-	const bufferMs = 5 * 60 * 1000;
-	if (oauth.expires > Date.now() + bufferMs) {
+	if (oauth.access && oauth.expires > Date.now()) {
 		return { access: oauth.access, accountId: oauth.accountId };
 	}
 
@@ -42,78 +35,19 @@ async function ensureValidToken(
 	}
 }
 
-function stripIdsFromInput(input: unknown): unknown {
-	if (Array.isArray(input)) {
-		const filtered = input.filter((item) => {
-			if (item && typeof item === 'object' && 'type' in item) {
-				if (item.type === 'item_reference') return false;
-			}
-			return true;
-		});
-
-		const validCallIds = new Set<string>();
-		for (const item of filtered) {
-			if (
-				item &&
-				typeof item === 'object' &&
-				'type' in item &&
-				item.type === 'function_call' &&
-				'call_id' in item &&
-				typeof item.call_id === 'string'
-			) {
-				validCallIds.add(item.call_id);
-			}
-		}
-
-		return filtered
-			.filter((item) => {
-				if (
-					item &&
-					typeof item === 'object' &&
-					'type' in item &&
-					item.type === 'function_call_output' &&
-					'call_id' in item &&
-					typeof item.call_id === 'string'
-				) {
-					return validCallIds.has(item.call_id);
-				}
-				return true;
-			})
-			.map((item) => {
-				if (item && typeof item === 'object') {
-					const result: Record<string, unknown> = {};
-					for (const [key, value] of Object.entries(item)) {
-						if (key === 'id') continue;
-						result[key] = stripIdsFromInput(value);
-					}
-					return result;
-				}
-				return item;
-			});
-	}
-	if (input && typeof input === 'object') {
-		const result: Record<string, unknown> = {};
-		for (const [key, value] of Object.entries(input)) {
-			if (key === 'id') continue;
-			result[key] = stripIdsFromInput(value);
-		}
-		return result;
-	}
-	return input;
-}
-
 function rewriteUrl(url: string): string {
-	if (url.includes('/responses')) {
-		return url
-			.replace(OPENAI_API_URL, CHATGPT_BACKEND_URL)
-			.replace('/responses', '/codex/responses');
+	const parsed = new URL(url);
+	if (
+		parsed.pathname.includes('/v1/responses') ||
+		parsed.pathname.includes('/chat/completions')
+	) {
+		return CODEX_API_ENDPOINT;
 	}
-	return url.replace(OPENAI_API_URL, CHATGPT_BACKEND_URL);
+	return url;
 }
 
 export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 	let currentOAuth = config.oauth;
-	const instructions = config.instructions || DEFAULT_INSTRUCTIONS;
 
 	const customFetch = async (
 		input: Parameters<typeof fetch>[0],
@@ -132,57 +66,17 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 					: input.url;
 		const targetUrl = rewriteUrl(originalUrl);
 
-		let body = init?.body;
-		if (body && typeof body === 'string') {
-			try {
-				const parsed = JSON.parse(body);
-
-				parsed.store = false;
-				// ChatGPT backend codex endpoint requires streaming
-				parsed.stream = true;
-				parsed.instructions = instructions;
-
-				if (parsed.input) {
-					parsed.input = stripIdsFromInput(parsed.input);
-				}
-
-				if (!parsed.include) {
-					parsed.include = ['reasoning.encrypted_content'];
-				} else if (
-					Array.isArray(parsed.include) &&
-					!parsed.include.includes('reasoning.encrypted_content')
-				) {
-					parsed.include.push('reasoning.encrypted_content');
-				}
-
-				const existingReasoning = parsed.reasoning || {};
-				parsed.reasoning = {
-					effort:
-						existingReasoning.effort || config.reasoningEffort || 'medium',
-					summary:
-						existingReasoning.summary || config.reasoningSummary || 'auto',
-				};
-
-				delete parsed.max_output_tokens;
-				delete parsed.max_completion_tokens;
-
-				body = JSON.stringify(parsed);
-			} catch {}
-		}
-
 		const headers = new Headers(init?.headers);
-		headers.delete('x-api-key');
-		headers.set('Authorization', `Bearer ${accessToken}`);
-		headers.set('OpenAI-Beta', 'responses=experimental');
-		headers.set('originator', 'codex_cli_rs');
-		headers.set('accept', 'text/event-stream');
+		headers.delete('Authorization');
+		headers.delete('authorization');
+		headers.set('authorization', `Bearer ${accessToken}`);
+		headers.set('originator', 'agi');
 		if (accountId) {
-			headers.set('chatgpt-account-id', accountId);
+			headers.set('ChatGPT-Account-Id', accountId);
 		}
 
 		const response = await fetch(targetUrl, {
 			...init,
-			body,
 			headers,
 		});
 
@@ -207,9 +101,8 @@ export function createOpenAIOAuthModel(
 
 	const provider = createOpenAI({
 		apiKey: 'chatgpt-oauth',
-		baseURL: CHATGPT_BACKEND_URL,
 		fetch: customFetch,
 	});
 
-	return provider(model);
+	return provider.responses(model);
 }

package/src/providers/src/pricing.ts

@@ -88,6 +88,7 @@ const pricingTable: Record<ProviderName, PricingEntry[]> = {
 	moonshot: [
 		// Pricing from catalog entries; leave empty here
 	],
+	copilot: [],
 };
 
 function findPricing(

package/src/providers/src/setu-client.ts

@@ -38,7 +38,7 @@ function simplifyPaymentError(errMsg: string): string {
 	return short.length < errMsg.length ? `${short}...` : errMsg;
 }
 
-const DEFAULT_BASE_URL = 'https://setu.agi.nitish.sh';
+const DEFAULT_BASE_URL = 'https://api.setu.nitish.sh';
 const DEFAULT_RPC_URL = 'https://api.mainnet-beta.solana.com';
 const DEFAULT_MAX_ATTEMPTS = 3;
 const DEFAULT_MAX_PAYMENT_ATTEMPTS = 20;

package/src/providers/src/utils.ts

@@ -48,6 +48,7 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 		'codex-mini-latest',
 	],
 	zai: ['glm-4.5-flash', 'glm-4.5-air'],
+	copilot: ['gpt-4o-mini', 'gpt-4.1-nano', 'gpt-4.1-mini'],
 };
 
 export function getFastModel(provider: ProviderId): string | undefined {
@@ -150,6 +151,7 @@ export function getUnderlyingProviderKey(
 	if (provider === 'openai') return 'openai';
 	if (provider === 'google') return 'google';
 	if (provider === 'moonshot') return 'moonshot';
+	if (provider === 'copilot') return 'openai';
 
 	const npm = getModelNpmBinding(provider, model);
 	if (npm === '@ai-sdk/anthropic') return 'anthropic';
@@ -169,6 +171,7 @@ export function getModelFamily(
 	if (provider === 'openai') return 'openai';
 	if (provider === 'google') return 'google';
 	if (provider === 'moonshot') return 'moonshot';
+	if (provider === 'copilot') return 'openai';
 
 	// 2) For aggregate providers, infer from model ID patterns
 	if (provider === 'openrouter' || provider === 'opencode') {

package/src/types/src/index.ts

@@ -1,6 +1,7 @@
 // Provider types
 export type {
 	ProviderId,
+	ProviderFamily,
 	ModelInfo,
 	ModelProviderBinding,
 	ProviderCatalogEntry,

package/src/types/src/provider.ts

@@ -7,6 +7,7 @@ export type ProviderId =
 	| 'google'
 	| 'openrouter'
 	| 'opencode'
+	| 'copilot'
 	| 'setu'
 	| 'zai'
 	| 'zai-coding'