@gguf/coder 0.3.0 → 0.3.1

package/scripts/update-nix-version.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+# Update Nix package version and hashes for a new release
+# Usage: ./scripts/update-nix-version.sh <version>
+# Example: ./scripts/update-nix-version.sh 1.15.0
+
+set -e
+
+VERSION=$1
+SKIP_VERIFY=$2
+NIX_FILE="nix/packages/default/default.nix"
+FAKE_HASH="sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+if [ -z "$VERSION" ]; then
+  echo -e "${RED}Error: Version number required${NC}"
+  echo "Usage: $0 <version> [--skip-verify]"
+  echo "Example: $0 1.15.0"
+  echo "Example: $0 1.15.0 --skip-verify"
+  exit 1
+fi
+
+echo -e "${YELLOW}Updating Nix package to version ${VERSION}...${NC}"
+echo ""
+
+# Step 1: Update version in nix file
+echo "Step 1: Updating version number in ${NIX_FILE}..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' "s|version = \".*\";|version = \"${VERSION}\";|" "$NIX_FILE"
+else
+  sed -i "s|version = \".*\";|version = \"${VERSION}\";|" "$NIX_FILE"
+fi
+
+# Step 2: Insert fake source hash
+echo "Step 2: Using fake source hash to trigger hash calculation..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' "s|sha256 = \".*\";|sha256 = \"${FAKE_HASH}\";|" "$NIX_FILE"
+else
+  sed -i "s|sha256 = \".*\";|sha256 = \"${FAKE_HASH}\";|" "$NIX_FILE"
+fi
+
+# Step 3: Build to get the real source hash
+echo "Step 3: Building package to get correct source hash..."
+echo -e "${YELLOW}(This will fail - that's expected!)${NC}"
+echo ""
+
+BUILD_OUTPUT=$(nix build .#default 2>&1 || true)
+SOURCE_HASH=$(echo "$BUILD_OUTPUT" | sed -n 's/.*got:[[:space:]]*\(sha256-[A-Za-z0-9+/=]*\).*/\1/p' | head -1)
+
+if [ -z "$SOURCE_HASH" ]; then
+  echo -e "${RED}Error: Could not extract source hash from build output${NC}"
+  echo "Build output:"
+  echo "$BUILD_OUTPUT"
+  exit 1
+fi
+
+echo -e "${GREEN}Found source hash: ${SOURCE_HASH}${NC}"
+echo ""
+
+# Step 4: Update with real source hash
+echo "Step 4: Updating with correct source hash..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' "s|sha256 = \".*\";|sha256 = \"${SOURCE_HASH}\";|" "$NIX_FILE"
+else
+  sed -i "s|sha256 = \".*\";|sha256 = \"${SOURCE_HASH}\";|" "$NIX_FILE"
+fi
+
+# Step 5: Insert fake pnpmDeps hash
+echo "Step 5: Using fake pnpmDeps hash to trigger hash calculation..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' "s|hash = \".*\";|hash = \"${FAKE_HASH}\";|" "$NIX_FILE"
+else
+  sed -i "s|hash = \".*\";|hash = \"${FAKE_HASH}\";|" "$NIX_FILE"
+fi
+
+# Step 6: Build to get the real pnpmDeps hash
+echo "Step 6: Building package to get correct pnpmDeps hash..."
+echo -e "${YELLOW}(This will fail - that's expected!)${NC}"
+echo ""
+
+BUILD_OUTPUT=$(nix build .#default 2>&1 || true)
+PNPM_HASH=$(echo "$BUILD_OUTPUT" | sed -n 's/.*got:[[:space:]]*\(sha256-[A-Za-z0-9+/=]*\).*/\1/p' | head -1)
+
+if [ -z "$PNPM_HASH" ]; then
+  echo -e "${RED}Error: Could not extract pnpmDeps hash from build output${NC}"
+  echo "Build output:"
+  echo "$BUILD_OUTPUT"
+  exit 1
+fi
+
+echo -e "${GREEN}Found pnpmDeps hash: ${PNPM_HASH}${NC}"
+echo ""
+
+# Step 7: Update with real pnpmDeps hash
+echo "Step 7: Updating with correct pnpmDeps hash..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' "s|hash = \".*\";|hash = \"${PNPM_HASH}\";|" "$NIX_FILE"
+else
+  sed -i "s|hash = \".*\";|hash = \"${PNPM_HASH}\";|" "$NIX_FILE"
+fi
+
+# Step 8: Build again to verify (unless --skip-verify is passed)
+if [ "$SKIP_VERIFY" = "--skip-verify" ]; then
+  echo "Step 8: Skipping verification build (--skip-verify flag passed)"
+  echo ""
+  echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+  echo -e "${GREEN}Success! Nix package updated to v${VERSION}${NC}"
+  echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+  echo ""
+  echo "Changes made to: ${NIX_FILE}"
+  echo ""
+  echo "Source hash: ${SOURCE_HASH}"
+  echo "pnpmDeps hash: ${PNPM_HASH}"
+  echo ""
+  echo -e "${YELLOW}Note: Verification build was skipped. Run 'nix build .#default' locally to verify.${NC}"
+else
+  echo "Step 8: Verifying build with correct hashes..."
+  if nix build .#default; then
+    echo -e "${GREEN}✓ Build successful!${NC}"
+    echo ""
+
+    # Test the binary exists
+    echo "Step 9: Verifying binary exists..."
+    if [ -f "./result/bin/coder" ] && [ -x "./result/bin/coder" ]; then
+      echo -e "${GREEN}✓ Binary exists and is executable!${NC}"
+    else
+      echo -e "${YELLOW}⚠ Warning: Binary not found or not executable${NC}"
+    fi
+
+    # Clean up
+    rm -f result
+
+    echo ""
+    echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+    echo -e "${GREEN}Success! Nix package updated to v${VERSION}${NC}"
+    echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+    echo ""
+    echo "Changes made to: ${NIX_FILE}"
+    echo ""
+    echo "Source hash: ${SOURCE_HASH}"
+    echo "pnpmDeps hash: ${PNPM_HASH}"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Review the changes: git diff ${NIX_FILE}"
+    echo "  2. Commit: git add ${NIX_FILE}"
+    echo "  3. Commit: git commit -m 'chore: update nix package to v${VERSION}'"
+    echo "  4. Push: git push"
+  else
+    echo -e "${RED}✗ Build failed with correct hashes${NC}"
+    echo "Please check the build output above for errors."
+    exit 1
+  fi
+fi

package/source/ai-sdk-client/AISDKClient.spec.ts

@@ -0,0 +1,117 @@
+import test from 'ava';
+import type {AIProviderConfig} from '@/types/index';
+import {AISDKClient} from './AISDKClient.js';
+
+test('AISDKClient constructor initializes with config', t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['test-model-1', 'test-model-2'],
+		config: {
+			baseURL: 'https://api.test.com',
+			apiKey: 'test-key',
+		},
+	};
+
+	const client = new AISDKClient(config);
+
+	t.is(client.getCurrentModel(), 'test-model-1');
+	t.is(client.getContextSize(), 0); // Not yet loaded
+	t.is(client.getMaxRetries(), 2); // Default value
+});
+
+test('AISDKClient.create returns a Promise', async t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['test-model'],
+		config: {
+			baseURL: 'https://api.test.com',
+			apiKey: 'test-key',
+		},
+	};
+
+	const client = await AISDKClient.create(config);
+
+	t.truthy(client);
+	t.true(client instanceof AISDKClient);
+});
+
+test('AISDKClient setModel updates current model', t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['model-1', 'model-2'],
+		config: {
+			baseURL: 'https://api.test.com',
+		},
+	};
+
+	const client = new AISDKClient(config);
+	t.is(client.getCurrentModel(), 'model-1');
+
+	client.setModel('model-2');
+	t.is(client.getCurrentModel(), 'model-2');
+});
+
+test('AISDKClient getAvailableModels returns models array', async t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['model-1', 'model-2', 'model-3'],
+		config: {
+			baseURL: 'https://api.test.com',
+		},
+	};
+
+	const client = new AISDKClient(config);
+	const models = await client.getAvailableModels();
+
+	t.deepEqual(models, ['model-1', 'model-2', 'model-3']);
+});
+
+test('AISDKClient clearContext resolves successfully', async t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['test-model'],
+		config: {
+			baseURL: 'https://api.test.com',
+		},
+	};
+
+	const client = new AISDKClient(config);
+
+	await t.notThrowsAsync(async () => {
+		await client.clearContext();
+	});
+});
+
+test('AISDKClient uses custom maxRetries from config', t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: ['test-model'],
+		maxRetries: 5,
+		config: {
+			baseURL: 'https://api.test.com',
+		},
+	};
+
+	const client = new AISDKClient(config);
+	t.is(client.getMaxRetries(), 5);
+});
+
+test('AISDKClient handles config without models', t => {
+	const config: AIProviderConfig = {
+		name: 'TestProvider',
+		type: 'openai',
+		models: [],
+		config: {
+			baseURL: 'https://api.test.com',
+		},
+	};
+
+	const client = new AISDKClient(config);
+	t.is(client.getCurrentModel(), '');
+});

