@eddyskywalker/dsh-chatgpt-subscription 0.37.0 → 0.38.1

package/lib/index.js

@@ -23621,114 +23621,6 @@ var OllamaAccountPool = class extends AccountPoolCore {
 	}
 };
 //#endregion
-//#region src/host/kimi-code/model-catalog.ts
-/**
-* The four ids the subscription serves today.
-*
-* `kimi-for-coding` is the alias that never changes: Moonshot upgrades the model
-* behind it in place (K2.7 Code became K2.8 Preview without a config change), so
-* this entry is the durable default a user can leave selected.
-*/
-const KIMI_CODE_MODELS = [
-	{
-		id: "k3",
-		name: "K3",
-		version: "K3",
-		contextWindow: 262144,
-		maxContextWindow: 1048576,
-		maxTokens: 32768,
-		inputModalities: [
-			"text",
-			"image",
-			"video"
-		],
-		reasoningEfforts: [
-			"low",
-			"high",
-			"max"
-		],
-		defaultReasoningEffort: "high",
-		minimumPlan: "Moderato",
-		contextPlan: "Allegretto",
-		description: "The most capable flagship coding model: 2.8T parameters, 1M context window. The 1M context consumes about twice the quota of k3-256k.",
-		supportsDynamicTools: true,
-		quotaMultiplier: 2,
-		speed: "regular"
-	},
-	{
-		id: "k3-256k",
-		name: "K3 (256K)",
-		version: "K3",
-		contextWindow: 262144,
-		maxContextWindow: null,
-		maxTokens: 32768,
-		inputModalities: ["text", "image"],
-		reasoningEfforts: [
-			"low",
-			"high",
-			"max"
-		],
-		defaultReasoningEffort: "high",
-		minimumPlan: "Moderato",
-		contextPlan: null,
-		description: "The 256K context version of K3, available to every Moderato member and above. Costs about half the quota of k3 with 1M context, and does not accept video input.",
-		supportsDynamicTools: true,
-		quotaMultiplier: 1,
-		speed: "regular"
-	},
-	{
-		id: "kimi-for-coding",
-		name: "Kimi for Coding",
-		version: "K2.8 Preview",
-		contextWindow: 1048576,
-		maxContextWindow: null,
-		maxTokens: 32768,
-		inputModalities: [
-			"text",
-			"image",
-			"video"
-		],
-		reasoningEfforts: [
-			"low",
-			"high",
-			"max"
-		],
-		defaultReasoningEffort: "max",
-		minimumPlan: null,
-		contextPlan: null,
-		description: "Performance close to K3 with more efficient thinking, and up to 1M context on every plan. Good at code completion and routine development tasks.",
-		supportsDynamicTools: true,
-		quotaMultiplier: 1,
-		speed: "regular"
-	},
-	{
-		id: "kimi-for-coding-highspeed",
-		name: "Kimi for Coding HighSpeed",
-		version: "K2.7 Code HighSpeed",
-		contextWindow: 262144,
-		maxContextWindow: null,
-		maxTokens: 32768,
-		inputModalities: [
-			"text",
-			"image",
-			"video"
-		],
-		reasoningEfforts: ["high"],
-		defaultReasoningEffort: "high",
-		minimumPlan: "Allegretto",
-		contextPlan: null,
-		description: "The high-speed version of K2.7 Code with the same coding ability and roughly 5-6x faster output, at 3x quota usage. Requires the Allegretto plan or above.",
-		supportsDynamicTools: false,
-		quotaMultiplier: 3,
-		speed: "highspeed"
-	}
-];
-const BY_ID$1 = new Map(KIMI_CODE_MODELS.map((model) => [model.id, model]));
-/** Registry entry for one model id, or undefined when the id is unknown. */
-function kimiCodeModelDef(modelId) {
-	return BY_ID$1.get(modelId.trim());
-}
-//#endregion
 //#region src/host/common/request-images.ts
 function isRecord$39(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -24122,6 +24014,194 @@ function imageBlockToInline$2(block, images) {
 	} : void 0;
 }
 //#endregion
