@selesai/code 0.8.10 → 0.8.11

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.8.11] - 2026-08-19
+
+### Added
+- **Image captioning relay for text-only models.** When the active model cannot accept images
+  (e.g. DeepSeek `deepseek-v4-*` / `auto`) and a vision model is configured
+  (`images.imageCaptionModel`), images pasted into chat or read via the `read` tool are described
+  by the vision model (e.g. Gemma/Kimi) and the caption text is used by the main model in place of
+  the raw image. Configure the vision model and its context budget from `/settings` ("Vision caption
+  model" / "Vision context tokens").
+- **Gemma 4 31B (Vision) as a bundled default** on the Token-In provider (`tokenin/gemma-4`,
+  `input: ["text", "image"]`) — usable both as a captioner and as a main model.
+- **Context-aware captioning.** The caption request now includes the user's current prompt and a
+  bounded slice of the most recent user/assistant conversation (whole messages, tool output
+  excluded), capped by `images.imageCaptionContextTokens` (default 16384). Full history is never
+  sent, so the caption model's smaller context window is never overloaded.
+- **Captioning status indicator.** While an image is being described, the TUI shows a "Reading image
+  with vision model..." spinner (with a per-image 15s timeout and a brief notice on total failure),
+  so captioning no longer looks like a frozen screen.
+- **Skill enablement overrides** are now honored for built-in and additional skill resources
+  (package-manager/resource-loader), and `getResolvedSkills()` is exposed on the resource loader.
+
+### Changed
+- **Model-prompt-injector** rule for the Token-In provider now matches `deepseek-v4-*` (was
+  `deepseek-v4-pro`).
+
+### Added (context)
+- `images.imageCaptionContextTokens` sets the max recent-conversation token budget sent to the
+  caption model (`0` disables context).
+
 ## [0.8.10] - 2026-08-18
 
 ### Changed

package/dist/core/agent-session.d.ts

@@ -106,6 +106,11 @@ export type AgentSessionEvent = Exclude<AgentEvent, {
     type: "bash_execution_update";
     id?: string;
     delta: string;
+} | {
+    type: "image_captioning_start";
+} | {
+    type: "image_captioning_end";
+    ok: boolean;
 };
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
@@ -414,6 +419,25 @@ export declare class AgentSession {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    private _captionImagesForCurrentModel;
+    /**
+     * Build a small, text-only slice of the most recent conversation to give the
+     * caption model some intent context without risking its context window.
+     * Only user and assistant text is included (tool output/code is skipped), and
+     * the result is capped to the given token budget.
+     */
+    /**
+     * Build a slice of the most recent conversation to give the caption model some
+     * intent context without risking its context window. Only user and assistant
+     * text is included (tool output is skipped).
+     *
+     * Walks messages backward from the end toward the first message. Messages are
+     * kept whole (never truncated mid-message): we stop adding once the next full
+     * message would push us past `maxTokens` (approx chars).
+     */
+    private _recentConversationTail;
+    /** Extract plain user/assistant text from a message; returns "" for others/empty. */
+    private _messageText;
     /**
      * Send a user message to the agent. Always triggers a turn.
      * When the agent is streaming, use deliverAs to specify how to queue the message.

package/dist/core/agent-session.js

@@ -38,6 +38,7 @@ import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions, stripToolParameterDescriptions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
+import { captionImageWithModel } from "./vision-caption.js";
 /** Parse consecutive skill blocks at the start of a user message. */
 export function parseSkillBlocks(text) {
     const skills = [];
@@ -882,6 +883,15 @@ export class AgentSession {
                 expandedText = this._expandSkillCommand(expandedText);
                 expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
             }
+            // Vision relay: when the active model cannot accept images, describe
+            // attached images with the configured caption model (images.imageCaptionModel)
+            // so the main model can work from the description text.
+            if (currentImages && currentImages.length > 0) {
+                const caption = await this._captionImagesForCurrentModel(currentImages, currentText);
+                if (caption) {
+                    expandedText += `\n\n${caption}`;
+                }
+            }
             // If streaming, queue via steer() or followUp() based on option
             if (this.isStreaming) {
                 if (!options?.streamingBehavior) {
@@ -1151,6 +1161,145 @@ export class AgentSession {
             this._emit({ type: "message_end", message: appMessage });
         }
     }
+    /**
+     * Vision relay for attached images: when the active model cannot accept image
+     * input and a caption model is configured (images.imageCaptionModel), describe
+     * each image with the caption model and return the descriptions as text.
+     * Returns null when no captioning applies (vision-capable main model, no
+     * caption model configured, or every caption attempt failed). The caption
+     * model is always called with a minimal fresh context, so main-agent context
+     * usage does not matter here.
+     */
+    async _captionImagesForCurrentModel(images, userPrompt) {
+        const mainModel = this.model;
+        if (!mainModel || mainModel.input.includes("image"))
+            return null;
+        const captionModelId = this.settingsManager.getImageCaptionModel();
+        if (!captionModelId)
+            return null;
+        const slash = captionModelId.indexOf("/");
+        if (slash <= 0 || slash === captionModelId.length - 1)
+            return null;
+        const captionModel = this._modelRuntime.getModel(captionModelId.slice(0, slash), captionModelId.slice(slash + 1));
+        if (!captionModel || !captionModel.input.includes("image"))
+            return null;
+        let auth;
+        try {
+            auth = await this._modelRuntime.getAuth(captionModel);
+        }
+        catch {
+            return null;
+        }
+        if (!auth)
+            return null;
+        const maxContextTokens = this.settingsManager.getImageCaptionContextTokens();
+        const contextText = maxContextTokens > 0 ? this._recentConversationTail(maxContextTokens) : "";
+        // Show a status spinner while the caption request runs so the UI never
+        // looks frozen on a blank screen.
+        this._emit({ type: "image_captioning_start" });
+        try {
+            const descriptions = [];
+            let failureReason;
+            for (const image of images) {
+                const controller = new AbortController();
+                let aborted = false;
+                const timeout = setTimeout(() => {
+                    aborted = true;
+                    controller.abort();
+                }, 15_000);
+                try {
+                    const caption = await captionImageWithModel(captionModel, image, {
+                        apiKey: auth.auth.apiKey,
+                        headers: auth.auth.headers,
+                        signal: controller.signal,
+                        userPrompt,
+                        contextText,
+                        onError: (message) => {
+                            failureReason = message;
+                            console.error("[image-caption] request failed:", message);
+                        },
+                    });
+                    if (caption)
+                        descriptions.push(caption);
+                }
+                catch {
+                    // Captioning is best-effort; fall back to leaving the image attached.
+                }
+                finally {
+                    clearTimeout(timeout);
+                }
+                if (aborted) {
+                    failureReason = failureReason ?? "timed out after 15s";
+                }
+            }
+            if (descriptions.length === 0) {
+                if (failureReason)
+                    console.error("[image-caption] captioning failed:", failureReason);
+                this._emit({ type: "image_captioning_end", ok: false });
+                return null;
+            }
+            this._emit({ type: "image_captioning_end", ok: true });
+            if (descriptions.length === 1) {
+                return `[Image description provided by the ${captionModel.name} vision model:]\n${descriptions[0]}`;
+            }
+            return descriptions
+                .map((d, i) => `[Image ${i + 1} of ${descriptions.length} description:]\n${d}`)
+                .join("\n\n");
+        }
+        catch {
+            this._emit({ type: "image_captioning_end", ok: false });
+            return null;
+        }
+    }
+    /**
+     * Build a small, text-only slice of the most recent conversation to give the
+     * caption model some intent context without risking its context window.
+     * Only user and assistant text is included (tool output/code is skipped), and
+     * the result is capped to the given token budget.
+     */
+    /**
+     * Build a slice of the most recent conversation to give the caption model some
+     * intent context without risking its context window. Only user and assistant
+     * text is included (tool output is skipped).
+     *
+     * Walks messages backward from the end toward the first message. Messages are
+     * kept whole (never truncated mid-message): we stop adding once the next full
+     * message would push us past `maxTokens` (approx chars).
+     */
+    _recentConversationTail(maxTokens) {
+        const messages = this.agent.state.messages;
+        const maxChars = maxTokens * 4;
+        const collected = [];
+        let length = 0;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            const text = this._messageText(msg);
+            if (!text)
+                continue;
+            const entry = `${msg.role === "user" ? "User" : "Assistant"}: ${text}`;
+            // Cut at message boundaries only: once the next full message would
+            // exceed the budget, stop (unless nothing collected yet, so the most
+            // recent exchange is never dropped).
+            if (length > 0 && length + entry.length > maxChars)
+                break;
+            collected.push(entry);
+            length += entry.length;
+        }
+        return collected.reverse().join("\n\n");
+    }
+    /** Extract plain user/assistant text from a message; returns "" for others/empty. */
+    _messageText(msg) {
+        if (msg.role !== "user" && msg.role !== "assistant")
+            return "";
+        if (typeof msg.content === "string")
+            return msg.content;
+        if (!Array.isArray(msg.content))
+            return "";
+        return msg.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+    }
     /**
      * Send a user message to the agent. Always triggers a turn.
      * When the agent is streaming, use deliverAs to specify how to queue the message.
@@ -2092,6 +2241,7 @@ export class AgentSession {
     }
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
+        const imageCaptionModel = this.settingsManager.getImageCaptionModel();
         const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();
         const shellPath = this.settingsManager.getShellPath();
         const baseToolDefinitions = this._baseToolsOverride
@@ -2100,7 +2250,7 @@ export class AgentSession {
                 createToolDefinitionFromAgentTool(tool),
             ]))
             : createAllToolDefinitions(this._cwd, {
-                read: { autoResizeImages },
+                read: { autoResizeImages, imageCaptionModel },
                 bash: { commandPrefix: shellCommandPrefix, shellPath },
             });
         this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));

package/dist/core/package-manager.d.ts

@@ -83,6 +83,7 @@ export declare function getExtensionTempFolder(agentDir: string): string;
  * under the given root (e.g. a settings-listed absolute path elsewhere).
  */
 export declare function extensionEntryName(extPath: string, extensionsRoot: string): string | undefined;
+export declare function isEnabledByOverrides(filePath: string, patterns: string[], baseDir: string, defaultEnabled?: boolean): boolean;
 export declare class DefaultPackageManager implements PackageManager {
     private cwd;
     private agentDir;

package/dist/core/package-manager.js

@@ -529,12 +529,12 @@ function matchesAnyExactPattern(filePath, patterns, baseDir) {
 function getOverridePatterns(entries) {
     return entries.filter((pattern) => pattern.startsWith("!") || pattern.startsWith("+") || pattern.startsWith("-"));
 }
-function isEnabledByOverrides(filePath, patterns, baseDir) {
+export function isEnabledByOverrides(filePath, patterns, baseDir, defaultEnabled = true) {
     const overrides = getOverridePatterns(patterns);
     const excludes = overrides.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
     const forceIncludes = overrides.filter((pattern) => pattern.startsWith("+")).map((pattern) => pattern.slice(1));
     const forceExcludes = overrides.filter((pattern) => pattern.startsWith("-")).map((pattern) => pattern.slice(1));
-    let enabled = true;
+    let enabled = defaultEnabled;
     if (excludes.length > 0 && matchesAnyPattern(filePath, excludes, baseDir)) {
         enabled = false;
     }
@@ -1962,10 +1962,10 @@ export class DefaultPackageManager {
         const projectAgentsSkillDirs = projectTrusted
             ? collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve(dir) !== resolve(userAgentsSkillsDir))
             : [];
-        const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
+        const addResources = (resourceType, paths, metadata, overrides, baseDir, defaultEnabled = true) => {
             const target = this.getTargetMap(accumulator, resourceType);
             for (const path of paths) {
-                const enabled = isEnabledByOverrides(path, overrides, baseDir);
+                const enabled = isEnabledByOverrides(path, overrides, baseDir, defaultEnabled);
                 this.addResource(target, path, metadata, enabled);
             }
         };
@@ -1973,7 +1973,7 @@ export class DefaultPackageManager {
             // Project extensions from .pi/
             addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
             // Project skills from .pi/
-            addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir);
+            addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir, false);
         }
         // Project skills from .agents/ (each with its own baseDir)
         for (const agentsSkillsDir of projectAgentsSkillDirs) {
@@ -1982,7 +1982,7 @@ export class DefaultPackageManager {
                 ...projectMetadata,
                 baseDir: agentsBaseDir,
             };
-            addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir);
+            addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir, false);
         }
         if (projectTrusted) {
             addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
@@ -2057,14 +2057,14 @@ export class DefaultPackageManager {
         }
         addResources("extensions", piHostKept, { ...userMetadata, baseDir: piHostBaseDir }, userOverrides.extensions, piHostBaseDir);
         // User skills from ~/.selesai/agent/
-        addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir);
+        addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir, false);
         // User skills from ~/.agents/ (with its own baseDir)
         const userAgentsBaseDir = dirname(userAgentsSkillsDir);
         const userAgentsMetadata = {
             ...userMetadata,
             baseDir: userAgentsBaseDir,
         };
-        addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir);
+        addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir, false);
         addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
         return collisions;