package/source/ai-sdk-client/AISDKClient.ts

@@ -0,0 +1,155 @@
+import {TIMEOUT_SOCKET_DEFAULT_MS} from '@/constants';
+import {getModelContextLimit} from '@/models/index.js';
+import type {
+	AIProviderConfig,
+	AISDKCoreTool,
+	LLMChatResponse,
+	LLMClient,
+	Message,
+	StreamCallbacks,
+} from '@/types/index';
+import {getLogger} from '@/utils/logging';
+import {createOpenAICompatible} from '@ai-sdk/openai-compatible';
+import type {LanguageModel} from 'ai';
+import {Agent} from 'undici';
+import {handleChat} from './chat/chat-handler.js';
+import {createProvider} from './providers/provider-factory.js';
+
+export class AISDKClient implements LLMClient {
+	private provider: ReturnType<typeof createOpenAICompatible>;
+	private currentModel: string;
+	private availableModels: string[];
+	private providerConfig: AIProviderConfig;
+	private undiciAgent: Agent;
+	private cachedContextSize: number;
+	private maxRetries: number;
+
+	constructor(providerConfig: AIProviderConfig) {
+		const logger = getLogger();
+
+		this.providerConfig = providerConfig;
+		this.availableModels = providerConfig.models;
+		this.currentModel = providerConfig.models[0] || '';
+		this.cachedContextSize = 0;
+		// Default to 2 retries (same as AI SDK default), or use configured value
+		this.maxRetries = providerConfig.maxRetries ?? 2;
+
+		logger.info('AI SDK client initializing', {
+			models: this.availableModels,
+			defaultModel: this.currentModel,
+			provider: providerConfig.name || 'unknown',
+			baseUrl: providerConfig.config.baseURL ? '[REDACTED]' : undefined,
+			maxRetries: this.maxRetries,
+		});
+
+		const {connectionPool} = this.providerConfig;
+		const {requestTimeout, socketTimeout} = this.providerConfig;
+		const effectiveSocketTimeout = socketTimeout ?? requestTimeout;
+		const resolvedSocketTimeout =
+			effectiveSocketTimeout === -1
+				? 0
+				: (effectiveSocketTimeout ?? TIMEOUT_SOCKET_DEFAULT_MS);
+
+		this.undiciAgent = new Agent({
+			connect: {
+				timeout: resolvedSocketTimeout,
+			},
+			bodyTimeout: resolvedSocketTimeout,
+			headersTimeout: resolvedSocketTimeout,
+			keepAliveTimeout: connectionPool?.idleTimeout,
+			keepAliveMaxTimeout: connectionPool?.cumulativeMaxIdleTimeout,
+		});
+
+		this.provider = createProvider(this.providerConfig, this.undiciAgent);
+
+		// Fetch context size asynchronously (don't block construction)
+		void this.updateContextSize();
+	}
+
+	/**
+	 * Fetch and cache context size from models.dev
+	 */
+	private async updateContextSize(): Promise<void> {
+		try {
+			const contextSize = await getModelContextLimit(this.currentModel);
+			this.cachedContextSize = contextSize || 0;
+		} catch {
+			// Silently fail - context size will remain 0
+			this.cachedContextSize = 0;
+		}
+	}
+
+	static create(providerConfig: AIProviderConfig): Promise<AISDKClient> {
+		const client = new AISDKClient(providerConfig);
+		return Promise.resolve(client);
+	}
+
+	setModel(model: string): void {
+		const logger = getLogger();
+		const previousModel = this.currentModel;
+
+		this.currentModel = model;
+
+		logger.info('Model changed', {
+			previousModel,
+			newModel: model,
+			provider: this.providerConfig.name,
+		});
+
+		// Update context size when model changes
+		void this.updateContextSize();
+	}
+
+	getCurrentModel(): string {
+		return this.currentModel;
+	}
+
+	getContextSize(): number {
+		return this.cachedContextSize;
+	}
+
+	getMaxRetries(): number {
+		return this.maxRetries;
+	}
+
+	getAvailableModels(): Promise<string[]> {
+		return Promise.resolve(this.availableModels);
+	}
+
+	/**
+	 * Stream chat with real-time token updates
+	 */
+	async chat(
+		messages: Message[],
+		tools: Record<string, AISDKCoreTool>,
+		callbacks: StreamCallbacks,
+		signal?: AbortSignal,
+	): Promise<LLMChatResponse> {
+		// Get the language model instance from the provider
+		const model = this.provider(this.currentModel) as unknown as LanguageModel;
+
+		// Delegate to chat handler
+		return await handleChat({
+			model,
+			currentModel: this.currentModel,
+			providerConfig: this.providerConfig,
+			messages,
+			tools,
+			callbacks,
+			signal,
+			maxRetries: this.maxRetries,
+		});
+	}
+
+	clearContext(): Promise<void> {
+		const logger = getLogger();
+
+		logger.debug('AI SDK client context cleared', {
+			model: this.currentModel,
+			provider: this.providerConfig.name,
+		});
+
+		// No internal state to clear
+		return Promise.resolve();
+	}
+}

