fix(agent-core): scope [image] config limits to the owning core

RealKai42 · RealKai42 · commit e56d57184cce · 2026-07-09T19:26:44.000+08:00
diff --git a/.changeset/scoped-image-limits.md b/.changeset/scoped-image-limits.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Scope `[image]` config limits to the owning core instead of a process-global value, so multiple cores in one process (the SDK's multi-client pattern) each compress images with their own `max_edge_px` / `read_byte_budget`, and a config reload of one core never retunes another; the env vars `KIMI_IMAGE_MAX_EDGE_PX` / `KIMI_IMAGE_READ_BYTE_BUDGET` still override process-wide.
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
@@ -14,6 +14,7 @@ import type { PluginCommandOrigin } from './context';
 
 import type { McpConnectionManager } from '../mcp';
 import { FlagResolver, type ExperimentalFlagResolver } from '../flags';
+import { ImageLimits } from '../tools/support/image-limits';
 import {
   prepareSystemPromptContext,
   type PreparedSystemPromptContext,
@@ -96,6 +97,8 @@ export interface AgentOptions {
   readonly pluginSessionStarts?: readonly EnabledPluginSessionStart[];
   readonly pluginCommands?: readonly PluginCommandDef[];
   readonly experimentalFlags?: ExperimentalFlagResolver;
+  /** Owner-scoped [image] limits; a standalone Agent gets env/built-in defaults. */
+  readonly imageLimits?: ImageLimits;
   readonly replay?: ReplayBuilderOptions;
   readonly additionalDirs?: readonly string[];
   readonly systemPromptContextProvider?: (() => Promise<PreparedSystemPromptContext>) | undefined;
@@ -124,6 +127,7 @@ export class Agent {
   readonly log: Logger;
   readonly telemetry: TelemetryClient;
   readonly experimentalFlags: ExperimentalFlagResolver;
+  readonly imageLimits: ImageLimits;
 
   readonly llmRequestLogger: LlmRequestLogger;
   readonly llmRequestRecorder: LlmRequestRecorder;
@@ -178,6 +182,7 @@ export class Agent {
     this.log = options.log ?? log;
     this.telemetry = options.telemetry ?? noopTelemetryClient;
     this.experimentalFlags = options.experimentalFlags ?? new FlagResolver();
+    this.imageLimits = options.imageLimits ?? new ImageLimits();
     this.additionalDirs = normalizeAdditionalDirs(options.additionalDirs ?? []);
     this.systemPromptContextProvider = options.systemPromptContextProvider;
 
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
@@ -317,6 +317,8 @@ export class ToolManager {
               return mcpResultToExecutableOutput(result, qualified, {
                 originalsDir: this.agent.mediaOriginalsDir,
                 telemetry: this.agent.telemetry,
+                // Resolved per call so a config reload applies immediately.
+                maxImageEdgePx: this.agent.imageLimits?.maxEdgePx(),
               });
             },
           };
@@ -706,6 +708,7 @@ export class ToolManager {
             modelCapabilities,
             videoUploader,
             this.agent.telemetry,
+            this.agent.imageLimits,
           ),
         new b.EnterPlanModeTool(this.agent),
         new b.ExitPlanModeTool(this.agent),
diff --git a/packages/agent-core/src/index.ts b/packages/agent-core/src/index.ts
@@ -64,9 +64,13 @@ export {
   compressImageContentParts,
   cropImageForModel,
   formatByteSize,
+  resolveMaxImageEdgePx,
+  resolveReadImageByteBudget,
   IMAGE_BYTE_BUDGET,
   MAX_IMAGE_EDGE_PX,
+  READ_IMAGE_BYTE_BUDGET,
 } from './tools/support/image-compress';
+export { ImageLimits } from './tools/support/image-limits';
 export type {
   CompressAnnotateOptions,
   CompressedContentParts,
diff --git a/packages/agent-core/src/mcp/output.ts b/packages/agent-core/src/mcp/output.ts
@@ -44,6 +44,8 @@ export interface McpOutputOptions {
   readonly originalsDir?: string | undefined;
   /** Report an `image_compress` event per compressed tool-result image. */
   readonly telemetry?: TelemetryClient | undefined;
+  /** Owner-resolved longest-edge ceiling (px) for tool-result images. */
+  readonly maxImageEdgePx?: number | undefined;
 }
 
 // MCP servers can produce arbitrarily large outputs; cap what we feed back to
@@ -188,6 +190,7 @@ export async function mcpResultToExecutableOutput(
   // DATA (never inserted into the parts), so tool output that merely quotes
   // a caption can never be mistaken for a generated one.
   const compressed = await compressImageContentParts(budgeted.parts, {
+    maxEdge: options.maxImageEdgePx,
     telemetry:
       options.telemetry === undefined
         ? undefined
diff --git a/packages/agent-core/src/rpc/core-impl.ts b/packages/agent-core/src/rpc/core-impl.ts
@@ -7,7 +7,7 @@ import { PluginManager } from '#/plugin';
 import { LocalFetchURLProvider } from '#/tools/providers/local-fetch-url';
 import { MoonshotFetchURLProvider } from '#/tools/providers/moonshot-fetch-url';
 import { MoonshotWebSearchProvider } from '#/tools/providers/moonshot-web-search';
-import { setConfiguredMaxImageEdgePx, setConfiguredReadImageByteBudget } from '#/tools/support/image-compress';
+import { ImageLimits } from '#/tools/support/image-limits';
 import type { PromisableMethods } from '#/utils/types';
 import { getCoreVersion } from '#/version';
 import { resolveThinkingEffort } from '../agent/config/thinking';
@@ -169,6 +169,8 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   private pluginsLoadError: Error | undefined;
   private readonly appVersion: string | undefined;
   private readonly experimentalFlags: FlagResolver;
+  /** Owner-scoped [image] limits; reload pushes the new config via setConfig. */
+  readonly imageLimits: ImageLimits;
 
   constructor(
     protected readonly rpcClient: CoreRPCClient,
@@ -206,8 +208,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       FLAG_DEFINITIONS,
       this.config.experimental,
     );
-    setConfiguredMaxImageEdgePx(this.config.image?.maxEdgePx);
-    setConfiguredReadImageByteBudget(this.config.image?.readByteBudget);
+    this.imageLimits = new ImageLimits(process.env, this.config.image);
     this.sessionStore = new SessionStore(this.homeDir);
     this.plugins = new PluginManager({ kimiHomeDir: this.homeDir });
     // Capture the error rather than swallow it: mutators and explicit /plugins
@@ -301,6 +302,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       skills: this.resolveSessionSkillConfig(config),
       mcpConfig,
       experimentalFlags: this.experimentalFlags,
+      imageLimits: this.imageLimits,
       telemetry: sessionTelemetry,
       pluginSessionStarts,
       pluginCommands,
@@ -436,6 +438,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       skills: this.resolveSessionSkillConfig(config),
       mcpConfig,
       experimentalFlags: this.experimentalFlags,
+      imageLimits: this.imageLimits,
       telemetry: withTelemetryContext(this.telemetry, { sessionId: summary.id }),
       initializeMainAgent: false,
       pluginSessionStarts,
@@ -1082,8 +1085,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   private setRuntimeConfig(config: KimiConfig): KimiConfig {
     this.config = config;
     this.experimentalFlags.setConfigOverrides(config.experimental);
-    setConfiguredMaxImageEdgePx(config.image?.maxEdgePx);
-    setConfiguredReadImageByteBudget(config.image?.readByteBudget);
+    this.imageLimits.setConfig(config.image);
     return this.config;
   }
 
diff --git a/packages/agent-core/src/services/coreProcess/coreProcess.ts b/packages/agent-core/src/services/coreProcess/coreProcess.ts
@@ -33,6 +33,7 @@ import { createDecorator } from '../../di';
 import type { CoreRPC, KimiCoreOptions } from '../../rpc';
 import type { TelemetryClient } from '../../telemetry';
 import { type KimiHostIdentity } from '@moonshot-ai/kimi-code-oauth';
+import type { ImageLimits } from '#/tools/support/image-limits';
 
 export interface CoreProcessServiceOptions extends KimiCoreOptions {
   /**
@@ -68,6 +69,12 @@ export interface ICoreProcessService {
    */
   readonly telemetry?: TelemetryClient | undefined;
 
+  /**
+   * The core's owner-scoped [image] limits, so daemon-side prompt-ingestion
+   * compression uses the same settings (and reloads) as the core's own tools.
+   */
+  readonly imageLimits?: ImageLimits | undefined;
+
   /**
    * Resolves once `KimiCore` is fully constructed and the SDK side of the
    * in-process RPC has been bound. Repeated calls return the cached promise.
diff --git a/packages/agent-core/src/services/coreProcess/coreProcessService.ts b/packages/agent-core/src/services/coreProcess/coreProcessService.ts
@@ -3,6 +3,7 @@
  */
 
 import { createRPC, KimiCore } from '../../rpc';
+import type { ImageLimits } from '../../tools/support/image-limits';
 import { Disposable, registerSingleton, SyncDescriptor } from '../../di';
 import type { CoreAPI, CoreRPC, SDKAPI } from '../../rpc';
 import type { OAuthTokenProviderResolver } from '../../session/provider-manager';
@@ -36,6 +37,11 @@ export class CoreProcessService extends Disposable implements ICoreProcessServic
 
   public readonly telemetry: TelemetryClient;
 
+  /** The core's owner-scoped [image] limits; see ICoreProcessService. */
+  public get imageLimits(): ImageLimits {
+    return this._core.imageLimits;
+  }
+
   /**
    * The in-process `KimiCore` instance. Kept private so daemon-side code can't
    * grab it and bypass the peer-service indirection.
diff --git a/packages/agent-core/src/session/index.ts b/packages/agent-core/src/session/index.ts
@@ -52,6 +52,7 @@ import { SessionSubagentHost } from './subagent-host';
 import { sessionMediaOriginalsDir } from '../tools/support/image-originals';
 import type { ToolServices } from '../tools/support/services';
 import { FlagResolver, type ExperimentalFlagResolver } from '../flags';
+import { ImageLimits } from '../tools/support/image-limits';
 import { abortError } from '../utils/abort';
 
 export interface SessionOptions {
@@ -75,6 +76,8 @@ export interface SessionOptions {
   readonly pluginCommands?: readonly PluginCommandDef[];
   readonly appVersion?: string;
   readonly experimentalFlags?: ExperimentalFlagResolver;
+  /** Owner-scoped [image] limits, threaded from the owning core into every agent. */
+  readonly imageLimits?: ImageLimits;
   readonly additionalDirs?: readonly string[];
   /**
    * Print-mode (`kimi -p`) only: hold the main turn open while background
@@ -169,6 +172,7 @@ export class Session {
   private readonly logHandle: SessionLogHandle | undefined;
   readonly hookEngine: HookEngine;
   readonly experimentalFlags: ExperimentalFlagResolver;
+  readonly imageLimits: ImageLimits;
   private toolKaos: Kaos;
   private persistenceKaos: Kaos;
   private additionalDirs: readonly string[];
@@ -202,6 +206,7 @@ export class Session {
       (options.id === undefined ? log : log.createChild({ sessionId: options.id }));
     this.rpc = options.rpc;
     this.experimentalFlags = options.experimentalFlags ?? new FlagResolver();
+    this.imageLimits = options.imageLimits ?? new ImageLimits();
     this.hookEngine = new HookEngine(options.hooks, {
       cwd: options.kaos.getcwd(),
       sessionId: options.id,
@@ -837,6 +842,7 @@ export class Session {
       pluginSessionStarts: type === 'main' ? this.options.pluginSessionStarts : undefined,
       pluginCommands: type === 'main' ? this.options.pluginCommands : undefined,
       experimentalFlags: this.experimentalFlags,
+      imageLimits: this.imageLimits,
       additionalDirs: parentAgent?.getAdditionalDirs() ?? this.additionalDirs,
       systemPromptContextProvider: () =>
         prepareSystemPromptContext(
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -45,10 +45,10 @@ import {
   compressImageForModel,
   cropImageForModel,
   formatByteSize,
-  resolveReadImageByteBudget,
   type ImageCompressionTelemetry,
   type ImageCropRegion,
 } from '../../support/image-compress';
+import { ImageLimits } from '../../support/image-limits';
 import { toInputJsonSchema } from '../../support/input-schema';
 import { literalRulePattern, matchesPathRuleSubject } from '../../support/rule-match';
 import type { WorkspaceConfig } from '../../support/workspace';
@@ -258,12 +258,14 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
   readonly description: string;
   readonly parameters: Record<string, unknown> = toInputJsonSchema(ReadMediaFileInputSchema);
   private readonly compressTelemetry: ImageCompressionTelemetry | undefined;
+  private readonly imageLimits: ImageLimits;
   constructor(
     private readonly kaos: Kaos,
     private readonly workspace: WorkspaceConfig,
     private readonly capabilities: ModelCapability,
     private readonly videoUploader?: VideoUploader | undefined,
     telemetry?: TelemetryClient,
+    imageLimits?: ImageLimits,
   ) {
     if (!capabilities.image_in && !capabilities.video_in) {
       const skip = new Error('ReadMediaFile requires image_in or video_in capability');
@@ -273,6 +275,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
     this.description = buildDescription(capabilities);
     this.compressTelemetry =
       telemetry === undefined ? undefined : { client: telemetry, source: 'read_media' };
+    this.imageLimits = imageLimits ?? new ImageLimits();
   }
 
   resolveExecution(args: ReadMediaFileInput): ToolExecution {
@@ -387,6 +390,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           // full fidelity, so a prior downsampled view can be zoomed into.
           const outcome = await cropImageForModel(data, fileType.mimeType, args.region, {
             skipResize: args.full_resolution === true,
+            maxEdge: this.imageLimits.maxEdgePx(),
             telemetry: this.compressTelemetry,
           });
           if (!outcome.ok) {
@@ -446,7 +450,8 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           // failure compressImageForModel returns the original bytes, so the
           // read still succeeds with the uncompressed image.
           const compressed = await compressImageForModel(data, fileType.mimeType, {
-            byteBudget: resolveReadImageByteBudget(),
+            maxEdge: this.imageLimits.maxEdgePx(),
+            byteBudget: this.imageLimits.readByteBudget(),
             telemetry: this.compressTelemetry,
           });
           const base64 = Buffer.from(compressed.data).toString('base64');
diff --git a/packages/agent-core/src/tools/support/image-compress.ts b/packages/agent-core/src/tools/support/image-compress.ts
@@ -49,36 +49,34 @@ export const MAX_IMAGE_EDGE_PX = 2000;
  */
 export const MAX_IMAGE_EDGE_ENV = 'KIMI_IMAGE_MAX_EDGE_PX';
 
-/**
- * The `[image] max_edge_px` value from config.toml, pushed by the config
- * owner (KimiCore) on load and reload. Processes that never load config
- * (TUI paste, ACP adapter) leave this unset and get env/built-in behavior.
- */
-let configuredMaxImageEdgePx: number | undefined;
-
-/** Push (or clear, with `undefined`) the config.toml longest-edge ceiling. */
-export function setConfiguredMaxImageEdgePx(value: number | undefined): void {
-  configuredMaxImageEdgePx = value !== undefined && isPositiveInt(value) ? value : undefined;
+/** The env override for the longest-edge ceiling, or undefined when unset/invalid. */
+export function maxImageEdgeFromEnv(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): number | undefined {
+  return positiveIntFromEnv(env, MAX_IMAGE_EDGE_ENV);
 }
 
 /**
- * Effective default longest-edge ceiling (px), for calls that pass no
- * explicit `maxEdge`. Precedence mirrors the experimental-flag resolver:
- * env var > config.toml > built-in {@link MAX_IMAGE_EDGE_PX}.
+ * Default longest-edge ceiling (px) for calls that pass no explicit
+ * `maxEdge` and have no config owner: env var > built-in
+ * {@link MAX_IMAGE_EDGE_PX}. Owned call sites (tools under an Agent, server
+ * ingestion under a core) resolve through their `ImageLimits` instance
+ * instead, which adds the owner's `[image]` config between the two.
  */
 export function resolveMaxImageEdgePx(
   env: Readonly<Record<string, string | undefined>> = process.env,
 ): number {
-  const raw = env[MAX_IMAGE_EDGE_ENV]?.trim();
-  if (raw !== undefined && raw.length > 0 && /^\d+$/.test(raw)) {
-    const parsed = Number(raw);
-    if (isPositiveInt(parsed)) return parsed;
-  }
-  return configuredMaxImageEdgePx ?? MAX_IMAGE_EDGE_PX;
+  return maxImageEdgeFromEnv(env) ?? MAX_IMAGE_EDGE_PX;
 }
 
-function isPositiveInt(value: number): boolean {
-  return Number.isInteger(value) && value > 0;
+function positiveIntFromEnv(
+  env: Readonly<Record<string, string | undefined>>,
+  name: string,
+): number | undefined {
+  const raw = env[name]?.trim();
+  if (raw === undefined || raw.length === 0 || !/^\d+$/.test(raw)) return undefined;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 
 /**
@@ -107,28 +105,21 @@ export const READ_IMAGE_BYTE_BUDGET = 256 * 1024;
  */
 export const READ_IMAGE_BYTE_BUDGET_ENV = 'KIMI_IMAGE_READ_BYTE_BUDGET';
 
-/** The `[image] read_byte_budget` value from config.toml; see {@link setConfiguredMaxImageEdgePx}. */
-let configuredReadImageByteBudget: number | undefined;
-
-/** Push (or clear, with `undefined`) the config.toml read-image byte budget. */
-export function setConfiguredReadImageByteBudget(value: number | undefined): void {
-  configuredReadImageByteBudget = value !== undefined && isPositiveInt(value) ? value : undefined;
+/** The env override for the read-image byte budget, or undefined when unset/invalid. */
+export function readImageByteBudgetFromEnv(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): number | undefined {
+  return positiveIntFromEnv(env, READ_IMAGE_BYTE_BUDGET_ENV);
 }
 
 /**
- * Effective read-image byte budget. Precedence mirrors
- * {@link resolveMaxImageEdgePx}: env var > config.toml > built-in
- * {@link READ_IMAGE_BYTE_BUDGET}.
+ * Read-image byte budget for callers with no config owner; see
+ * {@link resolveMaxImageEdgePx} for the ownership model.
  */
 export function resolveReadImageByteBudget(
   env: Readonly<Record<string, string | undefined>> = process.env,
 ): number {
-  const raw = env[READ_IMAGE_BYTE_BUDGET_ENV]?.trim();
-  if (raw !== undefined && raw.length > 0 && /^\d+$/.test(raw)) {
-    const parsed = Number(raw);
-    if (isPositiveInt(parsed)) return parsed;
-  }
-  return configuredReadImageByteBudget ?? READ_IMAGE_BYTE_BUDGET;
+  return readImageByteBudgetFromEnv(env) ?? READ_IMAGE_BYTE_BUDGET;
 }
 
 /** Progressively lower JPEG quality until the payload fits the byte budget. */
@@ -182,7 +173,11 @@ const MAX_DECODE_BYTES = 64 * 1024 * 1024;
 const RECODABLE_MIME = new Set(['image/png', 'image/jpeg', 'image/webp']);
 
 export interface CompressImageOptions {
-  /** Override the longest-edge ceiling (px); defaults to {@link resolveMaxImageEdgePx}. */
+  /**
+   * Override the longest-edge ceiling (px). When omitted, owned call sites
+   * pass their {@link ImageLimits.maxEdgePx}; ownerless ones fall back to
+   * {@link resolveMaxImageEdgePx} (env var, then built-in).
+   */
   readonly maxEdge?: number;
   /** Override the raw-byte budget. */
   readonly byteBudget?: number;
diff --git a/packages/agent-core/src/tools/support/image-limits.ts b/packages/agent-core/src/tools/support/image-limits.ts
diff --git a/packages/agent-core/test/rpc/config-rpc.test.ts b/packages/agent-core/test/rpc/config-rpc.test.ts
diff --git a/packages/agent-core/test/tools/image-compress.test.ts b/packages/agent-core/test/tools/image-compress.test.ts
diff --git a/packages/agent-core/test/tools/read-media.test.ts b/packages/agent-core/test/tools/read-media.test.ts
diff --git a/packages/server/src/routes/prompts.ts b/packages/server/src/routes/prompts.ts

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@moonshot-ai/kimi-code": patch
 +---
++
 +Scope `[image]` config limits to the owning core instead of a process-global value, so multiple cores in one process (the SDK's multi-client pattern) each compress images with their own `max_edge_px` / `read_byte_budget`, and a config reload of one core never retunes another; the env vars `KIMI_IMAGE_MAX_EDGE_PX` / `KIMI_IMAGE_READ_BYTE_BUDGET` still override process-wide.