@agi-cli/server 0.1.133 → 0.1.135

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.133",
+	"version": "0.1.135",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.133",
-		"@agi-cli/database": "0.1.133",
+		"@agi-cli/sdk": "0.1.135",
+		"@agi-cli/database": "0.1.135",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/events/bus.ts

@@ -4,12 +4,27 @@ type Subscriber = (evt: AGIEvent) => void;
 
 const subscribers = new Map<string, Set<Subscriber>>(); // sessionId -> subs
 
+function sanitizeBigInt<T>(obj: T): T {
+	if (obj === null || obj === undefined) return obj;
+	if (typeof obj === 'bigint') return Number(obj) as T;
+	if (Array.isArray(obj)) return obj.map(sanitizeBigInt) as T;
+	if (typeof obj === 'object') {
+		const result: Record<string, unknown> = {};
+		for (const [key, value] of Object.entries(obj)) {
+			result[key] = sanitizeBigInt(value);
+		}
+		return result as T;
+	}
+	return obj;
+}
+
 export function publish(event: AGIEvent) {
+	const sanitizedEvent = sanitizeBigInt(event);
 	const subs = subscribers.get(event.sessionId);
 	if (!subs) return;
 	for (const sub of subs) {
 		try {
-			sub(event);
+			sub(sanitizedEvent);
 		} catch {}
 	}
 }

package/src/routes/session-stream.ts

@@ -2,6 +2,12 @@ import type { Hono } from 'hono';
 import { subscribe } from '../events/bus.ts';
 import type { AGIEvent } from '../events/types.ts';
 
