feat: update grok-cli ai sdk provider to v5 (#1252)

packages/ai-sdk-provider-grok-cli/README.md

@@ -0,0 +1,165 @@
+# AI SDK Provider for Grok CLI
+
+A provider for the [AI SDK](https://sdk.vercel.ai) that integrates with [Grok CLI](https://docs.x.ai/api) for accessing xAI's Grok language models.
+
+## Features
+
+- ✅ **AI SDK v5 Compatible** - Full support for the latest AI SDK interfaces
+- ✅ **Streaming & Non-streaming** - Both generation modes supported
+- ✅ **Error Handling** - Comprehensive error handling with retry logic
+- ✅ **Type Safety** - Full TypeScript support with proper type definitions
+- ✅ **JSON Mode** - Automatic JSON extraction from responses
+- ✅ **Abort Signals** - Proper cancellation support
+
+## Installation
+
+```bash
+npm install @tm/ai-sdk-provider-grok-cli
+# or
+yarn add @tm/ai-sdk-provider-grok-cli
+```
+
+## Prerequisites
+
+1. Install the Grok CLI:
+
+   ```bash
+   npm install -g grok-cli
+   # or follow xAI's installation instructions
+   ```
+
+2. Set up authentication:
+
+   ```bash
+   export GROK_CLI_API_KEY="your-api-key"
+   # or configure via grok CLI: grok config set api-key your-key
+   ```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { grokCli } from '@tm/ai-sdk-provider-grok-cli';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: grokCli('grok-3-latest'),
+  prompt: 'Write a haiku about TypeScript'
+});
+
+console.log(result.text);
+```
+
+### Streaming
+
+```typescript
+import { grokCli } from '@tm/ai-sdk-provider-grok-cli';
+import { streamText } from 'ai';
+
+const { textStream } = await streamText({
+  model: grokCli('grok-4-latest'),
+  prompt: 'Explain quantum computing'
+});
+
+for await (const delta of textStream) {
+  process.stdout.write(delta);
+}
+```
+
+### JSON Mode
+
+```typescript
+import { grokCli } from '@tm/ai-sdk-provider-grok-cli';
+import { generateObject } from 'ai';
+import { z } from 'zod';
+
+const result = await generateObject({
+  model: grokCli('grok-3-latest'),
+  schema: z.object({
+    name: z.string(),
+    age: z.number(),
+    hobbies: z.array(z.string())
+  }),
+  prompt: 'Generate a person profile'
+});
+
+console.log(result.object);
+```
+
+## Supported Models
+
+- `grok-3-latest` - Grok 3 (latest version)
+- `grok-4-latest` - Grok 4 (latest version)
+- `grok-4` - Grok 4 (stable)
+- Custom model strings supported
+
+## Configuration
+
+### Provider Settings
+
+```typescript
+import { createGrokCli } from '@tm/ai-sdk-provider-grok-cli';
+
+const grok = createGrokCli({
+  apiKey: 'your-api-key', // Optional if set via env/CLI
+  timeout: 120000, // 2 minutes default
+  workingDirectory: '/path/to/project', // Optional
+  baseURL: 'https://api.x.ai' // Optional
+});
+```
+
+### Model Settings
+
+```typescript
+const model = grok('grok-4-latest', {
+  timeout: 300000, // 5 minutes for grok-4
+  // Other CLI-specific settings
+});
+```
+
+## Error Handling
+
+The provider includes comprehensive error handling:
+
+```typescript
+import {
+  isAuthenticationError,
+  isTimeoutError,
+  isInstallationError
+} from '@tm/ai-sdk-provider-grok-cli';
+
+try {
+  const result = await generateText({
+    model: grokCli('grok-4-latest'),
+    prompt: 'Hello!'
+  });
+} catch (error) {
+  if (isAuthenticationError(error)) {
+    console.error('Authentication failed:', error.message);
+  } else if (isTimeoutError(error)) {
+    console.error('Request timed out:', error.message);
+  } else if (isInstallationError(error)) {
+    console.error('Grok CLI not installed or not found in PATH');
+  }
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Start development mode (keep running during development)
+npm run dev
+
+# Type check
+npm run typecheck
+
+# Run tests (requires build first)
+NODE_ENV=production npm run build
+npm test
+```
+
+**Important**: Always run `npm run dev` and keep it running during development. This ensures proper compilation and hot-reloading of TypeScript files.

packages/ai-sdk-provider-grok-cli/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@tm/ai-sdk-provider-grok-cli",
+	"private": true,
+	"description": "AI SDK provider for Grok CLI integration",
+	"keywords": ["ai", "grok", "x.ai", "cli", "language-model", "provider"],
+	"license": "MIT",
+	"sideEffects": false,
+	"main": "./dist/index.js",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"files": ["dist/**/*", "README.md"],
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:ui": "vitest --ui",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@ai-sdk/provider": "^2.0.0",
+		"@ai-sdk/provider-utils": "^3.0.10",
+		"jsonc-parser": "^3.3.1"
+	},
+	"devDependencies": {
+		"@types/node": "^22.18.6",
+		"typescript": "^5.9.2",
+		"vitest": "^3.2.4"
+	},
+	"peerDependencies": {
+		"@ai-sdk/provider": "^2.0.0",
+		"@ai-sdk/provider-utils": "^3.0.10",
+		"jsonc-parser": "^3.3.1"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

packages/ai-sdk-provider-grok-cli/src/errors.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Tests for error handling utilities
+ */
+
+import { APICallError, LoadAPIKeyError } from '@ai-sdk/provider';
+import { describe, expect, it } from 'vitest';
+import {
+	createAPICallError,
+	createAuthenticationError,
+	createInstallationError,
+	createTimeoutError,
+	getErrorMetadata,
+	isAuthenticationError,
+	isInstallationError,
+	isTimeoutError
+} from './errors.js';
+
+describe('createAPICallError', () => {
+	it('should create APICallError with metadata', () => {
+		const error = createAPICallError({
+			message: 'Test error',
+			code: 'TEST_ERROR',
+			exitCode: 1,
+			stderr: 'Error output',
+			stdout: 'Success output',
+			promptExcerpt: 'Test prompt',
+			isRetryable: true
+		});
+
+		expect(error).toBeInstanceOf(APICallError);
+		expect(error.message).toBe('Test error');
+		expect(error.isRetryable).toBe(true);
+		expect(error.url).toBe('grok-cli://command');
+		expect(error.data).toEqual({
+			code: 'TEST_ERROR',
+			exitCode: 1,
+			stderr: 'Error output',
+			stdout: 'Success output',
+			promptExcerpt: 'Test prompt'
+		});
+	});
+
+	it('should create APICallError with minimal parameters', () => {
+		const error = createAPICallError({
+			message: 'Simple error'
+		});
+
+		expect(error).toBeInstanceOf(APICallError);
+		expect(error.message).toBe('Simple error');
+		expect(error.isRetryable).toBe(false);
+	});
+});
+
+describe('createAuthenticationError', () => {
+	it('should create LoadAPIKeyError with custom message', () => {
+		const error = createAuthenticationError({
+			message: 'Custom auth error'
+		});
+
+		expect(error).toBeInstanceOf(LoadAPIKeyError);
+		expect(error.message).toBe('Custom auth error');
+	});
+
+	it('should create LoadAPIKeyError with default message', () => {
+		const error = createAuthenticationError({});
+
+		expect(error).toBeInstanceOf(LoadAPIKeyError);
+		expect(error.message).toContain('Authentication failed');
+	});
+});
+
+describe('createTimeoutError', () => {
+	it('should create APICallError for timeout', () => {
+		const error = createTimeoutError({
+			message: 'Operation timed out',
+			timeoutMs: 5000,
+			promptExcerpt: 'Test prompt'
+		});
+
+		expect(error).toBeInstanceOf(APICallError);
+		expect(error.message).toBe('Operation timed out');
+		expect(error.isRetryable).toBe(true);
+		expect(error.data).toEqual({
+			code: 'TIMEOUT',
+			promptExcerpt: 'Test prompt',
+			timeoutMs: 5000
+		});
+	});
+});
+
+describe('createInstallationError', () => {
+	it('should create APICallError for installation issues', () => {
+		const error = createInstallationError({
+			message: 'CLI not found'
+		});
+
+		expect(error).toBeInstanceOf(APICallError);
+		expect(error.message).toBe('CLI not found');
+		expect(error.isRetryable).toBe(false);
+		expect(error.url).toBe('grok-cli://installation');
+	});
+
+	it('should create APICallError with default message', () => {
+		const error = createInstallationError({});
+
+		expect(error).toBeInstanceOf(APICallError);
+		expect(error.message).toContain('Grok CLI is not installed');
+	});
+});
+
+describe('isAuthenticationError', () => {
+	it('should return true for LoadAPIKeyError', () => {
+		const error = new LoadAPIKeyError({ message: 'Auth failed' });
+		expect(isAuthenticationError(error)).toBe(true);
+	});
+
+	it('should return true for APICallError with 401 exit code', () => {
+		const error = new APICallError({
+			message: 'Unauthorized',
+			data: { exitCode: 401 }
+		});
+		expect(isAuthenticationError(error)).toBe(true);
+	});
+
+	it('should return false for other errors', () => {
+		const error = new Error('Generic error');
+		expect(isAuthenticationError(error)).toBe(false);
+	});
+});
+
+describe('isTimeoutError', () => {
+	it('should return true for timeout APICallError', () => {
+		const error = new APICallError({
+			message: 'Timeout',
+			data: { code: 'TIMEOUT' }
+		});
+		expect(isTimeoutError(error)).toBe(true);
+	});
+
+	it('should return false for other errors', () => {
+		const error = new APICallError({ message: 'Other error' });
+		expect(isTimeoutError(error)).toBe(false);
+	});
+});
+
+describe('isInstallationError', () => {
+	it('should return true for installation APICallError', () => {
+		const error = new APICallError({
+			message: 'Not installed',
+			url: 'grok-cli://installation'
+		});
+		expect(isInstallationError(error)).toBe(true);
+	});
+
+	it('should return false for other errors', () => {
+		const error = new APICallError({ message: 'Other error' });
+		expect(isInstallationError(error)).toBe(false);
+	});
+});
+
+describe('getErrorMetadata', () => {
+	it('should return metadata from APICallError', () => {
+		const metadata = {
+			code: 'TEST_ERROR',
+			exitCode: 1,
+			stderr: 'Error output'
+		};
+		const error = new APICallError({
+			message: 'Test error',
+			data: metadata
+		});
+
+		const result = getErrorMetadata(error);
+		expect(result).toEqual(metadata);
+	});
+
+	it('should return undefined for errors without metadata', () => {
+		const error = new Error('Generic error');
+		const result = getErrorMetadata(error);
+		expect(result).toBeUndefined();
+	});
+
+	it('should return undefined for APICallError without data', () => {
+		const error = new APICallError({ message: 'Test error' });
+		const result = getErrorMetadata(error);
+		expect(result).toBeUndefined();
+	});
+});

packages/ai-sdk-provider-grok-cli/src/errors.ts

@@ -0,0 +1,187 @@
+/**
+ * Error handling utilities for Grok CLI provider
+ */
+
+import { APICallError, LoadAPIKeyError } from '@ai-sdk/provider';
+import type { GrokCliErrorMetadata } from './types.js';
+
+/**
+ * Parameters for creating API call errors
+ */
+interface CreateAPICallErrorParams {
+	/** Error message */
+	message: string;
+	/** Error code */
+	code?: string;
+	/** Process exit code */
+	exitCode?: number;
+	/** Standard error output */
+	stderr?: string;
+	/** Standard output */
+	stdout?: string;
+	/** Excerpt of the prompt */
+	promptExcerpt?: string;
+	/** Whether the error is retryable */
+	isRetryable?: boolean;
+}
+
+/**
+ * Parameters for creating authentication errors
+ */
+interface CreateAuthenticationErrorParams {
+	/** Error message */
+	message?: string;
+}
+
+/**
+ * Parameters for creating timeout errors
+ */
+interface CreateTimeoutErrorParams {
+	/** Error message */
+	message: string;
+	/** Excerpt of the prompt */
+	promptExcerpt?: string;
+	/** Timeout in milliseconds */
+	timeoutMs: number;
+}
+
+/**
+ * Parameters for creating installation errors
+ */
+interface CreateInstallationErrorParams {
+	/** Error message */
+	message?: string;
+}
+
+/**
+ * Create an API call error with Grok CLI specific metadata
+ */
+export function createAPICallError({
+	message,
+	code,
+	exitCode,
+	stderr,
+	stdout,
+	promptExcerpt,
+	isRetryable = false
+}: CreateAPICallErrorParams): APICallError {
+	const metadata: GrokCliErrorMetadata = {
+		code,
+		exitCode,
+		stderr,
+		stdout,
+		promptExcerpt
+	};
+
+	return new APICallError({
+		message,
+		isRetryable,
+		url: 'grok-cli://command',
+		requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : undefined,
+		data: metadata
+	});
+}
+
+/**
+ * Create an authentication error
+ */
+export function createAuthenticationError({
+	message
+}: CreateAuthenticationErrorParams): LoadAPIKeyError {
+	return new LoadAPIKeyError({
+		message:
+			message ||
+			'Authentication failed. Please ensure Grok CLI is properly configured with API key.'
+	});
+}
+
+/**
+ * Create a timeout error
+ */
+export function createTimeoutError({
+	message,
+	promptExcerpt,
+	timeoutMs
+}: CreateTimeoutErrorParams): APICallError {
+	const metadata: GrokCliErrorMetadata & { timeoutMs: number } = {
+		code: 'TIMEOUT',
+		promptExcerpt,
+		timeoutMs
+	};
+
+	return new APICallError({
+		message,
+		isRetryable: true,
+		url: 'grok-cli://command',
+		requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : undefined,
+		data: metadata
+	});
+}
+
+/**
+ * Create a CLI installation error
+ */
+export function createInstallationError({
+	message
+}: CreateInstallationErrorParams): APICallError {
+	return new APICallError({
+		message:
+			message ||
+			'Grok CLI is not installed or not found in PATH. Please install with: npm install -g @vibe-kit/grok-cli',
+		isRetryable: false,
+		url: 'grok-cli://installation',
+		requestBodyValues: undefined
+	});
+}
+
+/**
+ * Check if an error is an authentication error
+ */
+export function isAuthenticationError(
+	error: unknown
+): error is LoadAPIKeyError {
+	if (error instanceof LoadAPIKeyError) return true;
+	if (error instanceof APICallError) {
+		const metadata = error.data as GrokCliErrorMetadata | undefined;
+		if (!metadata) return false;
+		return (
+			metadata.exitCode === 401 ||
+			metadata.code === 'AUTHENTICATION_ERROR' ||
+			metadata.code === 'UNAUTHORIZED'
+		);
+	}
+	return false;
+}
+
+/**
+ * Check if an error is a timeout error
+ */
+export function isTimeoutError(error: unknown): error is APICallError {
+	if (
+		error instanceof APICallError &&
+		(error.data as GrokCliErrorMetadata)?.code === 'TIMEOUT'
+	)
+		return true;
+	return false;
+}
+
+/**
+ * Check if an error is an installation error
+ */
+export function isInstallationError(error: unknown): error is APICallError {
+	if (error instanceof APICallError && error.url === 'grok-cli://installation')
+		return true;
+	return false;
+}
+
+/**
+ * Get error metadata from an error
+ */
+export function getErrorMetadata(
+	error: unknown
+): GrokCliErrorMetadata | undefined {
+	if (error instanceof APICallError && error.data) {
+		return error.data as GrokCliErrorMetadata;
+	}
+	return undefined;
+}

packages/ai-sdk-provider-grok-cli/src/grok-cli-language-model.ts

@@ -0,0 +1,513 @@
+/**
+ * Grok CLI Language Model implementation for AI SDK v5
+ */
+
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import type {
+	LanguageModelV2,
+	LanguageModelV2CallOptions,
+	LanguageModelV2CallWarning
+} from '@ai-sdk/provider';
+import { NoSuchModelError } from '@ai-sdk/provider';
+import { generateId } from '@ai-sdk/provider-utils';
+
+import {
+	createAPICallError,
+	createAuthenticationError,
+	createInstallationError,
+	createTimeoutError
+} from './errors.js';
+import { extractJson } from './json-extractor.js';
+import {
+	convertFromGrokCliResponse,
+	createPromptFromMessages,
+	escapeShellArg
+} from './message-converter.js';
+import type {
+	GrokCliLanguageModelOptions,
+	GrokCliModelId,
+	GrokCliSettings
+} from './types.js';
+
+/**
+ * Grok CLI Language Model implementation for AI SDK v5
+ */
+export class GrokCliLanguageModel implements LanguageModelV2 {
+	readonly specificationVersion = 'v2' as const;
+	readonly defaultObjectGenerationMode = 'json' as const;
+	readonly supportsImageUrls = false;
+	readonly supportsStructuredOutputs = false;
+	readonly supportedUrls: Record<string, RegExp[]> = {};
+
+	readonly modelId: GrokCliModelId;
+	readonly settings: GrokCliSettings;
+
+	constructor(options: GrokCliLanguageModelOptions) {
+		this.modelId = options.id;
+		this.settings = options.settings ?? {};
+
+		// Validate model ID format
+		if (
+			!this.modelId ||
+			typeof this.modelId !== 'string' ||
+			this.modelId.trim() === ''
+		) {
+			throw new NoSuchModelError({
+				modelId: this.modelId,
+				modelType: 'languageModel'
+			});
+		}
+	}
+
+	get provider(): string {
+		return 'grok-cli';
+	}
+
+	/**
+	 * Check if Grok CLI is installed and available
+	 */
+	private async checkGrokCliInstallation(): Promise<boolean> {
+		return new Promise((resolve) => {
+			const child = spawn('grok', ['--version'], {
+				stdio: 'pipe'
+			});
+
+			child.on('error', () => resolve(false));
+			child.on('exit', (code) => resolve(code === 0));
+		});
+	}
+
+	/**
+	 * Get API key from settings or environment
+	 */
+	private async getApiKey(): Promise<string | null> {
+		// Check settings first
+		if (this.settings.apiKey) {
+			return this.settings.apiKey;
+		}
+
+		// Check environment variable
+		if (process.env.GROK_CLI_API_KEY) {
+			return process.env.GROK_CLI_API_KEY;
+		}
+
+		// Check grok-cli config file
+		try {
+			const configPath = join(homedir(), '.grok', 'user-settings.json');
+			const configContent = await fs.readFile(configPath, 'utf8');
+			const config = JSON.parse(configContent);
+			return config.apiKey || null;
+		} catch (error) {
+			return null;
+		}
+	}
+
+	/**
+	 * Execute Grok CLI command
+	 */
+	private async executeGrokCli(
+		args: string[],
+		options: { timeout?: number } = {}
+	): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+		// Default timeout based on model type
+		let defaultTimeout = 120000; // 2 minutes default
+		if (this.modelId.includes('grok-4')) {
+			defaultTimeout = 600000; // 10 minutes for grok-4 models (they seem to hang during setup)
+		}
+
+		const timeout = options.timeout ?? this.settings.timeout ?? defaultTimeout;
+
+		return new Promise((resolve, reject) => {
+			const child = spawn('grok', args, {
+				stdio: 'pipe',
+				cwd: this.settings.workingDirectory || process.cwd()
+			});
+
+			let stdout = '';
+			let stderr = '';
+			let timeoutId: NodeJS.Timeout | undefined;
+
+			// Set up timeout
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					child.kill('SIGTERM');
+					reject(
+						createTimeoutError({
+							message: `Grok CLI command timed out after ${timeout}ms`,
+							timeoutMs: timeout,
+							promptExcerpt: args.join(' ').substring(0, 200)
+						})
+					);
+				}, timeout);
+			}
+
+			child.stdout?.on('data', (data) => {
+				const chunk = data.toString();
+				stdout += chunk;
+			});
+
+			child.stderr?.on('data', (data) => {
+				const chunk = data.toString();
+				stderr += chunk;
+			});
+
+			child.on('error', (error) => {
+				if (timeoutId) clearTimeout(timeoutId);
+
+				if ((error as any).code === 'ENOENT') {
+					reject(createInstallationError({}));
+				} else {
+					reject(
+						createAPICallError({
+							message: `Failed to execute Grok CLI: ${error.message}`,
+							code: (error as any).code,
+							stderr: error.message,
+							isRetryable: false
+						})
+					);
+				}
+			});
+
+			child.on('exit', (exitCode) => {
+				if (timeoutId) clearTimeout(timeoutId);
+
+				resolve({
+					stdout: stdout.trim(),
+					stderr: stderr.trim(),
+					exitCode: exitCode || 0
+				});
+			});
+		});
+	}
+
+	/**
+	 * Generate comprehensive warnings for unsupported parameters and validation issues
+	 */
+	private generateAllWarnings(
+		options: LanguageModelV2CallOptions,
+		prompt: string
+	): LanguageModelV2CallWarning[] {
+		const warnings: LanguageModelV2CallWarning[] = [];
+		const unsupportedParams: string[] = [];
+
+		// Check for unsupported parameters
+		if (options.temperature !== undefined)
+			unsupportedParams.push('temperature');
+		if (options.topP !== undefined) unsupportedParams.push('topP');
+		if (options.topK !== undefined) unsupportedParams.push('topK');
+		if (options.presencePenalty !== undefined)
+			unsupportedParams.push('presencePenalty');
+		if (options.frequencyPenalty !== undefined)
+			unsupportedParams.push('frequencyPenalty');
+		if (options.stopSequences !== undefined && options.stopSequences.length > 0)
+			unsupportedParams.push('stopSequences');
+		if (options.seed !== undefined) unsupportedParams.push('seed');
+
+		if (unsupportedParams.length > 0) {
+			// Add a warning for each unsupported parameter
+			for (const param of unsupportedParams) {
+				warnings.push({
+					type: 'unsupported-setting',
+					setting: param as
+						| 'temperature'
+						| 'topP'
+						| 'topK'
+						| 'presencePenalty'
+						| 'frequencyPenalty'
+						| 'stopSequences'
+						| 'seed',
+					details: `Grok CLI does not support the ${param} parameter. It will be ignored.`
+				});
+			}
+		}
+
+		// Add model validation warnings if needed
+		if (!this.modelId || this.modelId.trim() === '') {
+			warnings.push({
+				type: 'other',
+				message: 'Model ID is empty or invalid'
+			});
+		}
+
+		// Add prompt validation
+		if (!prompt || prompt.trim() === '') {
+			warnings.push({
+				type: 'other',
+				message: 'Prompt is empty'
+			});
+		}
+
+		return warnings;
+	}
+
+	/**
+	 * Generate text using Grok CLI
+	 */
+	async doGenerate(options: LanguageModelV2CallOptions) {
+		// Handle abort signal early
+		if (options.abortSignal?.aborted) {
+			throw options.abortSignal.reason || new Error('Request aborted');
+		}
+
+		// Check CLI installation
+		const isInstalled = await this.checkGrokCliInstallation();
+		if (!isInstalled) {
+			throw createInstallationError({});
+		}
+
+		// Get API key
+		const apiKey = await this.getApiKey();
+		if (!apiKey) {
+			throw createAuthenticationError({
+				message:
+					'Grok CLI API key not found. Set GROK_CLI_API_KEY environment variable or configure grok-cli.'
+			});
+		}
+
+		const prompt = createPromptFromMessages(options.prompt);
+		const warnings = this.generateAllWarnings(options, prompt);
+
+		// Build command arguments
+		const args = ['--prompt', escapeShellArg(prompt)];
+
+		// Add model if specified
+		if (this.modelId && this.modelId !== 'default') {
+			args.push('--model', this.modelId);
+		}
+
+		// Skip API key parameter if it's likely already configured to avoid hanging
+		// The CLI seems to hang when trying to save API keys for grok-4 models
+		// if (apiKey) {
+		//	args.push('--api-key', apiKey);
+		// }
+
+		// Add base URL if provided in settings
+		if (this.settings.baseURL) {
+			args.push('--base-url', this.settings.baseURL);
+		}
+
+		// Add working directory if specified
+		if (this.settings.workingDirectory) {
+			args.push('--directory', this.settings.workingDirectory);
+		}
+
+		try {
+			const result = await this.executeGrokCli(args);
+
+			if (result.exitCode !== 0) {
+				// Handle authentication errors
+				if (
+					result.stderr.toLowerCase().includes('unauthorized') ||
+					result.stderr.toLowerCase().includes('authentication')
+				) {
+					throw createAuthenticationError({
+						message: `Grok CLI authentication failed: ${result.stderr}`
+					});
+				}
+
+				throw createAPICallError({
+					message: `Grok CLI failed with exit code ${result.exitCode}: ${result.stderr || 'Unknown error'}`,
+					exitCode: result.exitCode,
+					stderr: result.stderr,
+					stdout: result.stdout,
+					promptExcerpt: prompt.substring(0, 200),
+					isRetryable: false
+				});
+			}
+
+			// Parse response
+			const response = convertFromGrokCliResponse(result.stdout);
+			let text = response.text || '';
+
+			// Extract JSON if in object-json mode
+			if (
+				'mode' in options &&
+				(options as any).mode?.type === 'object-json' &&
+				text
+			) {
+				text = extractJson(text);
+			}
+
+			return {
+				content: [
+					{
+						type: 'text' as const,
+						text: text || ''
+					}
+				],
+				usage: response.usage
+					? {
+							inputTokens: response.usage.promptTokens,
+							outputTokens: response.usage.completionTokens,
+							totalTokens: response.usage.totalTokens
+						}
+					: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+				finishReason: 'stop' as const,
+				rawCall: {
+					rawPrompt: prompt,
+					rawSettings: args
+				},
+				warnings: warnings,
+				response: {
+					id: generateId(),
+					timestamp: new Date(),
+					modelId: this.modelId
+				},
+				request: {
+					body: prompt
+				},
+				providerMetadata: {
+					'grok-cli': {
+						exitCode: result.exitCode,
+						...(result.stderr && { stderr: result.stderr })
+					}
+				}
+			};
+		} catch (error) {
+			// Re-throw our custom errors
+			if (
+				(error as any).name === 'APICallError' ||
+				(error as any).name === 'LoadAPIKeyError'
+			) {
+				throw error;
+			}
+
+			// Wrap other errors
+			throw createAPICallError({
+				message: `Grok CLI execution failed: ${(error as Error).message}`,
+				code: (error as any).code,
+				promptExcerpt: prompt.substring(0, 200),
+				isRetryable: false
+			});
+		}
+	}
+
+	/**
+	 * Stream text using Grok CLI
+	 * Note: Grok CLI doesn't natively support streaming, so this simulates streaming
+	 * by generating the full response and then streaming it in chunks
+	 */
+	async doStream(options: LanguageModelV2CallOptions) {
+		const prompt = createPromptFromMessages(options.prompt);
+		const warnings = this.generateAllWarnings(options, prompt);
+
+		const stream = new ReadableStream({
+			start: async (controller) => {
+				let abortListener: (() => void) | undefined;
+
+				try {
+					// Handle abort signal
+					if (options.abortSignal?.aborted) {
+						throw options.abortSignal.reason || new Error('Request aborted');
+					}
+
+					// Set up abort listener
+					if (options.abortSignal) {
+						abortListener = () => {
+							controller.enqueue({
+								type: 'error',
+								error:
+									options.abortSignal?.reason || new Error('Request aborted')
+							});
+							controller.close();
+						};
+						options.abortSignal.addEventListener('abort', abortListener, {
+							once: true
+						});
+					}
+
+					// Emit stream-start with warnings
+					controller.enqueue({ type: 'stream-start', warnings });
+
+					// Generate the full response first
+					const result = await this.doGenerate(options);
+
+					// Emit response metadata
+					controller.enqueue({
+						type: 'response-metadata',
+						id: result.response.id,
+						timestamp: result.response.timestamp,
+						modelId: result.response.modelId
+					});
+
+					// Simulate streaming by chunking the text
+					const content = result.content || [];
+					const text =
+						content.length > 0 && content[0].type === 'text'
+							? content[0].text
+							: '';
+					const chunkSize = 50; // Characters per chunk
+					let textPartId: string | undefined;
+
+					// Emit text-start if we have content
+					if (text.length > 0) {
+						textPartId = generateId();
+						controller.enqueue({
+							type: 'text-start',
+							id: textPartId
+						});
+					}
+
+					for (let i = 0; i < text.length; i += chunkSize) {
+						// Check for abort during streaming
+						if (options.abortSignal?.aborted) {
+							throw options.abortSignal.reason || new Error('Request aborted');
+						}
+
+						const chunk = text.slice(i, i + chunkSize);
+						controller.enqueue({
+							type: 'text-delta',
+							id: textPartId!,
+							delta: chunk
+						});
+
+						// Add small delay to simulate streaming
+						await new Promise((resolve) => setTimeout(resolve, 20));
+					}
+
+					// Close text part if opened
+					if (textPartId) {
+						controller.enqueue({
+							type: 'text-end',
+							id: textPartId
+						});
+					}
+
+					// Emit finish event
+					controller.enqueue({
+						type: 'finish',
+						finishReason: result.finishReason,
+						usage: result.usage,
+						providerMetadata: result.providerMetadata
+					});
+
+					controller.close();
+				} catch (error) {
+					controller.enqueue({
+						type: 'error',
+						error
+					});
+					controller.close();
+				} finally {
+					// Clean up abort listener
+					if (options.abortSignal && abortListener) {
+						options.abortSignal.removeEventListener('abort', abortListener);
+					}
+				}
+			},
+			cancel: () => {
+				// Clean up if stream is cancelled
+			}
+		});
+
+		return {
+			stream,
+			request: {
+				body: prompt
+			}
+		};
+	}
+}

packages/ai-sdk-provider-grok-cli/src/grok-cli-provider.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for Grok CLI provider
+ */
+
+import { NoSuchModelError } from '@ai-sdk/provider';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { GrokCliLanguageModel } from './grok-cli-language-model.js';
+import { createGrokCli, grokCli } from './grok-cli-provider.js';
+
+// Mock the GrokCliLanguageModel
+vi.mock('./grok-cli-language-model.js', () => ({
+	GrokCliLanguageModel: vi.fn().mockImplementation((options) => ({
+		modelId: options.id,
+		settings: options.settings,
+		provider: 'grok-cli'
+	}))
+}));
+
+describe('createGrokCli', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should create a provider with default settings', () => {
+		const provider = createGrokCli();
+		expect(typeof provider).toBe('function');
+		expect(typeof provider.languageModel).toBe('function');
+		expect(typeof provider.chat).toBe('function');
+		expect(typeof provider.textEmbeddingModel).toBe('function');
+		expect(typeof provider.imageModel).toBe('function');
+	});
+
+	it('should create a provider with custom default settings', () => {
+		const defaultSettings = {
+			timeout: 5000,
+			workingDirectory: '/custom/path'
+		};
+		const provider = createGrokCli({ defaultSettings });
+
+		const model = provider('grok-2-mini');
+
+		expect(GrokCliLanguageModel).toHaveBeenCalledWith({
+			id: 'grok-2-mini',
+			settings: defaultSettings
+		});
+	});
+
+	it('should create language models with merged settings', () => {
+		const defaultSettings = { timeout: 5000 };
+		const provider = createGrokCli({ defaultSettings });
+
+		const modelSettings = { apiKey: 'test-key' };
+		const model = provider('grok-2', modelSettings);
+
+		expect(GrokCliLanguageModel).toHaveBeenCalledWith({
+			id: 'grok-2',
+			settings: { timeout: 5000, apiKey: 'test-key' }
+		});
+	});
+
+	it('should create models via languageModel method', () => {
+		const provider = createGrokCli();
+		const model = provider.languageModel('grok-2-mini', { timeout: 1000 });
+
+		expect(GrokCliLanguageModel).toHaveBeenCalledWith({
+			id: 'grok-2-mini',
+			settings: { timeout: 1000 }
+		});
+	});
+
+	it('should create models via chat method (alias)', () => {
+		const provider = createGrokCli();
+		const model = provider.chat('grok-2');
+
+		expect(GrokCliLanguageModel).toHaveBeenCalledWith({
+			id: 'grok-2',
+			settings: {}
+		});
+	});
+
+	it('should throw error when called with new keyword', () => {
+		const provider = createGrokCli();
+		expect(() => {
+			// @ts-expect-error - intentionally testing invalid usage
+			new provider('grok-2');
+		}).toThrow(
+			'The Grok CLI model function cannot be called with the new keyword.'
+		);
+	});
+
+	it('should throw NoSuchModelError for textEmbeddingModel', () => {
+		const provider = createGrokCli();
+		expect(() => {
+			provider.textEmbeddingModel('test-model');
+		}).toThrow(NoSuchModelError);
+	});
+
+	it('should throw NoSuchModelError for imageModel', () => {
+		const provider = createGrokCli();
+		expect(() => {
+			provider.imageModel('test-model');
+		}).toThrow(NoSuchModelError);
+	});
+});
+
+describe('default grokCli provider', () => {
+	it('should be a pre-configured provider instance', () => {
+		expect(typeof grokCli).toBe('function');
+		expect(typeof grokCli.languageModel).toBe('function');
+		expect(typeof grokCli.chat).toBe('function');
+	});
+
+	it('should create models with default configuration', () => {
+		const model = grokCli('grok-2-mini');
+
+		expect(GrokCliLanguageModel).toHaveBeenCalledWith({
+			id: 'grok-2-mini',
+			settings: {}
+		});
+	});
+});

packages/ai-sdk-provider-grok-cli/src/grok-cli-provider.ts

@@ -0,0 +1,108 @@
+/**
+ * Grok CLI provider implementation for AI SDK v5
+ */
+
+import type { LanguageModelV2, ProviderV2 } from '@ai-sdk/provider';
+import { NoSuchModelError } from '@ai-sdk/provider';
+import { GrokCliLanguageModel } from './grok-cli-language-model.js';
+import type { GrokCliModelId, GrokCliSettings } from './types.js';
+
+/**
+ * Grok CLI provider interface that extends the AI SDK's ProviderV2
+ */
+export interface GrokCliProvider extends ProviderV2 {
+	/**
+	 * Creates a language model instance for the specified model ID.
+	 * This is a shorthand for calling `languageModel()`.
+	 */
+	(modelId: GrokCliModelId, settings?: GrokCliSettings): LanguageModelV2;
+
+	/**
+	 * Creates a language model instance for text generation.
+	 */
+	languageModel(
+		modelId: GrokCliModelId,
+		settings?: GrokCliSettings
+	): LanguageModelV2;
+
+	/**
+	 * Alias for `languageModel()` to maintain compatibility with AI SDK patterns.
+	 */
+	chat(modelId: GrokCliModelId, settings?: GrokCliSettings): LanguageModelV2;
+
+	textEmbeddingModel(modelId: string): never;
+	imageModel(modelId: string): never;
+}
+
+/**
+ * Configuration options for creating a Grok CLI provider instance
+ */
+export interface GrokCliProviderSettings {
+	/**
+	 * Default settings to use for all models created by this provider.
+	 * Individual model settings will override these defaults.
+	 */
+	defaultSettings?: GrokCliSettings;
+}
+
+/**
+ * Creates a Grok CLI provider instance with the specified configuration.
+ * The provider can be used to create language models for interacting with Grok models.
+ */
+export function createGrokCli(
+	options: GrokCliProviderSettings = {}
+): GrokCliProvider {
+	const createModel = (
+		modelId: GrokCliModelId,
+		settings: GrokCliSettings = {}
+	): LanguageModelV2 => {
+		const mergedSettings = {
+			...options.defaultSettings,
+			...settings
+		};
+
+		return new GrokCliLanguageModel({
+			id: modelId,
+			settings: mergedSettings
+		});
+	};
+
+	const provider = function (
+		modelId: GrokCliModelId,
+		settings?: GrokCliSettings
+	) {
+		if (new.target) {
+			throw new Error(
+				'The Grok CLI model function cannot be called with the new keyword.'
+			);
+		}
+
+		return createModel(modelId, settings);
+	};
+
+	provider.languageModel = createModel;
+	provider.chat = createModel; // Alias for languageModel
+
+	// Add textEmbeddingModel method that throws NoSuchModelError
+	provider.textEmbeddingModel = (modelId: string) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: 'textEmbeddingModel'
+		});
+	};
+
+	provider.imageModel = (modelId: string) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: 'imageModel'
+		});
+	};
+
+	return provider as GrokCliProvider;
+}
+
+/**
+ * Default Grok CLI provider instance.
+ * Pre-configured provider for quick usage without custom settings.
+ */
+export const grokCli = createGrokCli();

packages/ai-sdk-provider-grok-cli/src/index.ts

@@ -0,0 +1,64 @@
+/**
+ * Provider exports for creating and configuring Grok CLI instances.
+ */
+
+/**
+ * Creates a new Grok CLI provider instance and the default provider instance.
+ */
+export { createGrokCli, grokCli } from './grok-cli-provider.js';
+
+/**
+ * Type definitions for the Grok CLI provider.
+ */
+export type {
+	GrokCliProvider,
+	GrokCliProviderSettings
+} from './grok-cli-provider.js';
+
+/**
+ * Language model implementation for Grok CLI.
+ * This class implements the AI SDK's LanguageModelV2 interface.
+ */
+export { GrokCliLanguageModel } from './grok-cli-language-model.js';
+
+/**
+ * Type definitions for Grok CLI language models.
+ */
+export type {
+	GrokCliModelId,
+	GrokCliLanguageModelOptions,
+	GrokCliSettings,
+	GrokCliMessage,
+	GrokCliResponse,
+	GrokCliErrorMetadata
+} from './types.js';
+
+/**
+ * Error handling utilities for Grok CLI.
+ * These functions help create and identify specific error types.
+ */
+export {
+	isAuthenticationError,
+	isTimeoutError,
+	isInstallationError,
+	getErrorMetadata,
+	createAPICallError,
+	createAuthenticationError,
+	createTimeoutError,
+	createInstallationError
+} from './errors.js';
+
+/**
+ * Message conversion utilities for Grok CLI communication.
+ */
+export {
+	convertToGrokCliMessages,
+	convertFromGrokCliResponse,
+	createPromptFromMessages,
+	escapeShellArg
+} from './message-converter.js';
+
+/**
+ * JSON extraction utilities for parsing Grok responses.
+ */
+export { extractJson } from './json-extractor.js';

packages/ai-sdk-provider-grok-cli/src/json-extractor.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Tests for JSON extraction utilities
+ */
+
+import { describe, expect, it } from 'vitest';
+import { extractJson } from './json-extractor.js';
+
+describe('extractJson', () => {
+	it('should extract JSON from markdown code blocks', () => {
+		const text = '```json\n{"name": "test", "value": 42}\n```';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should extract JSON from generic code blocks', () => {
+		const text = '```\n{"name": "test", "value": 42}\n```';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should remove JavaScript variable declarations', () => {
+		const text = 'const result = {"name": "test", "value": 42};';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should handle let variable declarations', () => {
+		const text = 'let data = {"name": "test", "value": 42};';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should handle var variable declarations', () => {
+		const text = 'var config = {"name": "test", "value": 42};';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should extract JSON arrays', () => {
+		const text = '[{"name": "test1"}, {"name": "test2"}]';
+		const result = extractJson(text);
+		expect(result).toBe('[{"name": "test1"}, {"name": "test2"}]');
+	});
+
+	it('should convert JavaScript object literals to JSON', () => {
+		const text = "{name: 'test', value: 42}";
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should return valid JSON as-is', () => {
+		const text = '{"name": "test", "value": 42}';
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": 42}');
+	});
+
+	it('should return original text when JSON parsing fails completely', () => {
+		const text = 'This is not JSON at all';
+		const result = extractJson(text);
+		expect(result).toBe('This is not JSON at all');
+	});
+
+	it('should handle complex nested objects', () => {
+		const text =
+			'```json\n{\n  "user": {\n    "name": "John",\n    "age": 30\n  },\n  "items": [1, 2, 3]\n}\n```';
+		const result = extractJson(text);
+		expect(JSON.parse(result)).toEqual({
+			user: {
+				name: 'John',
+				age: 30
+			},
+			items: [1, 2, 3]
+		});
+	});
+
+	it('should handle mixed quotes in object literals', () => {
+		const text = `{name: "test", value: 'mixed quotes'}`;
+		const result = extractJson(text);
+		expect(result).toBe('{"name": "test", "value": "mixed quotes"}');
+	});
+});

packages/ai-sdk-provider-grok-cli/src/json-extractor.ts

@@ -0,0 +1,132 @@
+/**
+ * Extract JSON from AI's response using a tolerant parser.
+ *
+ * The function removes common wrappers such as markdown fences or variable
+ * declarations and then attempts to parse the remaining text with
+ * `jsonc-parser`.  If valid JSON (or JSONC) can be parsed, it is returned as a
+ * string via `JSON.stringify`.  Otherwise the original text is returned.
+ *
+ * @param text - Raw text which may contain JSON
+ * @returns A valid JSON string if extraction succeeds, otherwise the original text
+ */
+import { parse, type ParseError } from 'jsonc-parser';
+
+export function extractJson(text: string): string {
+	let content = text.trim();
+
+	// Strip ```json or ``` fences
+	const fenceMatch = /```(?:json)?\s*([\s\S]*?)\s*```/i.exec(content);
+	if (fenceMatch) {
+		content = fenceMatch[1];
+	}
+
+	// Strip variable declarations like `const foo =` or `let foo =`
+	const varMatch = /^\s*(?:const|let|var)\s+\w+\s*=\s*([\s\S]*)/i.exec(content);
+	if (varMatch) {
+		content = varMatch[1];
+		// Remove trailing semicolon if present
+		if (content.trim().endsWith(';')) {
+			content = content.trim().slice(0, -1);
+		}
+	}
+
+	// Find the first opening bracket
+	const firstObj = content.indexOf('{');
+	const firstArr = content.indexOf('[');
+	if (firstObj === -1 && firstArr === -1) {
+		return text;
+	}
+	const start =
+		firstArr === -1
+			? firstObj
+			: firstObj === -1
+				? firstArr
+				: Math.min(firstObj, firstArr);
+	content = content.slice(start);
+
+	// Try to parse the entire string with jsonc-parser
+	const tryParse = (value: string): string | undefined => {
+		const errors: ParseError[] = [];
+		try {
+			const result = parse(value, errors, { allowTrailingComma: true });
+			if (errors.length === 0) {
+				return JSON.stringify(result, null, 2);
+			}
+		} catch {
+			// ignore
+		}
+		return undefined;
+	};
+
+	const parsed = tryParse(content);
+	if (parsed !== undefined) {
+		return parsed;
+	}
+
+	// If parsing the full string failed, use a more efficient approach
+	// to find valid JSON boundaries
+	const openChar = content[0];
+	const closeChar = openChar === '{' ? '}' : ']';
+
+	// Find all potential closing positions by tracking nesting depth
+	const closingPositions: number[] = [];
+	let depth = 0;
+	let inString = false;
+	let escapeNext = false;
+
+	for (let i = 0; i < content.length; i++) {
+		const char = content[i];
+
+		if (escapeNext) {
+			escapeNext = false;
+			continue;
+		}
+
+		if (char === '\\') {
+			escapeNext = true;
+			continue;
+		}
+
+		if (char === '"' && !inString) {
+			inString = true;
+			continue;
+		}
+
+		if (char === '"' && inString) {
+			inString = false;
+			continue;
+		}
+
+		// Skip content inside strings
+		if (inString) continue;
+
+		if (char === openChar) {
+			depth++;
+		} else if (char === closeChar) {
+			depth--;
+			if (depth === 0) {
+				closingPositions.push(i + 1);
+			}
+		}
+	}
+
+	// Try parsing at each valid closing position, starting from the end
+	for (let i = closingPositions.length - 1; i >= 0; i--) {
+		const attempt = tryParse(content.slice(0, closingPositions[i]));
+		if (attempt !== undefined) {
+			return attempt;
+		}
+	}
+
+	// As a final fallback, try the original character-by-character approach
+	// but only for the last 1000 characters to limit performance impact
+	const searchStart = Math.max(0, content.length - 1000);
+	for (let end = content.length - 1; end > searchStart; end--) {
+		const attempt = tryParse(content.slice(0, end));
+		if (attempt !== undefined) {
+			return attempt;
+		}
+	}
+
+	return text;
+}

packages/ai-sdk-provider-grok-cli/src/message-converter.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Tests for message conversion utilities
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+	convertFromGrokCliResponse,
+	convertToGrokCliMessages,
+	createPromptFromMessages,
+	escapeShellArg
+} from './message-converter.js';
+
+describe('convertToGrokCliMessages', () => {
+	it('should convert string content messages', () => {
+		const messages = [
+			{ role: 'user', content: 'Hello, world!' },
+			{ role: 'assistant', content: 'Hi there!' }
+		];
+
+		const result = convertToGrokCliMessages(messages);
+
+		expect(result).toEqual([
+			{ role: 'user', content: 'Hello, world!' },
+			{ role: 'assistant', content: 'Hi there!' }
+		]);
+	});
+
+	it('should convert array content messages', () => {
+		const messages = [
+			{
+				role: 'user',
+				content: [
+					{ type: 'text', text: 'Hello' },
+					{ type: 'text', text: 'World' }
+				]
+			}
+		];
+
+		const result = convertToGrokCliMessages(messages);
+
+		expect(result).toEqual([{ role: 'user', content: 'Hello\nWorld' }]);
+	});
+
+	it('should convert object content messages', () => {
+		const messages = [
+			{
+				role: 'user',
+				content: { text: 'Hello from object' }
+			}
+		];
+
+		const result = convertToGrokCliMessages(messages);
+
+		expect(result).toEqual([{ role: 'user', content: 'Hello from object' }]);
+	});
+});
+
+describe('convertFromGrokCliResponse', () => {
+	it('should parse JSONL response format', () => {
+		const responseText = `{"role": "assistant", "content": "Hello there!", "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}}`;
+
+		const result = convertFromGrokCliResponse(responseText);
+
+		expect(result).toEqual({
+			text: 'Hello there!',
+			usage: {
+				promptTokens: 10,
+				completionTokens: 5,
+				totalTokens: 15
+			}
+		});
+	});
+
+	it('should handle multiple lines in JSONL format', () => {
+		const responseText = `{"role": "user", "content": "Hello"}
+{"role": "assistant", "content": "Hi there!", "usage": {"prompt_tokens": 5, "completion_tokens": 3}}`;
+
+		const result = convertFromGrokCliResponse(responseText);
+
+		expect(result).toEqual({
+			text: 'Hi there!',
+			usage: {
+				promptTokens: 5,
+				completionTokens: 3,
+				totalTokens: 0
+			}
+		});
+	});
+
+	it('should fallback to raw text when parsing fails', () => {
+		const responseText = 'Invalid JSON response';
+
+		const result = convertFromGrokCliResponse(responseText);
+
+		expect(result).toEqual({
+			text: 'Invalid JSON response',
+			usage: undefined
+		});
+	});
+});
+
+describe('createPromptFromMessages', () => {
+	it('should create formatted prompt from messages', () => {
+		const messages = [
+			{ role: 'system', content: 'You are a helpful assistant.' },
+			{ role: 'user', content: 'What is 2+2?' },
+			{ role: 'assistant', content: '2+2 equals 4.' }
+		];
+
+		const result = createPromptFromMessages(messages);
+
+		expect(result).toBe(
+			'System: You are a helpful assistant.\n\nUser: What is 2+2?\n\nAssistant: 2+2 equals 4.'
+		);
+	});
+
+	it('should handle custom role names', () => {
+		const messages = [{ role: 'custom', content: 'Custom message' }];
+
+		const result = createPromptFromMessages(messages);
+
+		expect(result).toBe('custom: Custom message');
+	});
+});
+
+describe('escapeShellArg', () => {
+	it('should escape single quotes', () => {
+		const arg = "It's a test";
+		const result = escapeShellArg(arg);
+		expect(result).toBe("'It'\\''s a test'");
+	});
+
+	it('should handle strings without special characters', () => {
+		const arg = 'simple string';
+		const result = escapeShellArg(arg);
+		expect(result).toBe("'simple string'");
+	});
+
+	it('should convert non-string values to strings', () => {
+		const arg = 123;
+		const result = escapeShellArg(arg);
+		expect(result).toBe("'123'");
+	});
+
+	it('should handle empty strings', () => {
+		const arg = '';
+		const result = escapeShellArg(arg);
+		expect(result).toBe("''");
+	});
+});

