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

2025-09-26 23:37:57 +02:00
parent 18aa416035
commit 986ac117ae
24 changed files with 3180 additions and 543 deletions
--- a/.changeset/sweet-maps-rule.md
+++ b/.changeset/sweet-maps-rule.md
@@ -0,0 +1,5 @@
+---
+"task-master-ai": minor
+---
+
+Upgrade grok-cli ai provider to ai sdk v5
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -61,6 +61,8 @@
 		"@ai-sdk/mistral": "^2.0.16",
 		"@ai-sdk/openai": "^2.0.34",
 		"@ai-sdk/perplexity": "^2.0.10",
+		"@ai-sdk/provider": "^2.0.0",
+		"@ai-sdk/provider-utils": "^3.0.10",
 		"@ai-sdk/xai": "^2.0.22",
 		"@aws-sdk/credential-providers": "^3.895.0",
 		"@inquirer/search": "^3.0.15",
@@ -124,8 +126,9 @@
 		"@biomejs/biome": "^1.9.4",
 		"@changesets/changelog-github": "^0.5.1",
 		"@changesets/cli": "^2.28.1",
-		"@tm/cli": "*",
 		"@manypkg/cli": "^0.25.1",
+		"@tm/cli": "*",
+		"@tm/ai-sdk-provider-grok-cli": "*",
 		"@types/jest": "^29.5.14",
 		"@types/marked-terminal": "^6.1.1",
 		"concurrently": "^9.2.1",
--- a/packages/ai-sdk-provider-grok-cli/README.md
+++ b/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.
--- a/packages/ai-sdk-provider-grok-cli/package.json
+++ b/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"
+	}
+}
--- a/packages/ai-sdk-provider-grok-cli/src/errors.test.ts
+++ b/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();
+	});
+});
--- a/packages/ai-sdk-provider-grok-cli/src/errors.ts
+++ b/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;
+}
--- a/packages/ai-sdk-provider-grok-cli/src/grok-cli-language-model.ts
+++ b/packages/ai-sdk-provider-grok-cli/src/grok-cli-language-model.ts
@@ -1,53 +1,51 @@
 /**
- * @fileoverview Grok CLI Language Model implementation
+ * 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 {
-	createPromptFromMessages,
-	convertFromGrokCliResponse,
-	escapeShellArg
-} from './message-converter.js';
-import { extractJson } from './json-extractor.js';
+
 import {
 	createAPICallError,
 	createAuthenticationError,
 	createInstallationError,
 	createTimeoutError
 } from './errors.js';
-import { spawn } from 'child_process';
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
+import { extractJson } from './json-extractor.js';
+import {
+	convertFromGrokCliResponse,
+	createPromptFromMessages,
+	escapeShellArg
+} from './message-converter.js';
+import type {
+	GrokCliLanguageModelOptions,
+	GrokCliModelId,
+	GrokCliSettings
+} from './types.js';

 /**
- * @typedef {import('./types.js').GrokCliSettings} GrokCliSettings
- * @typedef {import('./types.js').GrokCliModelId} GrokCliModelId
+ * 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[]> = {};

-/**
- * @typedef {Object} GrokCliLanguageModelOptions
- * @property {GrokCliModelId} id - Model ID
- * @property {GrokCliSettings} [settings] - Model settings
- */
+	readonly modelId: GrokCliModelId;
+	readonly settings: GrokCliSettings;