+//#region src/host/kimi-code/model-catalog.ts
+/**
+* Request-body ceiling the 1M-context tier defaults to.
+*
+* The 2 MB figure this line used to apply to every model comes from the gateway's
+* generic error example and was never measured against a 1M window, while a real
+* 1M session (3-4 MB of Chinese prose) hits it long before the window is full.
+* The official kimi-cli ships no byte guard at all, so the ceiling is this
+* plugin's own safety net rather than a client requirement.
+*
+* 8 MiB is sized so bytes never become the binding limit for a 1M session: that
+* window's body is roughly 4 MB of English or 4.5 MB of dense Chinese, so 8 MiB
+* leaves nearly double the headroom. What binds first is the model's own token
+* window — the service answers "Your request exceeded model token limit", which
+* common/context-overflow.ts already normalizes to CONTEXT_WINDOW_EXCEEDED, so
+* compaction and retry behave exactly as they did before.
+*
+* The number is still an UPPER BOUND pending measurement, not a documented
+* gateway limit: a deployment that has measured its own gateway pins the real
+* figure with DSH_KIMI_CODE_MAX_BODY_BYTES. The 256K tier keeps 2 MB, where the
+* old ceiling and the window line up.
+*/
+const LONG_CONTEXT_MESSAGE_BODY_BYTES = 8 * 1024 * 1024;
+/**
+* The ids the subscription serves today.
+*
+* `kimi-for-coding` is the alias that never changes: Moonshot upgrades the model
+* behind it in place (K2.7 Code became K2.8 Preview without a config change), so
+* this entry is the durable default a user can leave selected.
+*/
+const KIMI_CODE_MODELS = [
+	{
+		id: "k3",
+		name: "K3",
+		version: "K3",
+		contextWindow: 262144,
+		maxContextWindow: 1048576,
+		maxTokens: 32768,
+		maxRequestBodyBytes: LONG_CONTEXT_MESSAGE_BODY_BYTES,
+		inputModalities: [
+			"text",
+			"image",
+			"video"
+		],
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "high",
+		minimumPlan: "Moderato",
+		contextPlan: "Allegretto",
+		description: "The most capable flagship coding model: 2.8T parameters, 1M context window. The 1M context consumes about twice the quota of k3-256k.",
+		supportsDynamicTools: true,
+		quotaMultiplier: 2,
+		speed: "regular"
+	},
+	{
+		id: "k3-256k",
+		name: "K3 (256K)",
+		version: "K3",
+		contextWindow: 262144,
+		maxContextWindow: null,
+		maxTokens: 32768,
+		maxRequestBodyBytes: MAX_MESSAGE_BODY_BYTES,
+		inputModalities: ["text", "image"],
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "high",
+		minimumPlan: "Moderato",
+		contextPlan: null,
+		description: "The 256K context version of K3, available to every Moderato member and above. Costs about half the quota of k3 with 1M context, and does not accept video input.",
+		supportsDynamicTools: true,
+		quotaMultiplier: 1,
+		speed: "regular"
+	},
+	{
+		id: "kimi-for-coding",
+		name: "Kimi for Coding",
+		version: "K2.8 Preview",
+		contextWindow: 1048576,
+		maxContextWindow: null,
+		maxTokens: 32768,
+		maxRequestBodyBytes: LONG_CONTEXT_MESSAGE_BODY_BYTES,
+		inputModalities: [
+			"text",
+			"image",
+			"video"
+		],
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "max",
+		minimumPlan: null,
+		contextPlan: null,
+		description: "Performance close to K3 with more efficient thinking, and up to 1M context on every plan. Good at code completion and routine development tasks.",
+		supportsDynamicTools: true,
+		quotaMultiplier: 1,
+		speed: "regular"
+	},
+	{
+		id: "kimi-for-coding-highspeed",
+		name: "Kimi for Coding HighSpeed",
+		version: "K2.7 Code HighSpeed",
+		contextWindow: 262144,
+		maxContextWindow: null,
+		maxTokens: 32768,
+		maxRequestBodyBytes: MAX_MESSAGE_BODY_BYTES,
+		inputModalities: [
+			"text",
+			"image",
+			"video"
+		],
+		reasoningEfforts: ["high"],
+		defaultReasoningEffort: "high",
+		minimumPlan: "Allegretto",
+		contextPlan: null,
+		description: "The high-speed version of K2.7 Code with the same coding ability and roughly 5-6x faster output, at 3x quota usage. Requires the Allegretto plan or above.",
+		supportsDynamicTools: false,
+		quotaMultiplier: 3,
+		speed: "highspeed"
+	},
+	{
+		id: "k3.1-pro",
+		name: "K3.1 Pro",
+		version: "K3.1 Pro",
+		contextWindow: 262144,
+		maxContextWindow: 1048576,
+		maxTokens: 32768,
+		maxRequestBodyBytes: LONG_CONTEXT_MESSAGE_BODY_BYTES,
+		inputModalities: [
+			"text",
+			"image",
+			"video"
+		],
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "max",
+		thinkingType: "only",
+		minimumPlan: "Moderato",
+		contextPlan: "Allegretto",
+		description: "The K3.1 Pro flagship: 3T parameters, a 256K context window on Plus/Moderato and 1M on Pro/Allegretto and above. Thinking runs at low/high/max, defaults to max, and cannot be disabled.",
+		supportsDynamicTools: true,
+		quotaMultiplier: null,
+		speed: "regular"
+	},
+	{
+		id: "k3.1-pro-highspeed",
+		name: "K3.1 Pro Highspeed",
+		version: "K3.1 Pro Highspeed",
+		contextWindow: 1048576,
+		maxContextWindow: null,
+		maxTokens: 32768,
+		maxRequestBodyBytes: LONG_CONTEXT_MESSAGE_BODY_BYTES,
+		inputModalities: [
+			"text",
+			"image",
+			"video"
+		],
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "max",
+		thinkingType: "only",
+		minimumPlan: "Allegretto",
+		contextPlan: null,
+		description: "The high-speed K3.1 Pro with a 1M context window and faster output, at about twice the quota of the regular version. Requires the Pro/Allegretto plan or above.",
+		supportsDynamicTools: true,
+		quotaMultiplier: null,
+		speed: "highspeed"
+	}
+];
+const BY_ID$1 = new Map(KIMI_CODE_MODELS.map((model) => [model.id, model]));
+/** Registry entry for one model id, or undefined when the id is unknown. */
+function kimiCodeModelDef(modelId) {
+	return BY_ID$1.get(modelId.trim());
+}
+//#endregion
 //#region src/host/kimi-code/types.ts
 const PROVIDER_ID$8 = "kimi-code";
 const PROVIDER_NAME$7 = "Kimi Code";
