@ottocode/sdk 0.1.311 → 0.1.313

package/src/providers/src/moonshot-client.ts

@@ -1,25 +1,133 @@
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import type { OAuth } from '../../types/src/index.ts';
 import { catalog } from './catalog-merged.ts';
 
-export type MoonshotProviderConfig = {
+export type KimiProviderConfig = {
 	apiKey?: string;
 	baseURL?: string;
+	oauth?: OAuth;
 };
 
-export function createMoonshotModel(
-	model: string,
-	config?: MoonshotProviderConfig,
-) {
+/** @deprecated Use `KimiProviderConfig` */
+export type MoonshotProviderConfig = KimiProviderConfig;
+
+export function readKimiApiKeyFromEnv(): string {
+	return process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY || '';
+}
+
+/**
+ * Kimi/Moonshot streaming responses report token usage on the final chunk's
+ * `choices[0].usage` instead of the OpenAI-standard top-level `usage` field.
+ * The AI SDK openai-compatible parser only reads top-level `usage`, so we
+ * hoist choice-level usage to the top level when it is missing.
+ */
+export function hoistKimiSseUsage(line: string): string {
+	const hasCarriageReturn = line.endsWith('\r');
+	const raw = hasCarriageReturn ? line.slice(0, -1) : line;
+	if (!raw.startsWith('data:')) return line;
+	const payload = raw.slice(5).trim();
+	if (!payload || payload === '[DONE]') return line;
+	try {
+		const parsed = JSON.parse(payload) as {
+			usage?: unknown;
+			choices?: Array<{ usage?: unknown } | null>;
+		};
+		if (!parsed || typeof parsed !== 'object' || parsed.usage != null) {
+			return line;
+		}
+		const choiceUsage = Array.isArray(parsed.choices)
+			? parsed.choices.find((choice) => choice?.usage != null)?.usage
+			: undefined;
+		if (choiceUsage == null) return line;
+		parsed.usage = choiceUsage;
+		return `data: ${JSON.stringify(parsed)}${hasCarriageReturn ? '\r' : ''}`;
+	} catch {
+		return line;
+	}
+}
+
+/**
+ * Wraps fetch so Kimi SSE chunks carrying `choices[0].usage` are rewritten to
+ * expose a top-level `usage` field the AI SDK can parse.
+ */
+export function createKimiUsageFetch(
+	baseFetch: typeof fetch = fetch,
+): typeof fetch {
+	const wrappedFetch = async (
+		input: Parameters<typeof fetch>[0],
+		init?: Parameters<typeof fetch>[1],
+	): Promise<Response> => {
+		const response = await baseFetch(input, init);
+		const contentType = response.headers.get('content-type') ?? '';
+		if (
+			!response.ok ||
+			!response.body ||
+			!contentType.includes('text/event-stream')
+		) {
+			return response;
+		}
+
+		const decoder = new TextDecoder();
+		const encoder = new TextEncoder();
+		let buffered = '';
+		const transform = new TransformStream<Uint8Array, Uint8Array>({
+			transform(chunk, controller) {
+				buffered += decoder.decode(chunk, { stream: true });
+				const lines = buffered.split('\n');
+				buffered = lines.pop() ?? '';
+				for (const line of lines) {
+					controller.enqueue(encoder.encode(`${hoistKimiSseUsage(line)}\n`));
+				}
+			},
+			flush(controller) {
+				buffered += decoder.decode();
+				if (buffered.length) {
+					controller.enqueue(encoder.encode(hoistKimiSseUsage(buffered)));
+				}
+			},
+		});
+
+		const headers = new Headers(response.headers);
+		headers.delete('content-length');
+		headers.delete('content-encoding');
+		return new Response(response.body.pipeThrough(transform), {
+			status: response.status,
+			statusText: response.statusText,
+			headers,
+		});
+	};
+	return wrappedFetch as typeof fetch;
+}
+
+export function createKimiModel(model: string, config?: KimiProviderConfig) {
 	const entry = catalog.moonshot;
-	const baseURL = config?.baseURL || entry?.api || 'https://api.moonshot.ai/v1';
-	const apiKey = config?.apiKey || process.env.MOONSHOT_API_KEY || '';
+	const oauthAccess = config?.oauth?.access;
+	const defaultApiBaseURL = entry?.api ?? 'https://api.moonshot.ai/v1';
+	const configuredBaseURL = config?.baseURL;
+	const kimiCodeBaseURL =
+		process.env.KIMI_CODE_BASE_URL ?? 'https://api.kimi.com/coding/v1';
+	const baseURL =
+		oauthAccess &&
+		(!configuredBaseURL || configuredBaseURL === defaultApiBaseURL)
+			? kimiCodeBaseURL
+			: (configuredBaseURL ?? defaultApiBaseURL);
+	const apiKey = oauthAccess || config?.apiKey || readKimiApiKeyFromEnv();
 	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
 
 	const instance = createOpenAICompatible({
-		name: entry?.label ?? 'Moonshot AI',
+		name: 'Kimi',
 		baseURL,
 		headers,
+		fetch: createKimiUsageFetch(),
 	});
 
 	return instance(model);
 }
+
+/** @deprecated Use `createKimiModel` */
+export function createMoonshotModel(
+	model: string,
+	config?: MoonshotProviderConfig,
+) {
+	return createKimiModel(model, config);
+}

package/src/providers/src/registry.ts

@@ -1,6 +1,7 @@
 import { catalog } from './catalog-merged.ts';
-import { providerEnvVar } from './env.ts';
+import { providerEnvVar, readEnvKey } from './env.ts';
 import { getCachedProviderCatalogEntry } from './model-catalog-cache.ts';
+import { mergeModelLists } from './model-merge.ts';
 import { getUnderlyingProviderKey, providerIds } from './utils.ts';
 import type {
 	BuiltInProviderId,
@@ -94,7 +95,9 @@ function resolveCustomFamily(
 	return settings.family ?? 'default';
 }
 
-export function isBuiltInProviderId(
+export const KIMI_PROVIDER_ALIAS = 'kimi' as const;
+
+function isCatalogBuiltInProviderId(
 	value: unknown,
 ): value is BuiltInProviderId {
 	return (
@@ -103,6 +106,20 @@ export function isBuiltInProviderId(
 	);
 }
 
+export function resolveBuiltInProviderCatalogId(
+	provider: ProviderId,
+): BuiltInProviderId | undefined {
+	if (provider === KIMI_PROVIDER_ALIAS) return 'moonshot';
+	if (isCatalogBuiltInProviderId(provider)) return provider;
+	return undefined;
+}
+
+export function isBuiltInProviderId(
+	value: unknown,
+): value is BuiltInProviderId {
+	return isCatalogBuiltInProviderId(value) || value === KIMI_PROVIDER_ALIAS;
+}
+
 export function getProviderSettings(
 	cfg: OttoConfig,
 	provider: ProviderId,
@@ -115,23 +132,37 @@ export function getProviderDefinition(
 	provider: ProviderId,
 ): ResolvedProviderDefinition | undefined {
 	const settings = getProviderSettings(cfg, provider);
-	if (isBuiltInProviderId(provider)) {
-		const entry = catalog[provider];
+	const catalogProvider = resolveBuiltInProviderCatalogId(provider);
+	if (catalogProvider) {
+		const entry = catalog[catalogProvider];
 		if (!entry) return undefined;
-		const cachedEntry = getCachedProviderCatalogEntry(provider);
-		const models = cachedEntry?.models ?? entry.models;
+		const cachedEntry = getCachedProviderCatalogEntry(catalogProvider);
+		const models = mergeModelLists(entry.models, cachedEntry?.models);
+		const moonshotSettings =
+			provider === KIMI_PROVIDER_ALIAS
+				? (getProviderSettings(cfg, 'moonshot') ?? settings)
+				: settings;
+		const resolvedSettings =
+			provider === KIMI_PROVIDER_ALIAS
+				? (settings ?? moonshotSettings)
+				: settings;
 		return {
 			id: provider,
-			label: settings?.label ?? cachedEntry?.label ?? entry.label ?? provider,
+			label:
+				resolvedSettings?.label ??
+				(provider === KIMI_PROVIDER_ALIAS
+					? 'Kimi'
+					: (cachedEntry?.label ?? entry.label ?? provider)),
 			source: 'built-in',
-			compatibility: BUILTIN_COMPATIBILITY[provider],
-			family: BUILTIN_FAMILY[provider],
-			baseURL: normalizeOptionalText(settings?.baseURL) ?? entry.api,
-			apiKey: normalizeOptionalText(settings?.apiKey),
+			compatibility: BUILTIN_COMPATIBILITY[catalogProvider],
+			family: BUILTIN_FAMILY[catalogProvider],
+			baseURL: normalizeOptionalText(resolvedSettings?.baseURL) ?? entry.api,
+			apiKey: normalizeOptionalText(resolvedSettings?.apiKey),
 			apiKeyEnv:
-				normalizeOptionalText(settings?.apiKeyEnv) ?? providerEnvVar(provider),
+				normalizeOptionalText(resolvedSettings?.apiKeyEnv) ??
+				providerEnvVar(provider),
 			models,
-			allowAnyModel: provider === 'ollama-cloud',
+			allowAnyModel: catalogProvider === 'ollama-cloud',
 		};
 	}
 
@@ -171,6 +202,7 @@ export function getConfiguredProviderIds(
 	const includeDisabled = options?.includeDisabled === true;
 	const ids = new Set<ProviderId>([
 		...providerIds,
+		KIMI_PROVIDER_ALIAS,
 		...Object.keys(cfg.providers),
 		cfg.defaults.provider,
 	]);
@@ -224,8 +256,11 @@ export function getConfiguredProviderFamily(
 	const definition = getProviderDefinition(cfg, provider);
 	if (!definition) return null;
 	if (definition.source === 'custom') return definition.family;
-	if (isBuiltInProviderId(provider)) {
-		return getUnderlyingProviderKey(provider, model) ?? definition.family;
+	const catalogProvider = resolveBuiltInProviderCatalogId(provider);
+	if (catalogProvider) {
+		return (
+			getUnderlyingProviderKey(catalogProvider, model) ?? definition.family
+		);
 	}
 	return definition.family;
 }
@@ -245,6 +280,10 @@ export function getConfiguredProviderApiKey(
 	const definition = getProviderDefinition(cfg, provider);
 	if (!definition) return undefined;
 	if (definition.apiKey?.length) return definition.apiKey;
+	if (provider === KIMI_PROVIDER_ALIAS || provider === 'moonshot') {
+		const envValue = readEnvKey(provider);
+		if (envValue?.length) return envValue;
+	}
 	if (definition.apiKeyEnv?.length) {
 		const value = process.env[definition.apiKeyEnv];
 		if (value?.length) return value;

package/src/providers/src/utils.ts

@@ -1,5 +1,6 @@
 import { catalog } from './catalog-merged.ts';
 import { getCachedProviderCatalogEntry } from './model-catalog-cache.ts';
+import { mergeModelLists } from './model-merge.ts';
 import type {
 	BuiltInProviderId,
 	ProviderId,
@@ -7,7 +8,7 @@ import type {
 	ModelOwner,
 } from '../../types/src/index.ts';
 import { filterModelsForAuthType } from './oauth-models.ts';
-import { isBuiltInProviderId } from './registry.ts';
+import { resolveBuiltInProviderCatalogId } from './registry.ts';
 
 export const providerIds = Object.keys(catalog) as BuiltInProviderId[];
 
@@ -44,18 +45,25 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 	xai: ['grok-code-fast-1', 'grok-4-fast'],
 	zai: ['glm-4.5-flash'],
 	copilot: ['gpt-4.1-mini'],
+	moonshot: ['kimi-k2-turbo-preview'],
 };
 
 const PREFERRED_FAST_MODELS_OAUTH: Partial<Record<ProviderId, string[]>> = {
 	openai: ['gpt-5.4-mini'],
 	anthropic: ['claude-haiku-4-5'],
+	moonshot: ['kimi-k2.7-code'],
 };
 
+function preferredFastModelKey(provider: ProviderId): ProviderId {
+	return resolveBuiltInProviderCatalogId(provider) ?? provider;
+}
+
 export function getFastModel(provider: ProviderId): string | undefined {
 	const providerModels = getProviderModels(provider);
 	if (!providerModels.length) return undefined;
 
-	const preferred = PREFERRED_FAST_MODELS[provider] ?? [];
+	const preferred =
+		PREFERRED_FAST_MODELS[preferredFastModelKey(provider)] ?? [];
 	for (const modelId of preferred) {
 		if (providerModels.some((m) => m.id === modelId)) {
 			return modelId;
@@ -85,7 +93,7 @@ export function getFastModelForAuth(
 
 	const preferredMap =
 		authType === 'oauth' ? PREFERRED_FAST_MODELS_OAUTH : PREFERRED_FAST_MODELS;
-	const preferred = preferredMap[provider] ?? [];
+	const preferred = preferredMap[preferredFastModelKey(provider)] ?? [];
 	for (const modelId of preferred) {
 		if (filteredModels.some((m) => m.id === modelId)) {
 			return modelId;
@@ -108,7 +116,8 @@ export function getModelNpmBinding(
 	provider: ProviderId,
 	model: string,
 ): string | undefined {
-	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
+	const catalogProvider = resolveBuiltInProviderCatalogId(provider);
+	const entry = catalogProvider ? catalog[catalogProvider] : undefined;
 	const modelInfo = getProviderModels(provider).find((m) => m.id === model);
 	if (modelInfo?.provider?.npm) return modelInfo.provider.npm;
 	if (entry?.npm) return entry.npm;
@@ -240,17 +249,21 @@ export function getModelInfo(
 	provider: ProviderId,
 	model: string,
 ): ModelInfo | undefined {
-	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
+	const catalogProvider = resolveBuiltInProviderCatalogId(provider);
+	const entry = catalogProvider ? catalog[catalogProvider] : undefined;
 	if (!entry) return undefined;
 	return getProviderModels(provider).find((m) => m.id === model);
 }
 
 function getProviderModels(provider: ProviderId): ModelInfo[] {
-	return (
-		getCachedProviderCatalogEntry(provider)?.models ??
-		(isBuiltInProviderId(provider) ? catalog[provider]?.models : undefined) ??
-		[]
-	);
+	const catalogProvider = resolveBuiltInProviderCatalogId(provider);
+	const catalogModels = catalogProvider
+		? catalog[catalogProvider]?.models
+		: undefined;
+	const cachedModels = getCachedProviderCatalogEntry(
+		catalogProvider ?? provider,
+	)?.models;
+	return mergeModelLists(catalogModels, cachedModels);
 }
 
 export function modelSupportsReasoning(

package/src/providers/src/validate.ts

@@ -1,11 +1,12 @@
 import { catalog } from './catalog-merged.ts';
 import { getCachedProviderCatalogEntry } from './model-catalog-cache.ts';
+import { mergeModelLists } from './model-merge.ts';
 import type { OttoConfig, ProviderId } from '../../types/src/index.ts';
 import {
 	getProviderDefinition,
 	hasConfiguredModel,
-	isBuiltInProviderId,
 	providerAllowsAnyModel,
+	resolveBuiltInProviderCatalogId,
 } from './registry.ts';
 
 export type CapabilityRequest = {
@@ -28,7 +29,9 @@ export function validateProviderModel(
 	if (cfg) {
 		const definition = getProviderDefinition(cfg, providerId);
 		const cachedModels =
-			getCachedProviderCatalogEntry(providerId)?.models ?? [];
+			getCachedProviderCatalogEntry(
+				resolveBuiltInProviderCatalogId(providerId) ?? providerId,
+			)?.models ?? [];
 		if (!definition) {
 			if (!cachedModels.length) {
 				throw new Error(`Provider not supported: ${providerId}`);
@@ -69,12 +72,13 @@ export function validateProviderModel(
 	}
 
 	const p = providerId;
-	const builtInEntry = isBuiltInProviderId(p) ? catalog[p] : undefined;
-	if (!builtInEntry && !getCachedProviderCatalogEntry(p)) {
+	const catalogProvider = resolveBuiltInProviderCatalogId(p);
+	const builtInEntry = catalogProvider ? catalog[catalogProvider] : undefined;
+	const cachedEntry = getCachedProviderCatalogEntry(catalogProvider ?? p);
+	if (!builtInEntry && !cachedEntry) {
 		throw new Error(`Provider not supported: ${providerId}`);
 	}
-	const models =
-		getCachedProviderCatalogEntry(p)?.models ?? builtInEntry?.models ?? [];
+	const models = mergeModelLists(builtInEntry?.models, cachedEntry?.models);
 	const entry = models.find((m: { id: string }) => m.id === modelId);
 	if (!entry) {
 		throwModelNotFound(providerId, modelId, models);