+function safeStringify(obj: unknown): string {
+	return JSON.stringify(obj, (_key, value) =>
+		typeof value === 'bigint' ? Number(value) : value,
+	);
+}
+
 export function registerSessionStreamRoute(app: Hono) {
 	app.get('/v1/sessions/:id/stream', async (c) => {
 		const sessionId = c.req.param('id');
@@ -16,9 +22,14 @@ export function registerSessionStreamRoute(app: Hono) {
 		const stream = new ReadableStream<Uint8Array>({
 			start(controller) {
 				const write = (evt: AGIEvent) => {
-					const line =
-						`event: ${evt.type}\n` +
-						`data: ${JSON.stringify(evt.payload ?? {})}\n\n`;
+					let line: string;
+					try {
+						line =
+							`event: ${evt.type}\n` +
+							`data: ${safeStringify(evt.payload ?? {})}\n\n`;
+					} catch {
+						line = `event: ${evt.type}\ndata: {}\n\n`;
+					}
 					controller.enqueue(encoder.encode(line));
 				};
 				const unsubscribe = subscribe(sessionId, write);

package/src/runtime/agent/runner.ts

@@ -23,6 +23,7 @@ import {
 	createFinishHandler,
 } from '../stream/handlers.ts';
 import { pruneSession } from '../message/compaction.ts';
+import { triggerDeferredTitleGeneration } from '../message/service.ts';
 import { setupRunner } from './runner-setup.ts';
 import {
 	type ReasoningState,
@@ -67,6 +68,7 @@ async function runAssistant(opts: RunOpts) {
 
 	const setup = await setupRunner(opts);
 	const {
+		cfg,
 		db,
 		history,
 		system,
@@ -188,6 +190,13 @@ async function runAssistant(opts: RunOpts) {
 				if (!firstDeltaSeen) {
 					firstDeltaSeen = true;
 					streamStartTimer.end();
+					if (isFirstMessage) {
+						void triggerDeferredTitleGeneration({
+							cfg,
+							db,
+							sessionId: opts.sessionId,
+						});
+					}
 				}
 
 				if (!currentPartId) {

package/src/runtime/message/service.ts

@@ -1,5 +1,5 @@
 import { generateText, streamText } from 'ai';
-import { eq } from 'drizzle-orm';
+import { eq, asc } from 'drizzle-orm';
 import type { AGIConfig } from '@agi-cli/sdk';
 import type { DB } from '@agi-cli/database';
 import { messages, messageParts, sessions } from '@agi-cli/database/schema';
@@ -127,8 +127,6 @@ export async function dispatchAssistantMessage(
 		payload: { id: userMessageId, role: 'user' },
 	});
 
-	enqueueSessionTitle({ cfg, db, sessionId, content });
-
 	const assistantMessageId = crypto.randomUUID();
 	await db.insert(messages).values({
 		id: assistantMessageId,
@@ -304,12 +302,20 @@ async function generateSessionTitle(args: {
 
 		const promptText = String(content ?? '').slice(0, 2000);
 
-		const titlePrompt = [
-			'Generate a brief title (6-8 words) summarizing what the user wants to do.',
-			'Rules: Plain text only. No markdown, no quotes, no punctuation, no emojis.',
-			'Focus on the core task or topic. Be specific but concise.',
-			'Examples: "Fix TypeScript build errors", "Add dark mode toggle", "Refactor auth middleware"',
-		].join(' ');
+		const titleInstructions = `Generate a brief title (6-8 words) summarizing what the user wants to do.
+Rules: Plain text only. No markdown, no quotes, no punctuation, no emojis.
+Focus on the core task or topic. Be specific but concise.
+Examples: "Fix TypeScript build errors", "Add dark mode toggle", "Refactor auth middleware"
+
+Output ONLY the title, nothing else.`;
+
+		const userMessageWithTags = `<task>
+${titleInstructions}
+</task>
+
+<user-message>
+${promptText}
+</user-message>`;
 
 		// Build system prompt and messages
 		// For OAuth: Keep spoof pure, add instructions to user message
@@ -323,7 +329,7 @@ async function generateSessionTitle(args: {
 			messagesArray = [
 				{
 					role: 'user',
-					content: `${titlePrompt}\n\n${promptText}`,
+					content: userMessageWithTags,
 				},
 			];
 
@@ -335,8 +341,13 @@ async function generateSessionTitle(args: {
 			);
 		} else {
 			// API key mode: normal flow
-			system = titlePrompt;
-			messagesArray = [{ role: 'user', content: promptText }];
+			system = titleInstructions;
+			messagesArray = [
+				{
+					role: 'user',
+					content: `<user-message>\n${promptText}\n</user-message>`,
+				},
+			];
 
 			debugLog(
 				`[TITLE_GEN] Using API key mode (prompts: title-generator, user-request)`,
@@ -441,3 +452,61 @@ async function touchSessionLastActive(args: {
 		debugLog('[touchSessionLastActive] Error:', err);
 	}
 }
+
+export async function triggerDeferredTitleGeneration(args: {
+	cfg: AGIConfig;
+	db: DB;
+	sessionId: string;
+}): Promise<void> {
+	const { cfg, db, sessionId } = args;
+
+	try {
+		const userMessages = await db
+			.select()
+			.from(messages)
+			.where(eq(messages.sessionId, sessionId))
+			.orderBy(asc(messages.createdAt))
+			.limit(1);
+
+		if (!userMessages.length || userMessages[0].role !== 'user') {
+			debugLog(
+				'[TITLE_GEN] No user message found for deferred title generation',
+			);
+			return;
+		}
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, userMessages[0].id))
+			.orderBy(asc(messageParts.index))
+			.limit(1);
+
+		if (!parts.length) {
+			debugLog(
+				'[TITLE_GEN] No message parts found for deferred title generation',
+			);
+			return;
+		}
+
+		let content = '';
+		try {
+			const parsed = JSON.parse(parts[0].content ?? '{}');
+			content = String(parsed.text ?? '');
+		} catch {
+			debugLog('[TITLE_GEN] Failed to parse message part content');
+			return;
+		}
+
+		if (!content) {
+			debugLog('[TITLE_GEN] Empty content for deferred title generation');
+			return;
+		}
+
+		debugLog('[TITLE_GEN] Triggering deferred title generation');
+		enqueueSessionTitle({ cfg, db, sessionId, content });
+	} catch (err) {
+		debugLog('[TITLE_GEN] Error in triggerDeferredTitleGeneration:');
+		debugLog(err);
+	}
+}

package/src/runtime/provider/anthropic.ts

@@ -1,10 +1,14 @@
 import type { AGIConfig } from '@agi-cli/sdk';
-import { getAuth, refreshToken, setAuth } from '@agi-cli/sdk';
+import {
+	getAuth,
+	refreshToken,
+	setAuth,
+	createAnthropicOAuthModel,
+	createAnthropicCachingFetch,
+} from '@agi-cli/sdk';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { toClaudeCodeName } from '../tools/mapping.ts';
 
-const CLAUDE_CLI_VERSION = '1.0.61';
-
 export async function getAnthropicInstance(cfg: AGIConfig) {
 	const auth = await getAuth('anthropic', cfg.projectRoot);
 
@@ -32,312 +36,15 @@ export async function getAnthropicInstance(cfg: AGIConfig) {
 			};
 		}
 
-		const customFetch = async (
-			input: string | URL | Request,
-			init?: RequestInit,
-		) => {
-			const initHeaders = init?.headers;
-			const headers: Record<string, string> = {};
-
-			if (initHeaders) {
-				if (initHeaders instanceof Headers) {
-					initHeaders.forEach((value, key) => {
-						if (key.toLowerCase() !== 'x-api-key') {
-							headers[key] = value;
-						}
-					});
-				} else if (Array.isArray(initHeaders)) {
-					for (const [key, value] of initHeaders) {
-						if (
-							key &&
-							key.toLowerCase() !== 'x-api-key' &&
-							typeof value === 'string'
-						) {
-							headers[key] = value;
-						}
-					}
-				} else {
-					for (const [key, value] of Object.entries(initHeaders)) {
-						if (
-							key.toLowerCase() !== 'x-api-key' &&
-							typeof value === 'string'
-						) {
-							headers[key] = value;
-						}
-					}
-				}
-			}
-
-			headers.authorization = `Bearer ${currentAuth.access}`;
-			headers['anthropic-beta'] =
-				'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14';
-			headers['anthropic-dangerous-direct-browser-access'] = 'true';
-			headers['anthropic-version'] = '2023-06-01';
-			headers['user-agent'] =
-				`claude-cli/${CLAUDE_CLI_VERSION} (external, cli)`;
-			headers['x-app'] = 'cli';
-			headers['content-type'] = 'application/json';
-			headers.accept = 'application/json';
-
-			headers['x-stainless-arch'] = process.arch === 'arm64' ? 'arm64' : 'x64';
-			headers['x-stainless-helper-method'] = 'stream';
-			headers['x-stainless-lang'] = 'js';
-			headers['x-stainless-os'] =
-				process.platform === 'darwin'
-					? 'MacOS'
-					: process.platform === 'win32'
-						? 'Windows'
-						: 'Linux';
-			headers['x-stainless-package-version'] = '0.70.0';
-			headers['x-stainless-retry-count'] = '0';
-			headers['x-stainless-runtime'] = 'node';
-			headers['x-stainless-runtime-version'] = process.version;
-			headers['x-stainless-timeout'] = '600';
-
-			let url = typeof input === 'string' ? input : input.toString();
-			if (url.includes('/v1/messages') && !url.includes('beta=true')) {
-				url += url.includes('?') ? '&beta=true' : '?beta=true';
-			}
-
-			let body = init?.body;
-			if (body && typeof body === 'string') {
-				try {
-					const parsed = JSON.parse(body);
-
-					if (parsed.tools && Array.isArray(parsed.tools)) {
-						parsed.tools = parsed.tools.map(
-							(tool: { name: string; [key: string]: unknown }) => ({
-								...tool,
-								name: toClaudeCodeName(tool.name),
-							}),
-						);
-					}
-
-					const MAX_SYSTEM_CACHE = 1;
-					const MAX_MESSAGE_CACHE = 1;
-					let systemCacheUsed = 0;
-					let messageCacheUsed = 0;
-
-					if (parsed.system && Array.isArray(parsed.system)) {
-						parsed.system = parsed.system.map(
-							(
-								block: { type: string; cache_control?: unknown },
-								index: number,
-							) => {
-								if (block.cache_control) return block;
-								if (
-									systemCacheUsed < MAX_SYSTEM_CACHE &&
-									index === 0 &&
-									block.type === 'text'
-								) {
-									systemCacheUsed++;
-									return { ...block, cache_control: { type: 'ephemeral' } };
-								}
-								return block;
-							},
-						);
-					}
-
-					if (parsed.messages && Array.isArray(parsed.messages)) {
-						const messageCount = parsed.messages.length;
-
-						parsed.messages = parsed.messages.map(
-							(
-								msg: {
-									role: string;
-									content: unknown;
-									[key: string]: unknown;
-								},
-								msgIndex: number,
-							) => {
-								const isLast = msgIndex === messageCount - 1;
-
-								if (Array.isArray(msg.content)) {
-									const content = msg.content.map(
-										(
-											block: {
-												type: string;
-												name?: string;
-												cache_control?: unknown;
-											},
-											blockIndex: number,
-										) => {
-											let transformedBlock = block;
-
-											if (block.type === 'tool_use' && block.name) {
-												transformedBlock = {
-													...block,
-													name: toClaudeCodeName(block.name),
-												};
-											}
-											if (block.type === 'tool_result' && block.name) {
-												transformedBlock = {
-													...block,
-													name: toClaudeCodeName(block.name),
-												};
-											}
-
-											if (
-												isLast &&
-												!transformedBlock.cache_control &&
-												messageCacheUsed < MAX_MESSAGE_CACHE &&
-												blockIndex === (msg.content as unknown[]).length - 1
-											) {
-												messageCacheUsed++;
-												return {
-													...transformedBlock,
-													cache_control: { type: 'ephemeral' },
-												};
-											}
-
-											return transformedBlock;
-										},
-									);
-									return { ...msg, content };
-								}
-
-								if (
-									isLast &&
-									messageCacheUsed < MAX_MESSAGE_CACHE &&
-									typeof msg.content === 'string'
-								) {
-									messageCacheUsed++;
-									return {
-										...msg,
-										content: [
-											{
-												type: 'text',
-												text: msg.content,
-												cache_control: { type: 'ephemeral' },
-											},
-										],
-									};
-								}
-
-								return msg;
-							},
-						);
-					}
-
-					body = JSON.stringify(parsed);
-				} catch {
-					// If parsing fails, send as-is
-				}
-			}
-
-			return fetch(url, {
-				...init,
-				body,
-				headers,
+		return (model: string) =>
+			createAnthropicOAuthModel(model, {
+				oauth: currentAuth,
+				toolNameTransformer: toClaudeCodeName,
 			});
-		};
-		return createAnthropic({
-			apiKey: '',
-			fetch: customFetch as typeof fetch,
-		});
 	}
 
-	const customFetch = async (
-		input: string | URL | Request,
-		init?: RequestInit,
-	) => {
-		let body = init?.body;
-		if (body && typeof body === 'string') {
-			try {
-				const parsed = JSON.parse(body);
-
-				const MAX_SYSTEM_CACHE = 1;
-				const MAX_MESSAGE_CACHE = 1;
-				let systemCacheUsed = 0;
-				let messageCacheUsed = 0;
-
-				if (parsed.system && Array.isArray(parsed.system)) {
-					parsed.system = parsed.system.map(
-						(
-							block: { type: string; cache_control?: unknown },
-							index: number,
-						) => {
-							if (block.cache_control) return block;
-							if (
-								systemCacheUsed < MAX_SYSTEM_CACHE &&
-								index === 0 &&
-								block.type === 'text'
-							) {
-								systemCacheUsed++;
-								return { ...block, cache_control: { type: 'ephemeral' } };
-							}
-							return block;
-						},
-					);
-				}
-
-				if (parsed.messages && Array.isArray(parsed.messages)) {
-					const messageCount = parsed.messages.length;
-					parsed.messages = parsed.messages.map(
-						(
-							msg: {
-								role: string;
-								content: unknown;
-								[key: string]: unknown;
-							},
-							msgIndex: number,
-						) => {
-							const isLast = msgIndex === messageCount - 1;
-
-							if (Array.isArray(msg.content)) {
-								const blocks = msg.content as {
-									type: string;
-									cache_control?: unknown;
-								}[];
-								const content = blocks.map((block, blockIndex) => {
-									if (block.cache_control) return block;
-									if (
-										isLast &&
-										messageCacheUsed < MAX_MESSAGE_CACHE &&
-										blockIndex === blocks.length - 1
-									) {
-										messageCacheUsed++;
-										return { ...block, cache_control: { type: 'ephemeral' } };
-									}
-									return block;
-								});
-								return { ...msg, content };
-							}
-
-							if (
-								isLast &&
-								messageCacheUsed < MAX_MESSAGE_CACHE &&
-								typeof msg.content === 'string'
-							) {
-								messageCacheUsed++;
-								return {
-									...msg,
-									content: [
-										{
-											type: 'text',
-											text: msg.content,
-											cache_control: { type: 'ephemeral' },
-										},
-									],
-								};
-							}
-
-							return msg;
-						},
-					);
-				}
-
-				body = JSON.stringify(parsed);
-			} catch {
-				// If parsing fails, send as-is
-			}
-		}
-
-		const url = typeof input === 'string' ? input : input.toString();
-		return fetch(url, { ...init, body });
-	};
-
+	const cachingFetch = createAnthropicCachingFetch();
 	return createAnthropic({
-		fetch: customFetch as typeof fetch,
+		fetch: cachingFetch as typeof fetch,
 	});
 }

package/src/runtime/provider/google.ts

@@ -1,12 +1,8 @@
 import type { AGIConfig } from '@agi-cli/sdk';
-import { getAuth } from '@agi-cli/sdk';
-import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
+import { getAuth, createGoogleModel } from '@agi-cli/sdk';
 
 export async function resolveGoogleModel(model: string, cfg: AGIConfig) {
 	const auth = await getAuth('google', cfg.projectRoot);
-	if (auth?.type === 'api' && auth.key) {
-		const instance = createGoogleGenerativeAI({ apiKey: auth.key });
-		return instance(model);
-	}
-	return google(model);
+	const apiKey = auth?.type === 'api' ? auth.key : undefined;
+	return createGoogleModel(model, { apiKey });
 }

package/src/runtime/provider/index.ts

@@ -16,7 +16,9 @@ export async function resolveModel(
 	options?: { systemPrompt?: string; sessionId?: string },
 ) {
 	if (provider === 'openai') {
-		return resolveOpenAIModel(model, cfg, options);
+		return resolveOpenAIModel(model, cfg, {
+			systemPrompt: options?.systemPrompt,
+		});
 	}
 	if (provider === 'anthropic') {
 		const instance = await getAnthropicInstance(cfg);

package/src/runtime/provider/openai.ts

@@ -7,8 +7,6 @@ export async function resolveOpenAIModel(
 	cfg: AGIConfig,
 	options?: {
 		systemPrompt?: string;
-		promptCacheKey?: string;
-		promptCacheRetention?: 'in_memory' | '24h';
 	},
 ) {
 	const auth = await getAuth('openai', cfg.projectRoot);
@@ -20,8 +18,6 @@ export async function resolveOpenAIModel(
 			reasoningEffort: isCodexModel ? 'high' : 'medium',
 			reasoningSummary: 'auto',
 			instructions: options?.systemPrompt,
-			promptCacheKey: options?.promptCacheKey,
-			promptCacheRetention: options?.promptCacheRetention,
 		});
 	}
 	if (auth?.type === 'api' && auth.key) {

package/src/runtime/provider/opencode.ts

@@ -1,61 +1,7 @@
-import type { AGIConfig, ProviderId } from '@agi-cli/sdk';
-import { catalog } from '@agi-cli/sdk';
-import { createOpenAI } from '@ai-sdk/openai';
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-
-function normalizeModelIdentifier(provider: ProviderId, model: string): string {
-	const prefix = `${provider}/`;
-	return model.startsWith(prefix) ? model.slice(prefix.length) : model;
-}
+import type { AGIConfig } from '@agi-cli/sdk';
+import { createOpencodeModel } from '@agi-cli/sdk';
 
 export function resolveOpencodeModel(model: string, _cfg: AGIConfig) {
-	const entry = catalog.opencode;
-	const normalizedModel = normalizeModelIdentifier('opencode', model);
-	const modelInfo =
-		entry?.models.find((m) => m.id === normalizedModel) ??
-		entry?.models.find((m) => m.id === model);
-	const resolvedModelId = modelInfo?.id ?? normalizedModel ?? model;
-	const binding = modelInfo?.provider?.npm ?? entry?.npm;
-	const apiKey = process.env.OPENCODE_API_KEY ?? '';
-	const baseURL =
-		modelInfo?.provider?.baseURL ||
-		modelInfo?.provider?.api ||
-		entry?.api ||
-		'https://opencode.ai/zen/v1';
-	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-	if (binding === '@ai-sdk/openai') {
-		const instance = createOpenAI({ apiKey, baseURL });
-		return instance(resolvedModelId);
-	}
-	if (binding === '@ai-sdk/anthropic') {
-		const instance = createAnthropic({ apiKey, baseURL });
-		return instance(resolvedModelId);
-	}
-	if (binding === '@ai-sdk/openai-compatible') {
-		const instance = createOpenAICompatible({
-			name: entry?.label ?? 'opencode',
-			baseURL,
-			headers,
-		});
-		return instance(resolvedModelId);
-	}
-
-	const ocOpenAI = createOpenAI({ apiKey, baseURL });
-	const ocAnthropic = createAnthropic({ apiKey, baseURL });
-	const ocCompat = createOpenAICompatible({
-		name: entry?.label ?? 'opencode',
-		baseURL,
-		headers,
-	});
-
-	const id = resolvedModelId.toLowerCase();
-	if (id.includes('claude')) return ocAnthropic(resolvedModelId);
-	if (
-		id.includes('qwen3-coder') ||
-		id.includes('grok-code') ||
-		id.includes('kimi-k2')
-	)
-		return ocCompat(resolvedModelId);
-	return ocOpenAI(resolvedModelId);
+	const apiKey = process.env.OPENCODE_API_KEY;
+	return createOpencodeModel(model, { apiKey });
 }

package/src/runtime/provider/openrouter.ts

@@ -1,11 +1,7 @@
-import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { getOpenRouterInstance, createOpenRouterModel } from '@agi-cli/sdk';
 
-export function getOpenRouterInstance() {
-	const apiKey = process.env.OPENROUTER_API_KEY ?? '';
-	return createOpenRouter({ apiKey });
-}
+export { getOpenRouterInstance };
 
 export function resolveOpenRouterModel(model: string) {
-	const openrouter = getOpenRouterInstance();
-	return openrouter.chat(model);
+	return createOpenRouterModel(model);
 }

package/src/runtime/provider/zai.ts

@@ -1,53 +1,16 @@
 import type { AGIConfig } from '@agi-cli/sdk';
-import { catalog, getAuth } from '@agi-cli/sdk';
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { getAuth, createZaiModel, createZaiCodingModel } from '@agi-cli/sdk';
 
 export async function getZaiInstance(cfg: AGIConfig, model: string) {
 	const auth = await getAuth('zai', cfg.projectRoot);
-	const entry = catalog.zai;
-
-	let apiKey = '';
-	const baseURL = entry?.api || 'https://api.z.ai/api/paas/v4';
-
-	if (auth?.type === 'api' && auth.key) {
-		apiKey = auth.key;
-	} else {
-		apiKey = process.env.ZAI_API_KEY || process.env.ZHIPU_API_KEY || '';
-	}
-
-	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-
-	const instance = createOpenAICompatible({
-		name: entry?.label ?? 'Z.AI',
-		baseURL,
-		headers,
-	});
-
-	return instance(model);
+	const apiKey = auth?.type === 'api' ? auth.key : undefined;
+	return createZaiModel(model, { apiKey });
 }
 
 export async function getZaiCodingInstance(cfg: AGIConfig, model: string) {
 	const auth =
 		(await getAuth('zai', cfg.projectRoot)) ||
 		(await getAuth('zai-coding', cfg.projectRoot));
-	const entry = catalog['zai-coding'];
-
-	let apiKey = '';
-	const baseURL = entry?.api || 'https://api.z.ai/api/coding/paas/v4';
-
-	if (auth?.type === 'api' && auth.key) {
-		apiKey = auth.key;
-	} else {
-		apiKey = process.env.ZAI_API_KEY || process.env.ZHIPU_API_KEY || '';
-	}
-
-	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-
-	const instance = createOpenAICompatible({
-		name: entry?.label ?? 'Z.AI Coding',
-		baseURL,
-		headers,
-	});
-
-	return instance(model);
+	const apiKey = auth?.type === 'api' ? auth.key : undefined;
+	return createZaiCodingModel(model, { apiKey });
 }