@@ -24222,9 +24302,22 @@ function openAIUrl(suffix, region = "mainland-cn") {
 * spanning both tiers could not express "relax the text ceiling, leave the video
 * one alone", and a value chosen for a 2 MB conversation would collapse the video
 * tier with it. MiniMax's video budget is likewise a bare constant.
+*
+* The text/image tier is now graded by model: this constant is what the 256K
+* models keep and what an unknown model falls back to, while the 1M models
+* declare their own, larger ceiling in the registry. {@link maxRequestBodyBytesFor}
+* is the resolver that applies that grade.
 */
 const DEFAULT_MAX_MESSAGE_BODY_BYTES$1 = MAX_MESSAGE_BODY_BYTES;
-/** Ceiling this process enforces, honouring the deployment override. */
+/**
+* Ceiling this process enforces when the caller has no model to key on.
+*
+* Kept alongside {@link maxRequestBodyBytesFor} rather than folded into it: this
+* is the answer for "what does this deployment allow at all", which the video
+* budget and the settings reporting paths need without naming a model. A request
+* that DOES name one goes through the per-model resolver below, so a 1M-tier
+* session gets its own tier instead of this floor.
+*/
 function maxMessageBodyBytes$1(env = process.env) {
 	const raw = (env.DSH_KIMI_CODE_MAX_BODY_BYTES ?? "").trim();
 	if (raw === "") return DEFAULT_MAX_MESSAGE_BODY_BYTES$1;
@@ -24233,6 +24326,35 @@ function maxMessageBodyBytes$1(env = process.env) {
 	return Math.floor(parsed);
 }
 /**
+* Request-body ceiling for one model, in precedence order.
+*
+* The middleware gateway that rejects a body is shared and the sessions are not:
+* a 1M-tier session produces several megabytes of conversation the 256K tier
+* cannot, so one number for both either starves the long tier or leaves the
+* short one unguarded. Hence three sources, highest priority first:
+*
+* 1. DSH_KIMI_CODE_MAX_BODY_BYTES — a measured figure for THIS deployment, so it
+*    wins over every per-model default. It still has to be a positive integer:
+*    a typo falls through to the model's own default rather than switching the
+*    guard off, which is the one failure this variable must never cause;
+* 2. the model's {@link KimiCodeCatalogModel.maxRequestBodyBytes};
+* 3. {@link DEFAULT_MAX_MESSAGE_BODY_BYTES}, for a model the registry does not
+*    know — an unknown id keeps the most conservative ceiling rather than
+*    inheriting a long-context allowance nothing has vouched for.
+*
+* @param model the registry row for the model being called, or undefined when
+* the id is not one this route ships.
+* @param env environment the override is read from, injectable for tests.
+*/
+function maxRequestBodyBytesFor(model, env = process.env) {
+	const raw = (env.DSH_KIMI_CODE_MAX_BODY_BYTES ?? "").trim();
+	if (raw !== "") {
+		const parsed = Number(raw);
+		if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+	}
+	return model?.maxRequestBodyBytes ?? DEFAULT_MAX_MESSAGE_BODY_BYTES$1;
+}
+/**
 * Bytes one METERED token is assumed to occupy when a deployment asks this route
 * to fold its published window against the byte ceiling.
 *
@@ -24357,17 +24479,79 @@ function maxRequestImageBytes$1(env = process.env) {
 /**
 * Which wire dialect a model id is served over.
 *
-* The managed service speaks both protocols for every model, so the choice is a
-* client preference rather than a per-model constraint. The OpenAI dialect is
-* the default because that is what the official CLI configures for the managed
-* provider.
+* Always the OpenAI-compatible chat completions dialect: this line uses that one
+* protocol for every model, K3.1 Pro included, which is what the official agent
+* configures for the managed provider (`type = "kimi"`). The Anthropic Messages
+* dialect remains reachable only when a live listing declares it for an id
+* (see `wireForCatalogEntry`), so the answer here is a constant rather than a
+* per-model table.
 */
 function wireForModel(_modelId) {
 	return "openai";
 }
-/** Thinking levels one model advertises, from the static registry. */
+/**
+* Thinking levels one model advertises, from the static registry.
+*
+* A registry row that declares `thinkingType: 'only'` cannot be asked to stop
+* reasoning — the service answers HTTP 400 for a disabled-thinking request — so
+* `none` is filtered out of the list it publishes.
+*/
 function reasoningEffortsFor(modelId) {
-	return [...kimiCodeModelDef(modelId)?.reasoningEfforts ?? []];
+	const declared = kimiCodeModelDef(modelId)?.reasoningEfforts ?? [];
+	if (kimiCodeModelDef(modelId)?.thinkingType === "only") return declared.filter((effort) => effort !== "none");
+	return [...declared];
+}
+/**
+* Thinking level one model uses when the conversation does not pick one.
+*
+* A declared default that the resolved effort list no longer contains is
+* dropped rather than carried through: with `only` in force the list can lose
+* `none`, and a default naming a level the model can no longer be asked for
+* would fail on the first turn that relied on it.
+*/
+function defaultReasoningEffortFor(modelId) {
+	const declared = kimiCodeModelDef(modelId)?.defaultReasoningEffort ?? void 0;
+	if (declared === null || declared === void 0) return void 0;
+	return reasoningEffortsFor(modelId).includes(declared) ? declared : void 0;
+}
+/**
+* How a model handles thinking, from the static registry.
+*
+* Exposed so the request builder and the settings card read the same row rather
+* than each re-deriving the rule; `undefined` means the registry says nothing
+* about this id, which is not the same as "thinking can be switched off".
+*/
+function thinkingTypeFor(modelId) {
+	return kimiCodeModelDef(modelId)?.thinkingType;
+}
+/**
+* Raise a disabled-thinking request to a level the model can actually run.
+*
+* Asking a thinking-only model for `none` is refused by the service with
+* HTTP 400 ("K3.1 Pro does not support disabled thinking mode"), and the user's
+* real intent there is "don't spend my quota on thinking", not "fail the turn".
+* So the effort is lifted to the model's own default — `max` for the K3.1 pair —
+* and the lift is REPORTED through `coercedFrom` so a caller can tell the user
+* what happened instead of silently spending more than they asked for.
+*
+* A model that does not declare `only`, and any effort other than `none`, is
+* returned untouched. When a thinking-only row declares no default the effort
+* becomes `undefined`, which sends no level at all and leaves the service on its
+* own default — still never a disabled-thinking request.
+*/
+function coerceThinkingEffort(modelId, effort) {
+	if (effort !== "none") return {
+		effort,
+		coercedFrom: null
+	};
+	if (thinkingTypeFor(modelId) !== "only") return {
+		effort,
+		coercedFrom: null
+	};
+	return {
+		effort: defaultReasoningEffortFor(modelId),
+		coercedFrom: "none"
+	};
 }
 /**
 * Accepted request modalities for one model.
@@ -25757,7 +25941,7 @@ function wireForCatalogEntry(modelId, catalog) {
 function reasoningEffortsForEntry(modelId, catalog) {
 	const entry = catalog.find((model) => model.id === modelId);
 	const declared = entry?.reasoningEfforts ?? reasoningEffortsFor(modelId);
-	switch (entry?.thinkingType) {
+	switch (entry?.thinkingType ?? thinkingTypeFor(modelId)) {
 		case "no": return [];
 		case "only": return declared.filter((effort) => effort !== "none");
 		default: return [...declared];
@@ -25830,6 +26014,7 @@ function buildModelOptions(catalog, enabledModelIds, contextWindowOverrides) {
 		const contextWindow = typeof override === "number" && Number.isFinite(override) && override > 0 ? override : model.contextWindow ?? 262144;
 		const efforts = reasoningEffortsForEntry(model.id, catalog);
 		const defaultEffort = defaultReasoningEffortForEntry(model.id, catalog);
+		const thinkingType = model.thinkingType ?? thinkingTypeFor(model.id);
 		const declaredInputCap = maxInputTokensForEntry(model.id, catalog);
 		const promptBudget = declaredInputCap === void 0 ? contextWindow : Math.min(contextWindow, declaredInputCap);
 		return {
@@ -25843,6 +26028,7 @@ function buildModelOptions(catalog, enabledModelIds, contextWindowOverrides) {
 			defaultMaxTokens: maxOutputTokensFor$4(model.id, contextWindow),
 			...efforts.length === 0 ? {} : { reasoningEfforts: [...efforts] },
 			...defaultEffort === void 0 ? {} : { defaultReasoningEffort: defaultEffort },
+			...thinkingType === void 0 ? {} : { thinkingType },
 			wire: model.protocol ?? wireForModel(model.id),
 			description: model.description ?? kimiCodeModelDef(model.id)?.description ?? null,
 			supportsVideo: model.supportsVideo ?? kimiCodeModelDef(model.id)?.inputModalities.includes("video") ?? false,
@@ -27673,12 +27859,40 @@ function buildRequest(options, wire, images = NO_RESOLVED_IMAGES$3, preserveThin
 	recordDriftCause(trackPrefixStability(options), options.sessionId);
 	return wire === "anthropic" ? buildAnthropicRequest(options, images, media) : buildOpenAIRequest(options, images, preserveThinking, media);
 }
-function assertRequestBodyFits$1(body, carriesVideo = false, context) {
+/**
+* Reject a request the service would refuse for its size.
+*
+* This is the most frequently reported 400 on the coding endpoint, and it is
+* worth catching locally for two reasons: the message can name the actual
+* remedy (DSH's compaction), and a request that cannot succeed should not be
+* sent at all. The measured size is the real serialized body, so it accounts
+* for tool schemas and inlined images the caller cannot easily estimate.
+*
+* The ceiling is the caller's when it passes one, because the text/image tier is
+* graded by model and only the caller knows which model the turn is for; omitted,
+* the guard resolves the model-less default (or the video tier) itself.
+*
+* The error code is CONTEXT_OVERFLOW_CODE, not PROVIDER_ERROR, because naming the
+* remedy in prose is not the same as being able to act on it: DSH forces a
+* compaction and retries the same step only for that one code, and every other
+* 400-shaped failure ends the turn. A byte ceiling is answered by the same
+* compression a token ceiling is — the conversation shrinks either way — so the
+* body of the message stays as specific as it was while the code becomes one the
+* host can recover from.
+*
+* @param body the request body about to be serialized and sent.
+* @param carriesVideo whether the request attaches video, which has its own tier.
+* @param context what the body-fit loop already did, when it ran.
+* @param limit the ceiling already resolved for this request's model.
+* @returns the serialized body, so a caller that is about to send it does not
+* serialize a body of up to tens of megabytes a second time.
+*/
+function assertRequestBodyFits$1(body, carriesVideo = false, context, limit) {
 	const serialized = JSON.stringify(body);
 	const bytes = Buffer.byteLength(serialized, "utf8");
-	const limit = carriesVideo ? MAX_VIDEO_MESSAGE_BODY_BYTES : maxMessageBodyBytes$1();
-	if (bytes <= limit) return serialized;
-	throw new LlmError$1(oversizedBodyMessage(bytes, limit, body, context), CONTEXT_OVERFLOW_CODE);
+	const ceiling = limit ?? (carriesVideo ? 67108864 : maxMessageBodyBytes$1());
+	if (bytes <= ceiling) return serialized;
+	throw new LlmError$1(oversizedBodyMessage(bytes, ceiling, body, context), CONTEXT_OVERFLOW_CODE);
 }
 function walkJson(value, visit) {
 	if (Array.isArray(value)) {
@@ -27757,6 +27971,8 @@ function createStreamState$4(wire, sessionId) {
 		outputTokens: 0,
 		cacheReadTokens: 0,
 		cacheWriteTokens: 0,
+		cacheWrite5mTokens: 0,
+		cacheWrite1hTokens: 0,
 		reasoningTokens: 0,
 		sawUsage: false,
 		toolCallIds: new ToolCallIdNormalizer()
@@ -27847,8 +28063,10 @@ function processOpenAIStreamLine(line, state) {
 		const prompt = numberOr$7(usage.prompt_tokens, 0);
 		const details = isRecord$34(usage.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
 		const cached = details ? numberOr$7(details.cached_tokens, 0) : 0;
-		state.inputTokens = Math.max(0, prompt - cached);
+		const written = details ? numberOr$7(details.cache_write_tokens, 0) : 0;
+		state.inputTokens = Math.max(0, prompt - cached - written);
 		state.cacheReadTokens = cached;
+		state.cacheWriteTokens = written;
 		state.outputTokens = numberOr$7(usage.completion_tokens, state.outputTokens);
 		if (isRecord$34(usage.completion_tokens_details)) state.reasoningTokens = numberOr$7(usage.completion_tokens_details.reasoning_tokens, state.reasoningTokens);
 	}
@@ -28228,6 +28446,63 @@ function recordDriftCause(cause, sessionId) {
 function getLastDriftCause(sessionId) {
 	return driftCauses.get(cacheScopeKey(sessionId));
 }
+/** Last lift per session. */
+const thinkingCoercions = /* @__PURE__ */ new Map();
+/**
+* Record one lift, and make it visible.
+*
+* `process.emitWarning` rather than a thrown error or a silently swallowed
+* value: the request must still go out (that is the whole point of the lift),
+* but a diagnostic that reaches stderr with a stable code is what keeps it from
+* being invisible. It is emitted once per turn, and only for a model that
+* actually declares thinking-only, so a deployment that never asks for 'none'
+* never sees one.
+*/
+function recordThinkingCoercion(coercion, sessionId) {
+	rememberScoped(thinkingCoercions, cacheScopeKey(sessionId), coercion);
+	const target = coercion.to === void 0 ? "the service default" : "\"" + coercion.to + "\"";
+	process.emitWarning("[kimi-code] model \"" + coercion.model + "\" cannot disable thinking; sending " + target + " instead of \"none\" on the " + coercion.wire + " wire.", { code: "KIMI_CODE_THINKING_COERCED" });
+}
+/**
+* Response headers that split a cache write across its two TTL tiers.
+*
+* The service states the write TOTAL in 'usage' and the per-tier split only in
+* these headers, so the split has to be read off the HTTP response — there is no
+* body field for it. Both are decimal integers; a missing or non-numeric value
+* means the header said nothing, which is recorded as 0 rather than guessed at
+* (see KimiCodeCacheStatsDto.cacheWrite5mTokens: an absent header is silence,
+* not a claim that nothing was written to that tier).
+*/
+const CACHE_WRITE_5M_HEADER = "Msh-Usage-Cache-Write-Tokens-5m";
+const CACHE_WRITE_1H_HEADER = "Msh-Usage-Cache-Write-Tokens-1h";
+/** Decimal whole-token count from one response header, or 0 when it is silent. */
+function headerCount(headers, name) {
+	const raw = headers.get(name);
+	if (raw === null) return 0;
+	const text = raw.trim();
+	if (!/^\d+$/.test(text)) return 0;
+	const value = Number(text);
+	return Number.isSafeInteger(value) ? value : 0;
+}
+/** The two tier counts one response's headers state. */
+function cacheWriteTiers(headers) {
+	return {
+		write5m: headerCount(headers, CACHE_WRITE_5M_HEADER),
+		write1h: headerCount(headers, CACHE_WRITE_1H_HEADER)
+	};
+}
+/**
+* File one response's tier counts on the stream state that will close it.
+*
+* Called by the adapter on the Response itself, which is the only place the
+* headers exist; the totals are then filed with the rest of the usage when the
+* stream closes, so one turn's numbers stay one turn's numbers.
+*/
+function applyCacheWriteTiers(state, headers) {
+	const tiers = cacheWriteTiers(headers);
+	state.cacheWrite5mTokens = tiers.write5m;
+	state.cacheWrite1hTokens = tiers.write1h;
+}
 /**
 * Rolling cache totals per session.
 *
@@ -28241,7 +28516,9 @@ const EMPTY_CACHE_STATS = {
 	cachedTokens: 0,
 	freshTokens: 0,
 	outputTokens: 0,
-	cacheWriteTokens: 0
+	cacheWriteTokens: 0,
+	cacheWrite5mTokens: 0,
+	cacheWrite1hTokens: 0
 };
 /** Record one request's usage into its own session's totals. */
 function recordCacheStats(state, sessionId, accountId) {
@@ -28253,7 +28530,9 @@ function recordCacheStats(state, sessionId, accountId) {
 		cachedTokens: previous.cachedTokens + state.cacheReadTokens,
 		freshTokens: previous.freshTokens + state.inputTokens,
 		outputTokens: previous.outputTokens + state.outputTokens,
-		cacheWriteTokens: previous.cacheWriteTokens + state.cacheWriteTokens
+		cacheWriteTokens: previous.cacheWriteTokens + state.cacheWriteTokens,
+		cacheWrite5mTokens: previous.cacheWrite5mTokens + state.cacheWrite5mTokens,
+		cacheWrite1hTokens: previous.cacheWrite1hTokens + state.cacheWrite1hTokens
 	});
 }
 /** Add one entry into an accumulator. */
@@ -28263,6 +28542,8 @@ function accumulate(totals, stats) {
 	totals.freshTokens += stats.freshTokens;
 	totals.outputTokens += stats.outputTokens;
 	totals.cacheWriteTokens += stats.cacheWriteTokens;
+	totals.cacheWrite5mTokens += stats.cacheWrite5mTokens;
+	totals.cacheWrite1hTokens += stats.cacheWrite1hTokens;
 }
 /**
 * Totals for one account's share of a session, one whole session, or every
@@ -28821,7 +29102,19 @@ var KimiCodeAdapter = class extends LlmAdapter {
 		const entry = catalog.find((model) => model.id === options.model);
 		const normalized = normalizeGenerateOptions(options);
 		const images = await resolveRequestImages$1(normalized, this.options.attachments, signal);
-		const requestOptions = offloadOldestRequestVideos(offloadOldestRequestImages$1(normalized, maxRequestImageBytes$1(), images), MAX_REQUEST_VIDEO_BYTES$1);
+		const imageTrimmed = offloadOldestRequestImages$1(normalized, maxRequestImageBytes$1(), images);
+		const gatedEffort = coerceThinkingEffort(options.model, mapReasoningEffort(options.reasoningEffort === void 0 || options.reasoningEffort === null ? void 0 : String(options.reasoningEffort)));
+		if (gatedEffort.coercedFrom !== null) recordThinkingCoercion({
+			model: options.model,
+			wire,
+			from: gatedEffort.coercedFrom,
+			to: gatedEffort.effort
+		}, options.sessionId);
+		const videoTrimmed = offloadOldestRequestVideos(imageTrimmed, MAX_REQUEST_VIDEO_BYTES$1);
+		const requestOptions = gatedEffort.effort === void 0 ? videoTrimmed : {
+			...videoTrimmed,
+			reasoningEffort: ReasoningEffortId(gatedEffort.effort)
+		};
 		const videos = await resolveRequestVideos(requestOptions, this.options.videos, signal);
 		const settings = await this.settings();
 		const media = {
@@ -28839,7 +29132,7 @@ var KimiCodeAdapter = class extends LlmAdapter {
 			maxTokens: clampOutputToContext$1(requestedMax, promptLimit, estimatedInputTokens(requestOptions))
 		};
 		const carriesVideo = requestHasVideo(requestOptions);
-		const bodyLimit = carriesVideo ? MAX_VIDEO_MESSAGE_BODY_BYTES : maxMessageBodyBytes$1();
+		const bodyLimit = carriesVideo ? MAX_VIDEO_MESSAGE_BODY_BYTES : maxRequestBodyBytesFor(kimiCodeModelDef(entry?.id ?? options.model), process.env);
 		let buildOptions = boundedOptions;
 		let body = "";
 		for (let attempt = 0;; attempt++) {
@@ -28853,12 +29146,12 @@ var KimiCodeAdapter = class extends LlmAdapter {
 				excessBytes: bytes - bodyLimit
 			});
 			if (attempt > MAX_BODY_FIT_ATTEMPTS || !requestHasSendableImage(buildOptions, images)) {
-				assertRequestBodyFits$1(built, carriesVideo, context());
+				assertRequestBodyFits$1(built, carriesVideo, context(), bodyLimit);
 				throw new Error("unreachable: assertRequestBodyFits returns or throws");
 			}
 			const drop = dropOldestImagesUntilFits(buildOptions, images, bytes - bodyLimit, requestOptions);
 			if (drop.dropped === 0) {
-				assertRequestBodyFits$1(built, carriesVideo, context());
+				assertRequestBodyFits$1(built, carriesVideo, context(), bodyLimit);
 				throw new Error("unreachable: assertRequestBodyFits returns or throws");
 			}
 			buildOptions = drop.options;
@@ -28934,6 +29227,7 @@ var KimiCodeAdapter = class extends LlmAdapter {
 		const reader = response.body.getReader();
 		const decoder = new TextDecoder();
 		const state = createStreamState$4(wire, requestOptions.sessionId);
+		applyCacheWriteTiers(state, response.headers);
 		markSessionActive(requestOptions.sessionId);
 		let buffer = "";
 		/**
@@ -29399,7 +29693,9 @@ function cacheStatsOrNull(sessionId) {
 	return {
 		...stats,
 		...lastDrift === void 0 ? {} : { lastDrift },
-		cacheWriteTokensNote: "always-zero-on-this-route"
+		cacheWriteTokens: stats.cacheWriteTokens,
+		cacheWrite5mTokens: stats.cacheWrite5mTokens,
+		cacheWrite1hTokens: stats.cacheWrite1hTokens
 	};
 }
 /**
@@ -29992,7 +30288,7 @@ async function assertVideoCapableRoute(ctx, exec, source) {
 	const llm = ctx.get("llm");
 	if (llm === void 0) throw new HarnessError(`cannot attach "${source}": the LLM service is unavailable`, "KIMI_VIDEO_NO_LLM");
 	const active = await llm.resolveModelInfo(provider, model, exec.signal);
-	if (active.inputModalities === void 0 || !active.inputModalities.includes("video")) throw new HarnessError(`cannot attach "${source}": model "${model}" does not accept video input; switch to k3 or kimi-for-coding`, "KIMI_VIDEO_MODEL_UNSUPPORTED");
+	if (active.inputModalities === void 0 || !active.inputModalities.includes("video")) throw new HarnessError(`cannot attach "${source}": model "${model}" does not accept video input; switch to k3, k3.1-pro, kimi-for-coding or kimi-for-coding-highspeed`, "KIMI_VIDEO_MODEL_UNSUPPORTED");
 }
 function humanBytes$1(bytes) {
 	return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
@@ -30055,7 +30351,7 @@ function createKimiVideoTool(ctx, options = {}) {
 	const fetchFn = options.fetchFn ?? fetch;
 	return defineTool({
 		name: KIMI_VIDEO_TOOL_NAME,
-		description: "Attach a video to the conversation for models that accept video input (Kimi k3 and kimi-for-coding). Use this when the user asks about a video file or a video URL: pass an absolute local path or an http(s) URL. The video is sent to the model on the next request; it does not work on image-only models such as k3-256k.",
+		description: "Attach a video to the conversation for models that accept video input (Kimi k3, k3.1-pro, kimi-for-coding and kimi-for-coding-highspeed). Use this when the user asks about a video file or a video URL: pass an absolute local path or an http(s) URL. The video is sent to the model on the next request; it does not work on image-only models such as k3-256k.",
 		parameters: {
 			source: {
 				type: "string",