-export class GrokCliLanguageModel {
-	specificationVersion = 'v1';
-	defaultObjectGenerationMode = 'json';
-	supportsImageUrls = false;
-	supportsStructuredOutputs = false;
-
-	/** @type {GrokCliModelId} */
-	modelId;
-
-	/** @type {GrokCliSettings} */
-	settings;
-
-	/**
-	 * @param {GrokCliLanguageModelOptions} options
-	 */
-	constructor(options) {
+	constructor(options: GrokCliLanguageModelOptions) {
 		this.modelId = options.id;
 		this.settings = options.settings ?? {};

@@ -64,15 +62,14 @@ export class GrokCliLanguageModel {
 		}
 	}

-	get provider() {
+	get provider(): string {
 		return 'grok-cli';
 	}

 	/**
 	 * Check if Grok CLI is installed and available
-	 * @returns {Promise<boolean>}
 	 */
-	async checkGrokCliInstallation() {
+	private async checkGrokCliInstallation(): Promise<boolean> {
 		return new Promise((resolve) => {
 			const child = spawn('grok', ['--version'], {
 				stdio: 'pipe'
@@ -85,9 +82,8 @@ export class GrokCliLanguageModel {

 	/**
 	 * Get API key from settings or environment
-	 * @returns {Promise<string|null>}
 	 */
-	async getApiKey() {
+	private async getApiKey(): Promise<string | null> {
 		// Check settings first
 		if (this.settings.apiKey) {
 			return this.settings.apiKey;
@@ -111,12 +107,18 @@ export class GrokCliLanguageModel {

 	/**
 	 * Execute Grok CLI command
-	 * @param {Array<string>} args - Command line arguments
-	 * @param {Object} options - Execution options
-	 * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>}
 	 */
-	async executeGrokCli(args, options = {}) {
-		const timeout = options.timeout || this.settings.timeout || 120000; // 2 minutes default
+	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, {
@@ -126,7 +128,7 @@ export class GrokCliLanguageModel {

 			let stdout = '';
 			let stderr = '';
-			let timeoutId;
+			let timeoutId: NodeJS.Timeout | undefined;

 			// Set up timeout
 			if (timeout > 0) {
@@ -142,24 +144,26 @@ export class GrokCliLanguageModel {
 				}, timeout);
 			}

-			child.stdout.on('data', (data) => {
-				stdout += data.toString();
+			child.stdout?.on('data', (data) => {
+				const chunk = data.toString();
+				stdout += chunk;
 			});

-			child.stderr.on('data', (data) => {
-				stderr += data.toString();
+			child.stderr?.on('data', (data) => {
+				const chunk = data.toString();
+				stderr += chunk;
 			});

 			child.on('error', (error) => {
 				if (timeoutId) clearTimeout(timeoutId);

-				if (error.code === 'ENOENT') {
+				if ((error as any).code === 'ENOENT') {
 					reject(createInstallationError({}));
 				} else {
 					reject(
 						createAPICallError({
 							message: `Failed to execute Grok CLI: ${error.message}`,
-							code: error.code,
+							code: (error as any).code,
 							stderr: error.message,
 							isRetryable: false
 						})
@@ -180,15 +184,18 @@ export class GrokCliLanguageModel {
 	}

 	/**
-	 * Generate unsupported parameter warnings
-	 * @param {Object} options - Generation options
-	 * @returns {Array} Warnings array
+	 * Generate comprehensive warnings for unsupported parameters and validation issues
 	 */
-	generateUnsupportedWarnings(options) {
-		const warnings = [];
-		const unsupportedParams = [];
+	private generateAllWarnings(
+		options: LanguageModelV2CallOptions,
+		prompt: string
+	): LanguageModelV2CallWarning[] {
+		const warnings: LanguageModelV2CallWarning[] = [];
+		const unsupportedParams: string[] = [];

-		// Grok CLI supports some parameters but not all AI SDK parameters
+		// 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)
@@ -200,24 +207,51 @@ export class GrokCliLanguageModel {
 		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,
+					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
-	 * @param {Object} options - Generation options
-	 * @returns {Promise<Object>}
 	 */
-	async doGenerate(options) {
+	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) {
@@ -234,7 +268,7 @@ export class GrokCliLanguageModel {
 		}

 		const prompt = createPromptFromMessages(options.prompt);
-		const warnings = this.generateUnsupportedWarnings(options);
+		const warnings = this.generateAllWarnings(options, prompt);

 		// Build command arguments
 		const args = ['--prompt', escapeShellArg(prompt)];
@@ -244,10 +278,11 @@ export class GrokCliLanguageModel {
 			args.push('--model', this.modelId);
 		}

-		// Add API key if available
-		if (apiKey) {
-			args.push('--api-key', apiKey);
-		}
+		// 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) {
@@ -260,9 +295,7 @@ export class GrokCliLanguageModel {
 		}

 		try {
-			const result = await this.executeGrokCli(args, {
-				timeout: this.settings.timeout
-			});
+			const result = await this.executeGrokCli(args);

 			if (result.exitCode !== 0) {
 				// Handle authentication errors
@@ -290,19 +323,34 @@ export class GrokCliLanguageModel {
 			let text = response.text || '';

 			// Extract JSON if in object-json mode
-			if (options.mode?.type === 'object-json' && text) {
+			if (
+				'mode' in options &&
+				(options as any).mode?.type === 'object-json' &&
+				text
+			) {
 				text = extractJson(text);
 			}

 			return {
-				text: text || undefined,
-				usage: response.usage || { promptTokens: 0, completionTokens: 0 },
-				finishReason: 'stop',
+				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.length > 0 ? warnings : undefined,
+				warnings: warnings,
 				response: {
 					id: generateId(),
 					timestamp: new Date(),
@@ -314,20 +362,23 @@ export class GrokCliLanguageModel {
 				providerMetadata: {
 					'grok-cli': {
 						exitCode: result.exitCode,
-						stderr: result.stderr || undefined
+						...(result.stderr && { stderr: result.stderr })
 					}
 				}
 			};
 		} catch (error) {
 			// Re-throw our custom errors
-			if (error.name === 'APICallError' || error.name === 'LoadAPIKeyError') {
+			if (
+				(error as any).name === 'APICallError' ||
+				(error as any).name === 'LoadAPIKeyError'
+			) {
 				throw error;
 			}

 			// Wrap other errors
 			throw createAPICallError({
-				message: `Grok CLI execution failed: ${error.message}`,
-				code: error.code,
+				message: `Grok CLI execution failed: ${(error as Error).message}`,
+				code: (error as any).code,
 				promptExcerpt: prompt.substring(0, 200),
 				isRetryable: false
 			});
@@ -338,15 +389,39 @@ export class GrokCliLanguageModel {
 	 * 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
-	 * @param {Object} options - Stream options
-	 * @returns {Promise<Object>}
 	 */
-	async doStream(options) {
-		const warnings = this.generateUnsupportedWarnings(options);
+	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);

@@ -359,20 +434,48 @@ export class GrokCliLanguageModel {
 					});

 					// Simulate streaming by chunking the text
-					const text = result.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',
-							textDelta: chunk
+							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',
@@ -388,19 +491,22 @@ export class GrokCliLanguageModel {
 						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,
-			rawCall: {
-				rawPrompt: createPromptFromMessages(options.prompt),
-				rawSettings: {}
-			},
-			warnings: warnings.length > 0 ? warnings : undefined,
 			request: {
-				body: createPromptFromMessages(options.prompt)
+				body: prompt
 			}
 		};
 	}
--- a/packages/ai-sdk-provider-grok-cli/src/grok-cli-provider.test.ts
+++ b/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: {}
+		});
+	});
+});
--- a/packages/ai-sdk-provider-grok-cli/src/grok-cli-provider.ts
+++ b/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();
--- a/packages/ai-sdk-provider-grok-cli/src/index.ts
+++ b/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';
--- a/packages/ai-sdk-provider-grok-cli/src/json-extractor.test.ts
+++ b/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"}');
+	});
+});
--- a/packages/ai-sdk-provider-grok-cli/src/json-extractor.ts
+++ b/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;
+}
--- a/packages/ai-sdk-provider-grok-cli/src/message-converter.test.ts
+++ b/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("''");
+	});
+});
--- a/packages/ai-sdk-provider-grok-cli/src/message-converter.ts
+++ b/packages/ai-sdk-provider-grok-cli/src/message-converter.ts
@@ -1,17 +1,28 @@
 /**
- * @fileoverview Message format conversion utilities for Grok CLI provider
+ * Message format conversion utilities for Grok CLI provider
 */

+import type { GrokCliMessage, GrokCliResponse } from './types.js';
+
 /**
- * @typedef {import('./types.js').GrokCliMessage} GrokCliMessage
+ * 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 {Array<Object>} messages - AI SDK message array
- * @returns {Array<GrokCliMessage>} Grok CLI compatible messages
+ * @param messages - AI SDK message array
+ * @returns Grok CLI compatible messages
 */
-export function convertToGrokCliMessages(messages) {
+export function convertToGrokCliMessages(
+	messages: AISDKMessage[]
+): GrokCliMessage[] {
 	return messages.map((message) => {
 		// Handle different message content types
 		let content = '';
@@ -22,7 +33,7 @@ export function convertToGrokCliMessages(messages) {
 			// Handle multi-part content (text and images)
 			content = message.content
 				.filter((part) => part.type === 'text')
-				.map((part) => part.text)
+				.map((part) => part.text || '')
 				.join('\n');
 		} else if (message.content && typeof message.content === 'object') {
 			// Handle object content
@@ -38,10 +49,17 @@ export function convertToGrokCliMessages(messages) {

 /**
 * Convert Grok CLI response to AI SDK format
- * @param {string} responseText - Raw response text from Grok CLI (JSONL format)
- * @returns {Object} AI SDK compatible response object
+ * @param responseText - Raw response text from Grok CLI (JSONL format)
+ * @returns AI SDK compatible response object
 */
-export function convertFromGrokCliResponse(responseText) {
+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
@@ -50,10 +68,10 @@ export function convertFromGrokCliResponse(responseText) {
 			.filter((line) => line.trim());

 		// Parse each line as JSON and find assistant messages
-		const messages = [];
+		const messages: GrokCliResponse[] = [];
 		for (const line of lines) {
 			try {
-				const message = JSON.parse(line);
+				const message = JSON.parse(line) as GrokCliResponse;
 				messages.push(message);
 			} catch (parseError) {
 				// Skip invalid JSON lines
@@ -63,7 +81,7 @@ export function convertFromGrokCliResponse(responseText) {

 		// Find the last assistant message
 		const assistantMessage = messages
-			.filter((msg) => msg.role === 'assistant')
+			.filter((msg: any) => msg.role === 'assistant')
 			.pop();

 		if (assistantMessage && assistantMessage.content) {
@@ -95,10 +113,10 @@ export function convertFromGrokCliResponse(responseText) {

 /**
 * Create a prompt string for Grok CLI from messages
- * @param {Array<Object>} messages - AI SDK message array
- * @returns {string} Formatted prompt string
+ * @param messages - AI SDK message array
+ * @returns Formatted prompt string
 */
-export function createPromptFromMessages(messages) {
+export function createPromptFromMessages(messages: AISDKMessage[]): string {
 	const grokMessages = convertToGrokCliMessages(messages);

 	// Create a conversation-style prompt
@@ -122,14 +140,14 @@ export function createPromptFromMessages(messages) {

 /**
 * Escape shell arguments for safe CLI execution
- * @param {string} arg - Argument to escape
- * @returns {string} Shell-escaped argument
+ * @param arg - Argument to escape
+ * @returns Shell-escaped argument
 */
-export function escapeShellArg(arg) {
+export function escapeShellArg(arg: string | unknown): string {
 	if (typeof arg !== 'string') {
 		arg = String(arg);
 	}

 	// Replace single quotes with '\''
-	return "'" + arg.replace(/'/g, "'\\''") + "'";
+	return "'" + (arg as string).replace(/'/g, "'\\''") + "'";
 }
--- a/packages/ai-sdk-provider-grok-cli/src/types.ts
+++ b/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;
+}
--- a/packages/ai-sdk-provider-grok-cli/tsconfig.json
+++ b/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"]
+}
--- a/packages/tm-core/package.json
+++ b/packages/tm-core/package.json
@@ -34,18 +34,11 @@
 		"zod": "^4.1.11"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^1.9.4",
-		"@tm/build-config": "*",
 		"@types/node": "^22.10.5",
-		"@vitest/coverage-v8": "^2.0.5",
+		"@vitest/coverage-v8": "^3.2.4",
 		"dotenv-mono": "^1.5.1",
-		"ts-node": "^10.9.2",
-		"tsup": "^8.5.0",
-		"typescript": "^5.7.3",
-		"vitest": "^2.1.8"
-	},
-	"engines": {
-		"node": ">=18.0.0"
+		"typescript": "^5.9.2",
+		"vitest": "^3.2.4"
 	},
 	"files": ["src", "README.md", "CHANGELOG.md"],
 	"keywords": ["task-management", "typescript", "ai", "prd", "parser"],
--- a/src/ai-providers/custom-sdk/grok-cli/errors.js
+++ b/src/ai-providers/custom-sdk/grok-cli/errors.js
@@ -1,155 +0,0 @@
-/**
- * @fileoverview Error handling utilities for Grok CLI provider
- */
-
-import { APICallError, LoadAPIKeyError } from '@ai-sdk/provider';
-
-/**
- * @typedef {import('./types.js').GrokCliErrorMetadata} GrokCliErrorMetadata
- */
-
-/**
- * Create an API call error with Grok CLI specific metadata
- * @param {Object} params - Error parameters
- * @param {string} params.message - Error message
- * @param {string} [params.code] - Error code
- * @param {number} [params.exitCode] - Process exit code
- * @param {string} [params.stderr] - Standard error output
- * @param {string} [params.stdout] - Standard output
- * @param {string} [params.promptExcerpt] - Excerpt of the prompt
- * @param {boolean} [params.isRetryable=false] - Whether the error is retryable
- * @returns {APICallError}
- */
-export function createAPICallError({
-	message,
-	code,
-	exitCode,
-	stderr,
-	stdout,
-	promptExcerpt,
-	isRetryable = false
-}) {
-	/** @type {GrokCliErrorMetadata} */
-	const metadata = {
-		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
- * @param {Object} params - Error parameters
- * @param {string} params.message - Error message
- * @returns {LoadAPIKeyError}
- */
-export function createAuthenticationError({ message }) {
-	return new LoadAPIKeyError({
-		message:
-			message ||
-			'Authentication failed. Please ensure Grok CLI is properly configured with API key.'
-	});
-}
-
-/**
- * Create a timeout error
- * @param {Object} params - Error parameters
- * @param {string} params.message - Error message
- * @param {string} [params.promptExcerpt] - Excerpt of the prompt
- * @param {number} params.timeoutMs - Timeout in milliseconds
- * @returns {APICallError}
- */
-export function createTimeoutError({ message, promptExcerpt, timeoutMs }) {
-	/** @type {GrokCliErrorMetadata & { timeoutMs: number }} */
-	const metadata = {
-		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
- * @param {Object} params - Error parameters
- * @param {string} [params.message] - Error message
- * @returns {APICallError}
- */
-export function createInstallationError({ message }) {
-	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'
-	});
-}
-
-/**
- * Check if an error is an authentication error
- * @param {unknown} error - Error to check
- * @returns {boolean}
- */
-export function isAuthenticationError(error) {
-	if (error instanceof LoadAPIKeyError) return true;
-	if (
-		error instanceof APICallError &&
-		/** @type {GrokCliErrorMetadata} */ (error.data)?.exitCode === 401
-	)
-		return true;
-	return false;
-}
-
-/**
- * Check if an error is a timeout error
- * @param {unknown} error - Error to check
- * @returns {boolean}
- */
-export function isTimeoutError(error) {
-	if (
-		error instanceof APICallError &&
-		/** @type {GrokCliErrorMetadata} */ (error.data)?.code === 'TIMEOUT'
-	)
-		return true;
-	return false;
-}
-
-/**
- * Check if an error is an installation error
- * @param {unknown} error - Error to check
- * @returns {boolean}
- */
-export function isInstallationError(error) {
-	if (error instanceof APICallError && error.url === 'grok-cli://installation')
-		return true;
-	return false;
-}
-
-/**
- * Get error metadata from an error
- * @param {unknown} error - Error to extract metadata from
- * @returns {GrokCliErrorMetadata|undefined}
- */
-export function getErrorMetadata(error) {
-	if (error instanceof APICallError && error.data) {
-		return /** @type {GrokCliErrorMetadata} */ (error.data);
-	}
-	return undefined;
-}
--- a/src/ai-providers/custom-sdk/grok-cli/index.js
+++ b/src/ai-providers/custom-sdk/grok-cli/index.js
@@ -1,85 +0,0 @@
-/**
- * @fileoverview Grok CLI provider factory and exports
- */
-
-import { NoSuchModelError } from '@ai-sdk/provider';
-import { GrokCliLanguageModel } from './language-model.js';
-
-/**
- * @typedef {import('./types.js').GrokCliSettings} GrokCliSettings
- * @typedef {import('./types.js').GrokCliModelId} GrokCliModelId
- * @typedef {import('./types.js').GrokCliProvider} GrokCliProvider
- * @typedef {import('./types.js').GrokCliProviderSettings} GrokCliProviderSettings
- */
-
-/**
- * Create a Grok CLI provider
- * @param {GrokCliProviderSettings} [options={}] - Provider configuration options
- * @returns {GrokCliProvider} Grok CLI provider instance
- */
-export function createGrokCli(options = {}) {
-	/**
-	 * Create a language model instance
-	 * @param {GrokCliModelId} modelId - Model ID
-	 * @param {GrokCliSettings} [settings={}] - Model settings
-	 * @returns {GrokCliLanguageModel}
-	 */
-	const createModel = (modelId, settings = {}) => {
-		return new GrokCliLanguageModel({
-			id: modelId,
-			settings: {
-				...options.defaultSettings,
-				...settings
-			}
-		});
-	};
-
-	/**
-	 * Provider function
-	 * @param {GrokCliModelId} modelId - Model ID
-	 * @param {GrokCliSettings} [settings] - Model settings
-	 * @returns {GrokCliLanguageModel}
-	 */
-	const provider = function (modelId, settings) {
-		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) => {
-		throw new NoSuchModelError({
-			modelId,
-			modelType: 'textEmbeddingModel'
-		});
-	};
-
-	return /** @type {GrokCliProvider} */ (provider);
-}
-
-/**
- * Default Grok CLI provider instance
- */
-export const grokCli = createGrokCli();
-
-// Provider exports
-export { GrokCliLanguageModel } from './language-model.js';
-
-// Error handling exports
-export {
-	isAuthenticationError,
-	isTimeoutError,
-	isInstallationError,
-	getErrorMetadata,
-	createAPICallError,
-	createAuthenticationError,
-	createTimeoutError,
-	createInstallationError
-} from './errors.js';
--- a/src/ai-providers/custom-sdk/grok-cli/json-extractor.js
+++ b/src/ai-providers/custom-sdk/grok-cli/json-extractor.js
@@ -1,59 +0,0 @@
-/**
- * @fileoverview Extract JSON from Grok's response, handling markdown blocks and other formatting
- */
-
-/**
- * Extract JSON from Grok's response
- * @param {string} text - The text to extract JSON from
- * @returns {string} - The extracted JSON string
- */
-export function extractJson(text) {
-	// Remove markdown code blocks if present
-	let jsonText = text.trim();
-
-	// Remove ```json blocks
-	jsonText = jsonText.replace(/^```json\s*/gm, '');
-	jsonText = jsonText.replace(/^```\s*/gm, '');
-	jsonText = jsonText.replace(/```\s*$/gm, '');
-
-	// Remove common TypeScript/JavaScript patterns
-	jsonText = jsonText.replace(/^const\s+\w+\s*=\s*/, ''); // Remove "const varName = "
-	jsonText = jsonText.replace(/^let\s+\w+\s*=\s*/, ''); // Remove "let varName = "
-	jsonText = jsonText.replace(/^var\s+\w+\s*=\s*/, ''); // Remove "var varName = "
-	jsonText = jsonText.replace(/;?\s*$/, ''); // Remove trailing semicolons
-
-	// Try to extract JSON object or array
-	const objectMatch = jsonText.match(/{[\s\S]*}/);
-	const arrayMatch = jsonText.match(/\[[\s\S]*\]/);
-
-	if (objectMatch) {
-		jsonText = objectMatch[0];
-	} else if (arrayMatch) {
-		jsonText = arrayMatch[0];
-	}
-
-	// First try to parse as valid JSON
-	try {
-		JSON.parse(jsonText);
-		return jsonText;
-	} catch {
-		// If it's not valid JSON, it might be a JavaScript object literal
-		// Try to convert it to valid JSON
-		try {
-			// This is a simple conversion that handles basic cases
-			// Replace unquoted keys with quoted keys
-			const converted = jsonText
-				.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":')
-				// Replace single quotes with double quotes
-				.replace(/'/g, '"');
-
-			// Validate the converted JSON
-			JSON.parse(converted);
-			return converted;
-		} catch {
-			// If all else fails, return the original text
-			// The AI SDK will handle the error appropriately
-			return text;
-		}
-	}
-}
--- a/src/ai-providers/custom-sdk/grok-cli/types.js
+++ b/src/ai-providers/custom-sdk/grok-cli/types.js
@@ -1,56 +0,0 @@
-/**
- * @fileoverview Type definitions for Grok CLI provider
- */
-
-/**
- * @typedef {Object} GrokCliSettings
- * @property {string} [apiKey] - API key for Grok CLI
- * @property {string} [baseURL] - Base URL for Grok API
- * @property {string} [model] - Default model to use
- * @property {number} [timeout] - Timeout in milliseconds
- * @property {string} [workingDirectory] - Working directory for CLI commands
- */
-
-/**
- * @typedef {string} GrokCliModelId
- * Model identifiers supported by Grok CLI
- */
-
-/**
- * @typedef {Object} GrokCliErrorMetadata
- * @property {string} [code] - Error code
- * @property {number} [exitCode] - Process exit code
- * @property {string} [stderr] - Standard error output
- * @property {string} [stdout] - Standard output
- * @property {string} [promptExcerpt] - Excerpt of the prompt that caused the error
- * @property {number} [timeoutMs] - Timeout value in milliseconds
- */
-
-/**
- * @typedef {Function} GrokCliProvider
- * @property {Function} languageModel - Create a language model
- * @property {Function} chat - Alias for languageModel
- * @property {Function} textEmbeddingModel - Text embedding model (throws error)
- */
-
-/**
- * @typedef {Object} GrokCliProviderSettings
- * @property {GrokCliSettings} [defaultSettings] - Default settings for all models
- */
-
-/**
- * @typedef {Object} GrokCliMessage
- * @property {string} role - Message role (user, assistant, system)
- * @property {string} content - Message content
- */
-
-/**
- * @typedef {Object} GrokCliResponse
- * @property {string} content - Response content
- * @property {Object} [usage] - Token usage information
- * @property {number} [usage.prompt_tokens] - Input tokens used
- * @property {number} [usage.completion_tokens] - Output tokens used
- * @property {number} [usage.total_tokens] - Total tokens used
- */
-
-export {};
--- a/src/ai-providers/grok-cli.js
+++ b/src/ai-providers/grok-cli.js
@@ -3,7 +3,7 @@
 * AI provider implementation for Grok models using Grok CLI.
 */

-import { createGrokCli } from './custom-sdk/grok-cli/index.js';
+import { createGrokCli } from '@tm/ai-sdk-provider-grok-cli';
 import { BaseAIProvider } from './base-provider.js';
 import { getGrokCliSettingsForCommand } from '../../scripts/modules/config-manager.js';

--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,7 +19,13 @@
 			"@tm/cli": ["./apps/cli/src/index.ts"],
 			"@tm/cli/*": ["./apps/cli/src/*"],
 			"@tm/build-config": ["./packages/build-config/src/index.ts"],
-			"@tm/build-config/*": ["./packages/build-config/src/*"]
+			"@tm/build-config/*": ["./packages/build-config/src/*"],
+			"@tm/ai-sdk-provider-grok-cli": [
+				"./packages/ai-sdk-provider-grok-cli/src/index.ts"
+			],
+			"@tm/ai-sdk-provider-grok-cli/*": [
+				"./packages/ai-sdk-provider-grok-cli/src/*"
+			]
 		}
 	},
 	"tsx": {