packages/ai-sdk-provider-grok-cli/src/message-converter.ts

@@ -0,0 +1,153 @@
+/**
+ * Message format conversion utilities for Grok CLI provider
+ */
+
+import type { GrokCliMessage, GrokCliResponse } from './types.js';
+
+/**
+ * AI SDK message type (simplified interface)
+ */
+interface AISDKMessage {
+	role: string;
+	content:
+		| string
+		| Array<{ type: string; text?: string }>
+		| { text?: string; [key: string]: unknown };
+}
+
+/**
+ * Convert AI SDK messages to Grok CLI compatible format
+ * @param messages - AI SDK message array
+ * @returns Grok CLI compatible messages
+ */
+export function convertToGrokCliMessages(
+	messages: AISDKMessage[]
+): GrokCliMessage[] {
+	return messages.map((message) => {
+		// Handle different message content types
+		let content = '';
+
+		if (typeof message.content === 'string') {
+			content = message.content;
+		} else if (Array.isArray(message.content)) {
+			// Handle multi-part content (text and images)
+			content = message.content
+				.filter((part) => part.type === 'text')
+				.map((part) => part.text || '')
+				.join('\n');
+		} else if (message.content && typeof message.content === 'object') {
+			// Handle object content
+			content = message.content.text || JSON.stringify(message.content);
+		}
+
+		return {
+			role: message.role,
+			content: content.trim()
+		};
+	});
+}
+
+/**
+ * Convert Grok CLI response to AI SDK format
+ * @param responseText - Raw response text from Grok CLI (JSONL format)
+ * @returns AI SDK compatible response object
+ */
+export function convertFromGrokCliResponse(responseText: string): {
+	text: string;
+	usage?: {
+		promptTokens: number;
+		completionTokens: number;
+		totalTokens: number;
+	};
+} {
+	try {
+		// Grok CLI outputs JSONL format - each line is a separate JSON message
+		const lines = responseText
+			.trim()
+			.split('\n')
+			.filter((line) => line.trim());
+
+		// Parse each line as JSON and find assistant messages
+		const messages: GrokCliResponse[] = [];
+		for (const line of lines) {
+			try {
+				const message = JSON.parse(line) as GrokCliResponse;
+				messages.push(message);
+			} catch (parseError) {
+				// Skip invalid JSON lines
+				continue;
+			}
+		}
+
+		// Find the last assistant message
+		const assistantMessage = messages
+			.filter((msg: any) => msg.role === 'assistant')
+			.pop();
+
+		if (assistantMessage && assistantMessage.content) {
+			return {
+				text: assistantMessage.content,
+				usage: assistantMessage.usage
+					? {
+							promptTokens: assistantMessage.usage.prompt_tokens || 0,
+							completionTokens: assistantMessage.usage.completion_tokens || 0,
+							totalTokens: assistantMessage.usage.total_tokens || 0
+						}
+					: undefined
+			};
+		}
+
+		// Fallback: if no assistant message found, return the raw text
+		return {
+			text: responseText.trim(),
+			usage: undefined
+		};
+	} catch (error) {
+		// If parsing fails completely, treat as plain text response
+		return {
+			text: responseText.trim(),
+			usage: undefined
+		};
+	}
+}
+
+/**
+ * Create a prompt string for Grok CLI from messages
+ * @param messages - AI SDK message array
+ * @returns Formatted prompt string
+ */
+export function createPromptFromMessages(messages: AISDKMessage[]): string {
+	const grokMessages = convertToGrokCliMessages(messages);
+
+	// Create a conversation-style prompt
+	const prompt = grokMessages
+		.map((message) => {
+			switch (message.role) {
+				case 'system':
+					return `System: ${message.content}`;
+				case 'user':
+					return `User: ${message.content}`;
+				case 'assistant':
+					return `Assistant: ${message.content}`;
+				default:
+					return `${message.role}: ${message.content}`;
+			}
+		})
+		.join('\n\n');
+
+	return prompt;
+}
+
+/**
+ * Escape shell arguments for safe CLI execution
+ * @param arg - Argument to escape
+ * @returns Shell-escaped argument
+ */
+export function escapeShellArg(arg: string | unknown): string {
+	if (typeof arg !== 'string') {
+		arg = String(arg);
+	}
+
+	// Replace single quotes with '\''
+	return "'" + (arg as string).replace(/'/g, "'\\''") + "'";
+}

packages/ai-sdk-provider-grok-cli/src/types.ts

@@ -0,0 +1,81 @@
+/**
+ * Type definitions for Grok CLI provider
+ */
+
+/**
+ * Settings for configuring Grok CLI behavior
+ */
+export interface GrokCliSettings {
+	/** API key for Grok CLI */
+	apiKey?: string;
+	/** Base URL for Grok API */
+	baseURL?: string;
+	/** Default model to use */
+	model?: string;
+	/** Timeout in milliseconds */
+	timeout?: number;
+	/** Working directory for CLI commands */
+	workingDirectory?: string;
+}
+
+/**
+ * Model identifiers supported by Grok CLI
+ */
+export type GrokCliModelId = string;
+
+/**
+ * Error metadata for Grok CLI operations
+ */
+export interface GrokCliErrorMetadata {
+	/** Error code */
+	code?: string;
+	/** Process exit code */
+	exitCode?: number;
+	/** Standard error output */
+	stderr?: string;
+	/** Standard output */
+	stdout?: string;
+	/** Excerpt of the prompt that caused the error */
+	promptExcerpt?: string;
+	/** Timeout value in milliseconds */
+	timeoutMs?: number;
+}
+
+/**
+ * Message format for Grok CLI communication
+ */
+export interface GrokCliMessage {
+	/** Message role (user, assistant, system) */
+	role: string;
+	/** Message content */
+	content: string;
+}
+
+/**
+ * Response format from Grok CLI
+ */
+export interface GrokCliResponse {
+	/** Message role */
+	role: string;
+	/** Response content */
+	content: string;
+	/** Token usage information */
+	usage?: {
+		/** Input tokens used */
+		prompt_tokens?: number;
+		/** Output tokens used */
+		completion_tokens?: number;
+		/** Total tokens used */
+		total_tokens?: number;
+	};
+}
+
+/**
+ * Configuration options for Grok CLI language model
+ */
+export interface GrokCliLanguageModelOptions {
+	/** Model identifier */
+	id: GrokCliModelId;
+	/** Model settings */
+	settings?: GrokCliSettings;
+}

packages/ai-sdk-provider-grok-cli/tsconfig.json

@@ -0,0 +1,36 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"lib": ["ES2022"],
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+		"baseUrl": ".",
+		"rootDir": "./src",
+		"strict": true,
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"strictFunctionTypes": true,
+		"strictBindCallApply": true,
+		"strictPropertyInitialization": true,
+		"noImplicitThis": true,
+		"alwaysStrict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"moduleResolution": "NodeNext",
+		"moduleDetection": "force",
+		"types": ["node"],
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"allowImportingTsExtensions": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
+}