package/source/ai-sdk-client/chat/chat-handler.spec.ts

@@ -0,0 +1,121 @@
+import test from 'ava';
+import type {
+	AIProviderConfig,
+	AISDKCoreTool,
+	Message,
+	StreamCallbacks,
+} from '@/types/index';
+import type {LanguageModel} from 'ai';
+import type {ChatHandlerParams} from './chat-handler.js';
+
+// Note: This file contains basic structure tests
+// Full integration tests would require mocking the AI SDK's generateText function
+// which is complex and better tested through the full AISDKClient
+
+test('ChatHandlerParams has correct structure', t => {
+	const params: ChatHandlerParams = {
+		model: {} as LanguageModel,
+		currentModel: 'test-model',
+		providerConfig: {
+			name: 'TestProvider',
+			type: 'openai',
+			models: ['test-model'],
+			config: {
+				baseURL: 'https://api.test.com',
+				apiKey: 'test-key',
+			},
+		},
+		messages: [],
+		tools: {},
+		callbacks: {},
+		maxRetries: 2,
+	};
+
+	t.is(params.currentModel, 'test-model');
+	t.is(params.providerConfig.name, 'TestProvider');
+	t.deepEqual(params.messages, []);
+	t.deepEqual(params.tools, {});
+});
+
+test('ChatHandlerParams accepts optional signal', t => {
+	const controller = new AbortController();
+	const params: ChatHandlerParams = {
+		model: {} as LanguageModel,
+		currentModel: 'test-model',
+		providerConfig: {
+			name: 'TestProvider',
+			type: 'openai',
+			models: ['test-model'],
+			config: {
+				baseURL: 'https://api.test.com',
+			},
+		},
+		messages: [],
+		tools: {},
+		callbacks: {},
+		signal: controller.signal,
+		maxRetries: 2,
+	};
+
+	t.is(params.signal, controller.signal);
+});
+
+test('ChatHandlerParams accepts messages and tools', t => {
+	const messages: Message[] = [
+		{role: 'user', content: 'Hello'},
+	];
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool,
+	};
+
+	const params: ChatHandlerParams = {
+		model: {} as LanguageModel,
+		currentModel: 'test-model',
+		providerConfig: {
+			name: 'TestProvider',
+			type: 'openai',
+			models: ['test-model'],
+			config: {
+				baseURL: 'https://api.test.com',
+			},
+		},
+		messages,
+		tools,
+		callbacks: {},
+		maxRetries: 2,
+	};
+
+	t.is(params.messages.length, 1);
+	t.is(Object.keys(params.tools).length, 1);
+});
+
+test('ChatHandlerParams accepts callbacks', t => {
+	const callbacks: StreamCallbacks = {
+		onToken: () => {},
+		onToolCall: () => {},
+		onToolExecuted: () => {},
+		onFinish: () => {},
+	};
+
+	const params: ChatHandlerParams = {
+		model: {} as LanguageModel,
+		currentModel: 'test-model',
+		providerConfig: {
+			name: 'TestProvider',
+			type: 'openai',
+			models: ['test-model'],
+			config: {
+				baseURL: 'https://api.test.com',
+			},
+		},
+		messages: [],
+		tools: {},
+		callbacks,
+		maxRetries: 2,
+	};
+
+	t.truthy(params.callbacks.onToken);
+	t.truthy(params.callbacks.onToolCall);
+	t.truthy(params.callbacks.onToolExecuted);
+	t.truthy(params.callbacks.onFinish);
+});