package/dist/core/package-manager.test.js

@@ -1,8 +1,9 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { extensionEntryName } from "./package-manager.js";
+import { DefaultPackageManager, extensionEntryName } from "./package-manager.js";
+import { SettingsManager } from "./settings-manager.js";
 describe("extensionEntryName", () => {
     let root;
     beforeEach(() => {
@@ -17,3 +18,41 @@ describe("extensionEntryName", () => {
         expect(extensionEntryName(join(root, "question", "index.ts"), root)).toBe("question");
     });
 });
+describe("auto-discovered skills are opt-in by default", () => {
+    let root;
+    const SKILL_BODY = "---\nname: {name}\ndescription: A test skill.\n---\n\n# {name}\n";
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "selesai-skill-root-"));
+    });
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+    function makeSkill(agentDir, name) {
+        const dir = join(agentDir, "skills", name);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "SKILL.md"), SKILL_BODY.replaceAll("{name}", name));
+    }
+    it("defaults auto-discovered user skills to disabled (opt-in)", async () => {
+        makeSkill(root, "alpha");
+        makeSkill(root, "beta");
+        const settingsManager = SettingsManager.inMemory({});
+        const pm = new DefaultPackageManager({ cwd: root, agentDir: root, settingsManager });
+        const resolved = await pm.resolve();
+        const localSkills = resolved.skills.filter((s) => s.path.startsWith(root));
+        expect(localSkills.length).toBe(2);
+        expect(localSkills.every((s) => s.enabled === false)).toBe(true);
+    });
+    it("enables a user skill when it is force-included via a + pattern", async () => {
+        makeSkill(root, "alpha");
+        makeSkill(root, "beta");
+        const settingsManager = SettingsManager.inMemory({
+            skills: ["+skills/alpha/SKILL.md"],
+        });
+        const pm = new DefaultPackageManager({ cwd: root, agentDir: root, settingsManager });
+        const resolved = await pm.resolve();
+        const alpha = resolved.skills.find((s) => s.path.startsWith(root) && s.path.endsWith("alpha/SKILL.md"));
+        const beta = resolved.skills.find((s) => s.path.startsWith(root) && s.path.endsWith("beta/SKILL.md"));
+        expect(alpha?.enabled).toBe(true);
+        expect(beta?.enabled).toBe(false);
+    });
+});

