@clinebot/llms 0.0.7 → 0.0.10

package/dist/providers/handlers/base.d.ts

@@ -13,41 +13,16 @@ export declare const DEFAULT_REQUEST_HEADERS: Record<string, string>;
 export declare abstract class BaseHandler implements ApiHandler {
     protected config: ProviderConfig;
     protected abortController: AbortController | undefined;
+    private abortSignalSequence;
     constructor(config: ProviderConfig);
-    /**
-     * Convert Cline messages to provider-specific format
-     * Must be implemented by subclasses
-     */
     abstract getMessages(systemPrompt: string, messages: Message[]): unknown;
-    /**
-     * Create a streaming message completion
-     * Must be implemented by subclasses
-     */
     abstract createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
-    /**
-     * Get the current model configuration
-     * Can be overridden by subclasses for provider-specific logic
-     */
     getModel(): HandlerModelInfo;
-    /**
-     * Get usage information (optional)
-     * Override in subclasses that support this
-     */
     getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined>;
-    /**
-     * Get the abort signal for the current request
-     * Creates a new AbortController if one doesn't exist or was already aborted
-     * Combines with config.abortSignal if provided
-     */
     protected getAbortSignal(): AbortSignal;
-    /**
-     * Abort the current request
-     */
     abort(): void;
     setAbortSignal(signal: AbortSignal | undefined): void;
-    /**
-     * Helper to calculate cost from usage
-     */
+    private logAbort;
     protected calculateCost(inputTokens: number, outputTokens: number, cacheReadTokens?: number): number | undefined;
     protected createResponseId(): string;
     protected withResponseId<T extends ApiStreamChunk>(chunk: T, responseId: string): T;

package/dist/providers/transform/openai-format.d.ts

@@ -9,7 +9,7 @@ type OpenAIMessage = OpenAI.Chat.ChatCompletionMessageParam;
 /**
  * Convert messages to OpenAI format
  */
-export declare function convertToOpenAIMessages(messages: Message[]): OpenAIMessage[];
+export declare function convertToOpenAIMessages(messages: Message[], enableCaching?: boolean): OpenAIMessage[];
 /**
  * Convert tool definitions to OpenAI format
  */

package/dist/providers/types/config.d.ts

@@ -187,6 +187,10 @@ export interface ProviderOptions {
     /** Runtime model catalog refresh configuration */
     modelCatalog?: ModelCatalogConfig;
 }
+/**
+ * Provider-specific options that don't fit other categories
+ */
+import type { BasicLogger } from "@clinebot/shared";
 /**
  * Runtime model catalog refresh options
  */
@@ -219,6 +223,8 @@ export interface ProviderConfig extends AuthConfig, EndpointConfig, ModelConfig,
     onRetryAttempt?: (attempt: number, maxRetries: number, delay: number, error: unknown) => void;
     /** AbortSignal for cancelling requests */
     abortSignal?: AbortSignal;
+    /** Optional runtime logger for provider-level diagnostics */
+    logger?: BasicLogger;
     /** Codex CLI-specific options */
     codex?: CodexConfig;
     /** Claude Code-specific options */

package/package.json

@@ -1,10 +1,11 @@
 {
 	"name": "@clinebot/llms",
-	"version": "0.0.7",
+	"version": "0.0.10",
 	"description": "Config-driven SDK for selecting, extending, and instantiating LLM providers and models",
 	"main": "./dist/index.js",
 	"module": "./dist/index.js",
 	"dependencies": {
+		"@clinebot/shared": "0.0.10",
 		"@ai-sdk/amazon-bedrock": "^4.0.67",
 		"@ai-sdk/google-vertex": "^4.0.74",
 		"@ai-sdk/mistral": "^3.0.24",

package/src/index.browser.ts

@@ -1,6 +1,6 @@
 export { defineLlmsConfig, loadLlmsConfigFromFile } from "./config-browser";
-export * as models from "./models/index";
-export * as providers from "./providers/public.browser";
+export * as LlmsModels from "./models/index";
+export * as LlmsProviders from "./providers/public.browser";
 export type {
 	CustomProviderConfig,
 	LlmsConfig,

package/src/index.ts

@@ -1,6 +1,6 @@
 export { defineLlmsConfig } from "./config";
-export * as models from "./models/index";
-export * as providers from "./providers/public";
+export * as LlmsModels from "./models/index";
+export * as LlmsProviders from "./providers/public";
 export { createLlmsSdk } from "./sdk";
 export type {
 	CustomProviderConfig,

package/src/models/providers/vercel-ai-gateway.ts

@@ -14,7 +14,7 @@ export const VERCEL_AI_GATEWAY_PROVIDER: ModelCollection = {
 		name: "Vercel AI Gateway",
 		description: "Vercel's AI gateway service",
 		protocol: "openai-chat",
-		baseUrl: "https://ai-gateway.vercel.app/v1",
+		baseUrl: "https://ai-gateway.vercel.sh/v1",
 		defaultModelId: Object.keys(VERCEL_AI_GATEWAY_MODELS)[0],
 		capabilities: ["reasoning"],
 		env: ["AI_GATEWAY_API_KEY"],

package/src/providers/handlers/anthropic-base.ts

@@ -145,7 +145,8 @@ export class AnthropicHandler extends BaseHandler {
 				thinking: reasoningOn
 					? { type: "enabled", budget_tokens: budgetTokens }
 					: undefined,
-				max_tokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
+				max_tokens:
+					model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
 				temperature: reasoningOn ? undefined : 0,
 				system: supportsPromptCache
 					? [
@@ -173,6 +174,7 @@ export class AnthropicHandler extends BaseHandler {
 			cacheReadTokens: 0,
 			cacheWriteTokens: 0,
 		};
+		let stopReason: string | null = null;
 
 		for await (const chunk of stream) {
 			if (debugThinking) {
@@ -185,6 +187,11 @@ export class AnthropicHandler extends BaseHandler {
 					countChunk(`content_block_delta:${chunk.delta?.type ?? "unknown"}`);
 				}
 			}
+			if (chunk.type === "message_delta") {
+				stopReason =
+					(chunk as { delta?: { stop_reason?: string } }).delta?.stop_reason ??
+					stopReason;
+			}
 			yield* this.withResponseIdForAll(
 				this.processChunk(chunk, currentToolCall, usageSnapshot, responseId),
 				responseId,
@@ -199,8 +206,12 @@ export class AnthropicHandler extends BaseHandler {
 			console.error(`[thinking-debug][anthropic][stream] ${summary}`);
 		}
 
-		// Yield done chunk to indicate streaming completed successfully
-		yield { type: "done", success: true, id: responseId };
+		yield {
+			type: "done",
+			success: true,
+			id: responseId,
+			incompleteReason: stopReason === "max_tokens" ? "max_tokens" : undefined,
+		};
 	}
 
 	protected *processChunk(

package/src/providers/handlers/base.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { ApiStream, ProviderConfig } from "../types/index";
 import { BaseHandler } from "./base";
 
@@ -18,6 +18,10 @@ class TestHandler extends BaseHandler {
 	): number | undefined {
 		return this.calculateCost(inputTokens, outputTokens, cacheReadTokens);
 	}
+
+	public exposeAbortSignal(): AbortSignal {
+		return this.getAbortSignal();
+	}
 }
 
 describe("BaseHandler.calculateCost", () => {
@@ -44,3 +48,58 @@ describe("BaseHandler.calculateCost", () => {
 		expect(cost).toBeCloseTo(17.73, 6);
 	});
 });
+
+describe("BaseHandler abort signal wiring", () => {
+	it("does not let a stale request signal abort a newer request", () => {
+		const logger = {
+			debug: vi.fn(),
+			warn: vi.fn(),
+		};
+		const request1 = new AbortController();
+		const handler = new TestHandler({
+			providerId: "openrouter",
+			modelId: "mock-model",
+			apiKey: "test-key",
+			baseUrl: "https://example.com/v1",
+			abortSignal: request1.signal,
+			logger,
+		});
+
+		const signal1 = handler.exposeAbortSignal();
+		expect(signal1.aborted).toBe(false);
+
+		const request2 = new AbortController();
+		handler.setAbortSignal(request2.signal);
+		const signal2 = handler.exposeAbortSignal();
+		expect(signal2).not.toBe(signal1);
+		expect(signal2.aborted).toBe(false);
+
+		request1.abort(new Error("stale timeout"));
+
+		expect(signal1.aborted).toBe(true);
+		expect(signal2.aborted).toBe(false);
+		expect(logger.warn).toHaveBeenCalledWith(
+			"Provider request abort signal fired",
+			expect.objectContaining({
+				reason: expect.objectContaining({ message: "stale timeout" }),
+			}),
+		);
+	});
+
+	it("creates a fresh controller for each request", () => {
+		const handler = new TestHandler({
+			providerId: "openrouter",
+			modelId: "mock-model",
+			apiKey: "test-key",
+			baseUrl: "https://example.com/v1",
+			abortSignal: new AbortController().signal,
+		});
+
+		const signal1 = handler.exposeAbortSignal();
+		const signal2 = handler.exposeAbortSignal();
+
+		expect(signal2).not.toBe(signal1);
+		expect(signal1.aborted).toBe(false);
+		expect(signal2.aborted).toBe(false);
+	});
+});

package/src/providers/handlers/base.ts

@@ -22,37 +22,44 @@ export const DEFAULT_REQUEST_HEADERS: Record<string, string> = {
 	"X-CLIENT-TYPE": "cline-sdk",
 };
 
+const controllerIds = new WeakMap<AbortController, string>();
+let controllerIdCounter = 0;
+
+function getControllerId(controller: AbortController): string {
+	let id = controllerIds.get(controller);
+	if (!id) {
+		id = `abort_${++controllerIdCounter}`;
+		controllerIds.set(controller, id);
+	}
+	return id;
+}
+
+function serializeAbortReason(reason: unknown): unknown {
+	return reason instanceof Error
+		? { name: reason.name, message: reason.message }
+		: reason;
+}
+
 /**
  * Base handler class with common functionality
  */
 export abstract class BaseHandler implements ApiHandler {
 	protected config: ProviderConfig;
 	protected abortController: AbortController | undefined;
+	private abortSignalSequence = 0;
 
 	constructor(config: ProviderConfig) {
 		this.config = config;
 	}
 
-	/**
-	 * Convert Cline messages to provider-specific format
-	 * Must be implemented by subclasses
-	 */
 	abstract getMessages(systemPrompt: string, messages: Message[]): unknown;
 
-	/**
-	 * Create a streaming message completion
-	 * Must be implemented by subclasses
-	 */
 	abstract createMessage(
 		systemPrompt: string,
 		messages: Message[],
 		tools?: ToolDefinition[],
 	): ApiStream;
 
-	/**
-	 * Get the current model configuration
-	 * Can be overridden by subclasses for provider-specific logic
-	 */
 	getModel(): HandlerModelInfo {
 		const modelId = this.config.modelId;
 		return {
@@ -61,43 +68,55 @@ export abstract class BaseHandler implements ApiHandler {
 		};
 	}
 
-	/**
-	 * Get usage information (optional)
-	 * Override in subclasses that support this
-	 */
 	async getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined> {
 		return undefined;
 	}
 
-	/**
-	 * Get the abort signal for the current request
-	 * Creates a new AbortController if one doesn't exist or was already aborted
-	 * Combines with config.abortSignal if provided
-	 */
 	protected getAbortSignal(): AbortSignal {
-		// Create a new controller if needed
-		if (!this.abortController || this.abortController.signal.aborted) {
-			this.abortController = new AbortController();
-		}
-
-		// If a signal was provided in config, chain it
-		if (this.config.abortSignal) {
-			const configSignal = this.config.abortSignal;
+		const controller = new AbortController();
+		this.abortController = controller;
+		controller.signal.addEventListener(
+			"abort",
+			() => {
+				if (this.abortController === controller) {
+					this.abortController = undefined;
+				}
+			},
+			{ once: true },
+		);
+
+		const configSignal = this.config.abortSignal;
+		if (configSignal) {
 			if (configSignal.aborted) {
-				this.abortController.abort(configSignal.reason);
+				this.logAbort("debug", "Provider request inherited aborted signal", {
+					controllerId: getControllerId(controller),
+					reason: serializeAbortReason(configSignal.reason),
+				});
+				controller.abort(configSignal.reason);
 			} else {
-				configSignal.addEventListener("abort", () => {
-					this.abortController?.abort(configSignal.reason);
+				const signalId = ++this.abortSignalSequence;
+				configSignal.addEventListener(
+					"abort",
+					() => {
+						this.logAbort("warn", "Provider request abort signal fired", {
+							controllerId: getControllerId(controller),
+							signalId,
+							reason: serializeAbortReason(configSignal.reason),
+						});
+						controller.abort(configSignal.reason);
+					},
+					{ once: true },
+				);
+				this.logAbort("debug", "Provider request attached abort signal", {
+					controllerId: getControllerId(controller),
+					signalId,
 				});
 			}
 		}
 
-		return this.abortController.signal;
+		return controller.signal;
 	}
 
-	/**
-	 * Abort the current request
-	 */
 	abort(): void {
 		this.abortController?.abort();
 	}
@@ -105,37 +124,47 @@ export abstract class BaseHandler implements ApiHandler {
 	setAbortSignal(signal: AbortSignal | undefined): void {
 		this.config.abortSignal = signal;
 		if (signal?.aborted) {
+			this.logAbort("debug", "Provider handler received pre-aborted signal", {
+				controllerId: this.abortController
+					? getControllerId(this.abortController)
+					: undefined,
+				reason: serializeAbortReason(signal.reason),
+			});
 			this.abortController?.abort(signal.reason);
 		}
 	}
 
-	/**
-	 * Helper to calculate cost from usage
-	 */
+	private logAbort(
+		level: "debug" | "warn",
+		message: string,
+		metadata?: Record<string, unknown>,
+	): void {
+		this.config.logger?.[level]?.(message, {
+			providerId: this.config.providerId,
+			modelId: this.config.modelId,
+			...metadata,
+		});
+	}
+
 	protected calculateCost(
 		inputTokens: number,
 		outputTokens: number,
 		cacheReadTokens = 0,
 	): number | undefined {
-		const modelPricingSource =
-			this.config.modelInfo ??
-			(this.config.modelId
-				? this.config.knownModels?.[this.config.modelId]
-				: undefined);
-		const pricing = modelPricingSource?.pricing;
+		const pricing = (
+			this.config.modelInfo ?? this.config.knownModels?.[this.config.modelId]
+		)?.pricing;
 		if (!pricing?.input || !pricing?.output) {
 			return undefined;
 		}
 
-		const uncachedInputTokens = inputTokens - cacheReadTokens;
-		const inputCost = (uncachedInputTokens / 1_000_000) * pricing.input;
-		const outputCost = (outputTokens / 1_000_000) * pricing.output;
-		const cacheReadCost =
-			cacheReadTokens > 0
+		return (
+			((inputTokens - cacheReadTokens) / 1_000_000) * pricing.input +
+			(outputTokens / 1_000_000) * pricing.output +
+			(cacheReadTokens > 0
 				? (cacheReadTokens / 1_000_000) * (pricing.cacheRead ?? 0)
-				: 0;
-
-		return inputCost + outputCost + cacheReadCost;
+				: 0)
+		);
 	}
 
 	protected createResponseId(): string {
@@ -154,7 +183,7 @@ export abstract class BaseHandler implements ApiHandler {
 		responseId: string,
 	): Generator<ApiStreamChunk> {
 		for (const chunk of chunks) {
-			yield this.withResponseId(chunk, responseId);
+			yield { ...chunk, id: responseId };
 		}
 	}
 

package/src/providers/handlers/bedrock-base.ts

@@ -143,7 +143,7 @@ export class BedrockHandler extends BaseHandler {
 			model: factory(modelId),
 			messages: this.getMessages(systemPrompt, messages),
 			tools: toAiSdkTools(tools),
-			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
+			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
 			temperature: reasoningEnabled ? undefined : (model.info.temperature ?? 0),
 			providerOptions:
 				Object.keys(providerOptions).length > 0 ? providerOptions : undefined,

package/src/providers/handlers/gemini-base.test.ts

@@ -218,4 +218,44 @@ describe("GeminiHandler", () => {
 		expect(secondId).toBeTruthy();
 		expect(firstId).not.toBe(secondId);
 	});
+
+	it("defaults maxOutputTokens to 8192 for gemini-3-flash when no model or config limit is provided", async () => {
+		generateContentStreamSpy.mockResolvedValue(createAsyncIterable([]));
+
+		const handler = new GeminiHandler({
+			providerId: "gemini",
+			modelId: "gemini-3-flash",
+			apiKey: "test-key",
+		});
+
+		await collectChunks(
+			handler.createMessage("System", [{ role: "user", content: "go" }]),
+		);
+
+		expect(generateContentStreamSpy).toHaveBeenCalledTimes(1);
+		const request = generateContentStreamSpy.mock.calls[0]?.[0] as {
+			config?: { maxOutputTokens?: number };
+		};
+		expect(request.config?.maxOutputTokens).toBe(8192);
+	});
+
+	it("defaults maxOutputTokens to 128000 for non gemini-3-flash models when no model or config limit is provided", async () => {
+		generateContentStreamSpy.mockResolvedValue(createAsyncIterable([]));
+
+		const handler = new GeminiHandler({
+			providerId: "gemini",
+			modelId: "gemini-2.5-flash",
+			apiKey: "test-key",
+		});
+
+		await collectChunks(
+			handler.createMessage("System", [{ role: "user", content: "go" }]),
+		);
+
+		expect(generateContentStreamSpy).toHaveBeenCalledTimes(1);
+		const request = generateContentStreamSpy.mock.calls[0]?.[0] as {
+			config?: { maxOutputTokens?: number };
+		};
+		expect(request.config?.maxOutputTokens).toBe(128000);
+	});
 });

package/src/providers/handlers/gemini-base.ts

@@ -27,6 +27,16 @@ import { RetriableError, retryStream } from "../utils/retry";
 import { BaseHandler } from "./base";
 
 const DEFAULT_THINKING_BUDGET_TOKENS = 1024;
+const DEFAULT_MAX_OUTPUT_TOKENS = 128_000;
+const GEMINI_3_FLASH_MAX_OUTPUT_TOKENS = 8192;
+
+function isGemini3FlashModel(modelId: string): boolean {
+	const normalized = modelId.toLowerCase();
+	return (
+		normalized.includes("gemini-3-flash") ||
+		normalized.includes("gemini-3.0-flash")
+	);
+}
 
 /**
  * Handler for Google's Gemini API
@@ -131,6 +141,11 @@ export class GeminiHandler extends BaseHandler {
 		}
 
 		// Build request config with abort signal
+		const fallbackMaxOutputTokens = isGemini3FlashModel(modelId)
+			? GEMINI_3_FLASH_MAX_OUTPUT_TOKENS
+			: DEFAULT_MAX_OUTPUT_TOKENS;
+		const maxOutputTokens =
+			info.maxTokens ?? this.config.maxOutputTokens ?? fallbackMaxOutputTokens;
 		const requestConfig: GenerateContentConfig = {
 			httpOptions: this.config.baseUrl
 				? { baseUrl: this.config.baseUrl, headers: this.getRequestHeaders() }
@@ -138,7 +153,7 @@ export class GeminiHandler extends BaseHandler {
 			abortSignal,
 			systemInstruction: systemPrompt,
 			temperature: info.temperature ?? 1,
-			maxOutputTokens: info.maxTokens ?? this.config.maxOutputTokens,
+			maxOutputTokens,
 		};
 
 		// Add thinking config only when explicitly requested and supported.

package/src/providers/handlers/openai-base.ts

@@ -22,6 +22,7 @@ import type {
 	ModelInfo,
 	ProviderConfig,
 } from "../types";
+import { hasModelCapability } from "../types";
 import type { Message, ToolDefinition } from "../types/messages";
 import { retryStream } from "../utils/retry";
 import { ToolCallProcessor } from "../utils/tool-processor";
@@ -106,9 +107,26 @@ export class OpenAIBaseHandler extends BaseHandler {
 		systemPrompt: string,
 		messages: Message[],
 	): OpenAI.Chat.ChatCompletionMessageParam[] {
+		const model = this.getModel();
+		const supportsPromptCache =
+			hasModelCapability(model.info, "prompt-cache") ||
+			this.config.capabilities?.includes("prompt-cache") === true;
+		const systemMessage = supportsPromptCache
+			? ({
+					role: "system",
+					content: [
+						{
+							type: "text",
+							text: systemPrompt,
+							cache_control: { type: "ephemeral" },
+						},
+					],
+				} as unknown as OpenAI.Chat.ChatCompletionMessageParam)
+			: { role: "system" as const, content: systemPrompt };
+
 		return [
-			{ role: "system", content: systemPrompt },
-			...convertToOpenAIMessages(messages),
+			systemMessage,
+			...convertToOpenAIMessages(messages, supportsPromptCache),
 		];
 	}
 
@@ -171,7 +189,11 @@ export class OpenAIBaseHandler extends BaseHandler {
 			this.config.reasoningEffort ??
 			(this.config.thinking ? DEFAULT_REASONING_EFFORT : undefined);
 		if (supportsReasoningEffort && effectiveReasoningEffort) {
-			(requestOptions as any).reasoning_effort = effectiveReasoningEffort;
+			(
+				requestOptions as OpenAI.ChatCompletionCreateParamsStreaming & {
+					reasoning_effort?: string;
+				}
+			).reasoning_effort = effectiveReasoningEffort;
 		}
 
 		const requestHeaders = this.getRequestHeaders();
@@ -191,16 +213,25 @@ export class OpenAIBaseHandler extends BaseHandler {
 			headers: requestHeaders,
 		});
 		const toolCallProcessor = new ToolCallProcessor();
+		let finishReason: string | null = null;
 
 		for await (const chunk of stream) {
+			const choice = chunk.choices?.[0];
+			if (choice?.finish_reason) {
+				finishReason = choice.finish_reason;
+			}
 			yield* this.withResponseIdForAll(
 				this.processChunk(chunk, toolCallProcessor, modelInfo, responseId),
 				responseId,
 			);
 		}
 
-		// Yield done chunk to indicate streaming completed successfully
-		yield { type: "done", success: true, id: responseId };
+		yield {
+			type: "done",
+			success: true,
+			id: responseId,
+			incompleteReason: finishReason === "length" ? "max_tokens" : undefined,
+		};
 	}
 
 	/**
@@ -213,9 +244,11 @@ export class OpenAIBaseHandler extends BaseHandler {
 		_modelInfo: ModelInfo,
 		responseId: string,
 	): Generator<import("../types").ApiStreamChunk> {
-		const delta = chunk.choices?.[0]?.delta && {
-			...chunk.choices[0].delta,
-			reasoning_content: (chunk.choices[0].delta as any).reasoning_content,
+		const rawDelta = chunk.choices?.[0]?.delta;
+		const delta = rawDelta && {
+			...rawDelta,
+			reasoning_content: (rawDelta as { reasoning_content?: string })
+				.reasoning_content,
 		};
 
 		// Handle text content
@@ -227,7 +260,7 @@ export class OpenAIBaseHandler extends BaseHandler {
 		if (delta?.reasoning_content) {
 			yield {
 				type: "reasoning",
-				reasoning: (delta as any).reasoning_content,
+				reasoning: delta.reasoning_content,
 				id: responseId,
 			};
 		}
@@ -248,10 +281,21 @@ export class OpenAIBaseHandler extends BaseHandler {
 		if (chunk.usage) {
 			const inputTokens = chunk.usage.prompt_tokens ?? 0;
 			const outputTokens = chunk.usage.completion_tokens ?? 0;
+			const usageWithCache = chunk.usage as typeof chunk.usage & {
+				prompt_tokens_details?: {
+					cached_tokens?: number;
+					cache_write_tokens?: number;
+				};
+				prompt_cache_miss_tokens?: number;
+				cache_creation_input_tokens?: number;
+				cache_read_input_tokens?: number;
+			};
 			const cacheReadTokens =
-				(chunk.usage as any).prompt_tokens_details?.cached_tokens ?? 0;
+				usageWithCache.prompt_tokens_details?.cached_tokens ?? 0;
 			const cacheWriteTokens =
-				(chunk.usage as any).prompt_cache_miss_tokens ?? 0;
+				usageWithCache.prompt_tokens_details?.cache_write_tokens ??
+				usageWithCache.prompt_cache_miss_tokens ??
+				0;
 
 			yield {
 				type: "usage",

package/src/providers/handlers/vertex.ts

@@ -241,7 +241,7 @@ export class VertexHandler extends BaseHandler {
 				promptCacheOn,
 			}),
 			tools: toAiSdkTools(tools),
-			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
+			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
 			temperature: reasoningOn ? undefined : 0,
 			providerOptions:
 				Object.keys(providerOptions).length > 0 ? providerOptions : undefined,