package/dist/core/resource-loader.d.ts

@@ -3,7 +3,7 @@ import type { ResourceDiagnostic } from "./diagnostics.ts";
 export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.ts";
 import { type EventBus } from "./event-bus.ts";
 import type { InlineExtension, LoadExtensionsResult } from "./extensions/types.ts";
-import { type PathMetadata } from "./package-manager.ts";
+import { type PathMetadata, type ResolvedResource } from "./package-manager.ts";
 import type { PromptTemplate } from "./prompt-templates.ts";
 import { SettingsManager } from "./settings-manager.ts";
 import type { AgentPersona } from "./agents.ts";
@@ -34,6 +34,7 @@ export interface ResourceLoader {
         skills: Skill[];
         diagnostics: ResourceDiagnostic[];
     };
+    getResolvedSkills(): ResolvedResource[];
     getPrompts(): {
         prompts: PromptTemplate[];
         diagnostics: ResourceDiagnostic[];
@@ -164,6 +165,7 @@ export declare class DefaultResourceLoader implements ResourceLoader {
     private extensionDiagnostics;
     private skills;
     private skillDiagnostics;
+    private resolvedSkills;
     private agents;
     private agentDiagnostics;
     private prompts;
@@ -190,6 +192,7 @@ export declare class DefaultResourceLoader implements ResourceLoader {
         skills: Skill[];
         diagnostics: ResourceDiagnostic[];
     };
+    getResolvedSkills(): ResolvedResource[];
     getPrompts(): {
         prompts: PromptTemplate[];
         diagnostics: ResourceDiagnostic[];
@@ -223,6 +226,12 @@ export declare class DefaultResourceLoader implements ResourceLoader {
     private resolveExtensionLoadPath;
     private loadFinalExtensionSet;
     private addExtensionConflictDiagnostics;
+    /**
+     * Enumerate every skill subdirectory in the bundled/CLI additional skill dirs,
+     * each gated by the user's skill overrides and defaulting to disabled (opt-in).
+     * Returns resolved resources (SKILL.md paths + enabled state).
+     */
+    private additionalResolvedSkills;
     private mapSkillPath;
     private normalizeExtensionPaths;
     private updateSkillsFromPaths;

package/dist/core/resource-loader.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
 import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
+import { isEnabledByOverrides } from "./package-manager.js";
 import { createEventBus } from "./event-bus.js";
 import { clearExtensionCache, createExtensionRuntime, loadExtensionFromFactory, loadExtensionsCached, } from "./extensions/loader.js";
 import { findGitPaths } from "./footer-data-provider.js";
@@ -139,6 +140,7 @@ export class DefaultResourceLoader {
     extensionDiagnostics;
     skills;
     skillDiagnostics;
+    resolvedSkills = [];
     agents;
     agentDiagnostics;
     prompts;
@@ -221,6 +223,9 @@ export class DefaultResourceLoader {
     getSkills() {
         return { skills: this.skills, diagnostics: this.skillDiagnostics };
     }
+    getResolvedSkills() {
+        return this.resolvedSkills;
+    }
     getPrompts() {
         return { prompts: this.prompts, diagnostics: this.promptDiagnostics };
     }
@@ -351,11 +356,13 @@ export class DefaultResourceLoader {
         }
         this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
         this.applyExtensionSourceInfo(this.extensionsResult.extensions, metadataByPath);
+        const additionalSkills = this.additionalResolvedSkills();
         const skillPaths = this.noSkills
             ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths)
-            : this.mergePaths([...cliEnabledSkills, ...enabledSkills], this.additionalSkillPaths);
+            : this.mergePaths([...cliEnabledSkills, ...enabledSkills], additionalSkills.filter((r) => r.enabled).map((r) => r.path));
         this.lastSkillPaths = skillPaths;
         this.updateSkillsFromPaths(skillPaths, metadataByPath);
+        this.resolvedSkills = [...resolvedPaths.skills, ...additionalSkills];
         for (const p of this.additionalSkillPaths) {
             if (isLocalPath(p)) {
                 const resolved = this.resolveResourcePath(p);
@@ -498,6 +505,43 @@ export class DefaultResourceLoader {
             extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
         }
     }
+    /**
+     * Enumerate every skill subdirectory in the bundled/CLI additional skill dirs,
+     * each gated by the user's skill overrides and defaulting to disabled (opt-in).
+     * Returns resolved resources (SKILL.md paths + enabled state).
+     */
+    additionalResolvedSkills() {
+        const resolved = [];
+        const patterns = this.settingsManager.getSkillPaths();
+        for (const dir of this.additionalSkillPaths) {
+            if (!isLocalPath(dir) || !existsSync(this.resolveResourcePath(dir)))
+                continue;
+            const resolvedDir = this.resolveResourcePath(dir);
+            let entries = [];
+            try {
+                entries = readdirSync(resolvedDir, { withFileTypes: true })
+                    .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                    .map((e) => join(resolvedDir, e.name, "SKILL.md"))
+                    .filter((p) => existsSync(p));
+            }
+            catch {
+                continue;
+            }
+            for (const skillFile of entries) {
+                resolved.push({
+                    path: skillFile,
+                    enabled: isEnabledByOverrides(skillFile, patterns, resolvedDir, false),
+                    metadata: {
+                        source: dir,
+                        scope: "user",
+                        origin: "top-level",
+                        baseDir: resolvedDir,
+                    },
+                });
+            }
+        }
+        return resolved;
+    }
     mapSkillPath(resource, metadataByPath) {
         if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
             return resource.path;

package/dist/core/settings-manager.d.ts

@@ -32,6 +32,8 @@ export interface TerminalSettings {
 export interface ImageSettings {
     autoResize?: boolean;
     blockImages?: boolean;
+    imageCaptionModel?: string;
+    imageCaptionContextTokens?: number;
 }
 export interface ThinkingBudgetsSettings {
     minimal?: number;
@@ -296,6 +298,10 @@ export declare class SettingsManager {
     getImageAutoResize(): boolean;
     setImageAutoResize(enabled: boolean): void;
     getBlockImages(): boolean;
+    getImageCaptionModel(): string | undefined;
+    setImageCaptionModel(modelId: string | undefined): void;
+    getImageCaptionContextTokens(): number;
+    setImageCaptionContextTokens(tokens: number): void;
     setBlockImages(blocked: boolean): void;
     getEnabledModels(): string[] | undefined;
     getDefaultTools(): string[] | undefined;

package/dist/core/settings-manager.js

@@ -859,6 +859,33 @@ export class SettingsManager {
     getBlockImages() {
         return this.settings.images?.blockImages ?? false;
     }
+    getImageCaptionModel() {
+        return this.settings.images?.imageCaptionModel;
+    }
+    setImageCaptionModel(modelId) {
+        if (!this.globalSettings.images) {
+            this.globalSettings.images = {};
+        }
+        if (modelId === undefined || modelId === "off") {
+            delete this.globalSettings.images.imageCaptionModel;
+        }
+        else {
+            this.globalSettings.images.imageCaptionModel = modelId;
+        }
+        this.markModified("images", "imageCaptionModel");
+        this.save();
+    }
+    getImageCaptionContextTokens() {
+        return this.settings.images?.imageCaptionContextTokens ?? 16384;
+    }
+    setImageCaptionContextTokens(tokens) {
+        if (!this.globalSettings.images) {
+            this.globalSettings.images = {};
+        }
+        this.globalSettings.images.imageCaptionContextTokens = tokens;
+        this.markModified("images", "imageCaptionContextTokens");
+        this.save();
+    }
     setBlockImages(blocked) {
         if (!this.globalSettings.images) {
             this.globalSettings.images = {};

package/dist/core/tools/read-vision.test.d.ts

@@ -0,0 +1 @@
+export {};