@4onstudios/iris-agent 0.1.0

package/dist/api/helpers/modelTokenLimits.js

@@ -0,0 +1,158 @@
+const MODEL_INPUT_TOKEN_LIMITS = {
+    "openrouter/anthropic/claude-sonnet-latest": 1_000_000,
+    "openrouter/google/gemini-2.5-pro": 1_000_000,
+    "openrouter/deepseek/deepseek-chat": 164_000,
+    "openrouter/xiaomi/mimo-v2.5": 128_000,
+    "openrouter/minimax/minimax-m3": 128_000,
+    "openrouter/deepseek/deepseek-v4-flash": 128_000,
+    "openrouter/openai/gpt-5.5": 1_000_000,
+    "openrouter/openai/gpt-5.5-pro": 1_000_000,
+    "openrouter/openai/gpt-5.1-codex-mini": 400_000,
+    "openrouter/openai/gpt-5.1-codex": 400_000,
+    "openrouter/openai/gpt-5.1-codex-max": 400_000,
+    "openrouter/openai/gpt-5.2-codex": 400_000,
+    // GPT-5.3 Codex sessions frequently include large tool schemas + long
+    // conversation state; keep a high effective budget to avoid hard drops where
+    // no message fits in the limiter window.
+    "openrouter/openai/gpt-5.3-codex": 400_000,
+    "openrouter/anthropic/claude-haiku-4.5": 200_000,
+    "openrouter/anthropic/claude-opus-4.1": 1_000_000,
+    "openrouter/anthropic/claude-fable-5": 1_000_000,
+    "openrouter/moonshotai/kimi-k2.5": 256_000,
+    "openrouter/moonshotai/kimi-k3": 256_000,
+    "openrouter/google/gemini-2.5-flash": 1_000_000,
+    "openrouter/z-ai/glm-5.2": 128_000,
+    "openrouter/openai/gpt-oss-20b:free": 128_000,
+    "openrouter/openai/gpt-oss-120b:free": 128_000,
+    "openrouter/z-ai/glm-4.5-air:free": 128_000,
+    "openrouter/poolside/laguna-xs.2:free": 64_000,
+    "gemini-2.5-pro": 173_000,
+    "gemini-3-flash-preview": 173_000,
+    "gemini-3.1-pro-preview": 1_000_000,
+    "gemini-3.5-flash": 1_000_000,
+    "gpt-5-mini": 192_000,
+    "gpt-5.2": 192_000,
+    "gpt-5.2-codex": 400_000,
+    "gpt-5.3-codex": 400_000,
+    "gpt-5.4": 1_000_000,
+    "gpt-5.4-mini": 400_000,
+    "raptor-mini-preview": 264_000,
+    "claude-haiku-4.5-other": 160_000,
+    "claude-sonnet-4.5-other": 160_000,
+    "claude-sonnet-4.6-other": 1_000_000,
+    "huggingface/moonshotai/Kimi-K2.7-Code:fastest": 128_000,
+    "huggingface/meta-llama/Llama-4-Maverick-17B-128E-Instruct:fastest": 1_000_000,
+    "huggingface/Qwen/Qwen3-235B-A22B:fastest": 128_000,
+    "huggingface/deepseek-ai/DeepSeek-V3-0324:fastest": 128_000,
+    "huggingface/mistralai/Mistral-Small-3.2-24B-Instruct-2506:fastest": 128_000,
+    "claude-haiku-4-5": 200_000,
+    "claude-opus-4-8": 1_000_000,
+    "claude-fable-5": 1_000_000,
+    "claude-sonnet-4-6": 1_000_000,
+};
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const getEnvTokenLimitOverride = () => {
+    const raw = process.env.IRIS_AGENT_INPUT_TOKEN_LIMIT;
+    if (!raw)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed))
+        return null;
+    return clamp(parsed, 4_096, 1_000_000);
+};
+const inferModelLimitByPattern = (modelId) => {
+    const normalized = modelId.toLowerCase();
+    if (normalized.includes("gemini") || normalized.includes("1m"))
+        return 1_000_000;
+    if (normalized.includes("claude") && normalized.includes("haiku"))
+        return 200_000;
+    if (normalized.includes("claude") && normalized.includes("sonnet"))
+        return 1_000_000;
+    if (normalized.includes("claude") && normalized.includes("opus"))
+        return 1_000_000;
+    if (normalized.includes("gpt-5.3-codex"))
+        return 400_000;
+    if (normalized.includes("gpt-5.2-codex"))
+        return 400_000;
+    if (normalized.includes("gpt-5"))
+        return 192_000;
+    if (normalized.includes("gpt-4o"))
+        return 128_000;
+    if (normalized.includes("deepseek") || normalized.includes("qwen") || normalized.includes("mistral"))
+        return 128_000;
+    if (normalized.includes("laguna"))
+        return 64_000;
+    return null;
+};
+// Models known to accept image content parts at the provider/endpoint level.
+// Keep this exact-match metadata in sync with selectable model metadata rather
+// than inferring from provider/family substrings.
+const VISION_MODEL_IDS = new Set([
+    "openrouter/openai/gpt-5.3-codex",
+    "openrouter/moonshotai/kimi-k2.5",
+    "openrouter/moonshotai/kimi-k3",
+    "openrouter/z-ai/glm-5.3-flash",
+    "openrouter/google/gemini-2.5-pro",
+    "openrouter/google/gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-3-flash-preview",
+    "gemini-3.1-pro-preview",
+    "gemini-3.5-flash",
+    "gpt-5.2",
+    "gpt-5.2-codex",
+    "gpt-5.3-codex",
+    "gpt-5.4",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "claude-haiku-4-5",
+    "claude-opus-4-8",
+    "claude-fable-5",
+    "claude-sonnet-4-6",
+]);
+const stripProviderSuffix = (modelId) => {
+    return modelId.endsWith("-other")
+        ? modelId.slice(0, -"-other".length)
+        : modelId;
+};
+const getVisionModelIdCandidates = (modelId) => {
+    const normalized = stripProviderSuffix((modelId || "").trim().toLowerCase());
+    if (!normalized)
+        return [];
+    const candidates = new Set([normalized]);
+    if (normalized.startsWith("openrouter/")) {
+        candidates.add(normalized.slice("openrouter/".length));
+    }
+    if (normalized.startsWith("openai/")) {
+        candidates.add(normalized.slice("openai/".length));
+    }
+    if (normalized.startsWith("google/")) {
+        candidates.add(normalized.slice("google/".length));
+    }
+    if (normalized.startsWith("anthropic/")) {
+        candidates.add(normalized.slice("anthropic/".length));
+    }
+    if (normalized.includes("/") &&
+        !normalized.startsWith("openrouter/") &&
+        !normalized.startsWith("ollama/") &&
+        !normalized.startsWith("local/") &&
+        !normalized.startsWith("huggingface/")) {
+        candidates.add(`openrouter/${normalized}`);
+    }
+    return Array.from(candidates);
+};
+export const resolveModelSupportsVision = (modelId) => {
+    return getVisionModelIdCandidates(modelId).some((candidate) => VISION_MODEL_IDS.has(candidate));
+};
+export const resolveModelInputTokenLimit = (modelId, fallback = 64_000) => {
+    const envOverride = getEnvTokenLimitOverride();
+    if (envOverride)
+        return envOverride;
+    const normalized = (modelId || "").trim();
+    if (MODEL_INPUT_TOKEN_LIMITS[normalized]) {
+        return MODEL_INPUT_TOKEN_LIMITS[normalized];
+    }
+    const inferred = inferModelLimitByPattern(normalized);
+    if (inferred)
+        return inferred;
+    return clamp(fallback, 4_096, 1_000_000);
+};

package/dist/api/helpers/observationalMemory.d.ts

@@ -0,0 +1,10 @@
+export type ObservationalMemorySettingsPayload = {
+    model?: string;
+    scope?: "resource" | "thread";
+    observationMessageTokens?: number;
+    reflectionObservationTokens?: number;
+    observationPreviousTokens?: number;
+    activateAfterIdle?: string;
+    activateOnProviderChange?: boolean;
+};
+export declare const sanitizeObservationalMemorySettings: (input: unknown) => ObservationalMemorySettingsPayload | undefined;

package/dist/api/helpers/observationalMemory.js

@@ -0,0 +1,36 @@
+const asBoundedInteger = (input, fallback, min, max) => {
+    const parsed = typeof input === "number"
+        ? input
+        : typeof input === "string"
+            ? Number.parseInt(input, 10)
+            : Number.NaN;
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(parsed)));
+};
+export const sanitizeObservationalMemorySettings = (input) => {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const raw = input;
+    const model = typeof raw.model === "string" && raw.model.trim().length > 0
+        ? raw.model.trim()
+        : "google/gemini-2.5-flash";
+    const scope = raw.scope === "thread" ? "thread" : "resource";
+    const observationMessageTokens = asBoundedInteger(raw.observationMessageTokens, 4000, 4000, 200000);
+    const reflectionObservationTokens = asBoundedInteger(raw.reflectionObservationTokens, 8000, 8000, 400000);
+    const observationPreviousTokens = asBoundedInteger(raw.observationPreviousTokens, 0, 0, 100000);
+    const activateAfterIdle = typeof raw.activateAfterIdle === "string" ? raw.activateAfterIdle.trim() : "";
+    const activateOnProviderChange = typeof raw.activateOnProviderChange === "boolean"
+        ? raw.activateOnProviderChange
+        : true;
+    return {
+        model,
+        scope,
+        observationMessageTokens,
+        reflectionObservationTokens,
+        observationPreviousTokens,
+        activateAfterIdle,
+        activateOnProviderChange,
+    };
+};

package/dist/api/helpers/promptBudget.d.ts

@@ -0,0 +1,30 @@
+export type ConversationMessageLike = {
+    content?: string;
+    role?: string;
+    continuationType?: string;
+};
+export { resolveModelInputTokenLimit, resolveModelSupportsVision, } from "./modelTokenLimits.js";
+type PromptBudgetBuildOptions<T extends ConversationMessageLike> = {
+    effectiveMessage: string;
+    conversationHistory?: T[];
+    contextInfo: string;
+    maxPromptTokens: number;
+    maxConversationMessages: number;
+    maxConversationMessageTokens: number;
+    continuationInstruction?: string;
+};
+type PromptBudgetBuildResult<T extends ConversationMessageLike> = {
+    prompt: string;
+    budgetedContextInfo: string;
+    budgetedConversationHistory: T[];
+    promptEstimatedTokens: number;
+};
+export declare const truncateText: (value: string, maxChars: number) => string;
+export declare const truncateMiddle: (value: string, maxChars: number) => string;
+export declare const estimateTokensFromChars: (value: string) => number;
+export declare const truncateTextByTokens: (value: string, maxTokens: number) => string;
+export declare const truncateHeadByTokens: (value: string, maxTokens: number) => string;
+export declare const truncateMiddleByTokens: (value: string, maxTokens: number) => string;
+export declare const budgetConversationHistory: <T extends ConversationMessageLike>(history: T[] | undefined, maxMessages: number, maxCharsPerMessage: number) => T[];
+export declare const budgetConversationHistoryByTokens: <T extends ConversationMessageLike>(history: T[] | undefined, maxMessages: number, maxTokensPerMessage: number, maxTotalTokens: number) => T[];
+export declare const buildPromptWithinTokenBudget: <T extends ConversationMessageLike>(options: PromptBudgetBuildOptions<T>) => PromptBudgetBuildResult<T>;

package/dist/api/helpers/promptBudget.js

@@ -0,0 +1,216 @@
+export { resolveModelInputTokenLimit, resolveModelSupportsVision, } from "./modelTokenLimits.js";
+const TOKEN_TO_CHAR_RATIO = 4;
+const MIN_SECTION_TOKENS = 64;
+const MESSAGE_OVERHEAD_TOKENS = 10;
+const SUMMARY_MESSAGE_LIMIT = 8;
+const SUMMARY_MESSAGE_CHAR_LIMIT = 220;
+export const truncateText = (value, maxChars) => {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 31))}\n\n[truncated: prompt budget exceeded]`;
+};
+export const truncateMiddle = (value, maxChars) => {
+    if (value.length <= maxChars)
+        return value;
+    const marker = "\n\n[truncated middle content for prompt budget]\n\n";
+    if (maxChars <= marker.length + 2) {
+        return truncateText(value, maxChars);
+    }
+    const remaining = maxChars - marker.length;
+    const head = Math.floor(remaining * 0.7);
+    const tail = remaining - head;
+    return `${value.slice(0, head)}${marker}${value.slice(Math.max(0, value.length - tail))}`;
+};
+export const estimateTokensFromChars = (value) => Math.ceil((value || "").length / TOKEN_TO_CHAR_RATIO);
+export const truncateTextByTokens = (value, maxTokens) => {
+    const safeMaxTokens = Math.max(0, maxTokens);
+    const maxChars = safeMaxTokens * TOKEN_TO_CHAR_RATIO;
+    return truncateText(value || "", maxChars);
+};
+export const truncateHeadByTokens = (value, maxTokens) => {
+    const safeMaxTokens = Math.max(0, maxTokens);
+    const maxChars = safeMaxTokens * TOKEN_TO_CHAR_RATIO;
+    if (value.length <= maxChars)
+        return value;
+    const keepChars = Math.max(0, maxChars - 31);
+    return `\n\n[truncated: prompt budget exceeded]\n${value.slice(Math.max(0, value.length - keepChars))}`;
+};
+export const truncateMiddleByTokens = (value, maxTokens) => {
+    const safeMaxTokens = Math.max(0, maxTokens);
+    const maxChars = safeMaxTokens * TOKEN_TO_CHAR_RATIO;
+    return truncateMiddle(value || "", maxChars);
+};
+export const budgetConversationHistory = (history, maxMessages, maxCharsPerMessage) => {
+    if (!history || history.length === 0)
+        return [];
+    return history
+        .slice(-maxMessages)
+        .map((message) => ({
+        ...message,
+        content: truncateText(message.content || "", maxCharsPerMessage),
+    }));
+};
+export const budgetConversationHistoryByTokens = (history, maxMessages, maxTokensPerMessage, maxTotalTokens) => {
+    if (!history || history.length === 0)
+        return [];
+    const safeMaxMessages = Math.max(1, maxMessages);
+    const safeMaxTokensPerMessage = Math.max(0, maxTokensPerMessage);
+    const safeMaxTotalTokens = Math.max(0, maxTotalTokens);
+    const windowed = history.slice(-safeMaxMessages);
+    const droppedByWindow = history.slice(0, Math.max(0, history.length - windowed.length));
+    const selected = [];
+    let remainingTokens = safeMaxTotalTokens;
+    let selectedStartIndex = windowed.length;
+    for (let i = windowed.length - 1; i >= 0; i -= 1) {
+        if (remainingTokens <= MESSAGE_OVERHEAD_TOKENS)
+            break;
+        const message = windowed[i];
+        const content = typeof message.content === "string" ? message.content : "";
+        if (!content)
+            continue;
+        const isToolResultsContinuation = message.continuationType === "tool_results";
+        const perMessageBudget = Math.min(isToolResultsContinuation
+            ? Math.max(safeMaxTokensPerMessage, safeMaxTotalTokens)
+            : safeMaxTokensPerMessage, remainingTokens - MESSAGE_OVERHEAD_TOKENS);
+        if (perMessageBudget <= 0)
+            break;
+        const truncatedContent = truncateTextByTokens(content, perMessageBudget);
+        const estimatedTokens = estimateTokensFromChars(truncatedContent) + MESSAGE_OVERHEAD_TOKENS;
+        if (estimatedTokens > remainingTokens)
+            break;
+        selected.unshift({
+            ...message,
+            content: truncatedContent,
+        });
+        selectedStartIndex = i;
+        remainingTokens -= estimatedTokens;
+    }
+    const omittedMessages = [...droppedByWindow, ...windowed.slice(0, selectedStartIndex)];
+    if (omittedMessages.length === 0) {
+        if (selected.length > 0) {
+            return selected;
+        }
+        const fallbackMessage = windowed[windowed.length - 1];
+        const fallbackBudget = Math.min(safeMaxTokensPerMessage, safeMaxTotalTokens - MESSAGE_OVERHEAD_TOKENS);
+        if (fallbackBudget <= 0) {
+            return [];
+        }
+        return [
+            {
+                ...fallbackMessage,
+                content: truncateTextByTokens(fallbackMessage.content || "", fallbackBudget),
+            },
+        ];
+    }
+    const summaryBudget = Math.min(Math.max(1, Math.floor(safeMaxTotalTokens * 0.25)), Math.max(0, safeMaxTotalTokens - MESSAGE_OVERHEAD_TOKENS));
+    if (summaryBudget <= 0) {
+        return selected;
+    }
+    const summaryText = truncateTextByTokens(buildConversationSummary(omittedMessages), summaryBudget);
+    const summaryTokenUsage = estimateTokensFromChars(summaryText) + MESSAGE_OVERHEAD_TOKENS;
+    const selectedWithTokens = selected.map((message) => ({
+        message,
+        tokenUsage: estimateTokensFromChars(typeof message.content === "string" ? message.content : "") +
+            MESSAGE_OVERHEAD_TOKENS,
+    }));
+    let selectedTokenUsage = selectedWithTokens.reduce((total, entry) => total + entry.tokenUsage, 0);
+    while (selectedTokenUsage + summaryTokenUsage > safeMaxTotalTokens && selectedWithTokens.length > 0) {
+        const removed = selectedWithTokens.shift();
+        if (!removed)
+            break;
+        selectedTokenUsage -= removed.tokenUsage;
+    }
+    const summarizedConversation = {
+        role: "system",
+        content: summaryText,
+    };
+    if (selectedWithTokens.length > 0) {
+        return [summarizedConversation, ...selectedWithTokens.map((entry) => entry.message)];
+    }
+    return [
+        summarizedConversation,
+    ];
+};
+const formatRoleLabel = (role) => {
+    if (role === "user")
+        return "User";
+    if (role === "assistant")
+        return "Assistant";
+    if (role === "tool")
+        return "Tool";
+    if (role === "system")
+        return "System";
+    return "Assistant";
+};
+const buildConversationSummary = (history) => {
+    if (history.length === 0)
+        return "";
+    const recentEntries = history.slice(-SUMMARY_MESSAGE_LIMIT);
+    const parts = recentEntries.map((message) => {
+        const role = formatRoleLabel(message.role);
+        const content = truncateText((message.content || "").replace(/\s+/g, " ").trim(), SUMMARY_MESSAGE_CHAR_LIMIT).trim();
+        return content ? `${role}: ${content}` : role;
+    });
+    return `Conversation state: ${parts.join("; ")}`;
+};
+const formatConversationTranscript = (history) => history
+    .map((message) => `**${formatRoleLabel(message.role)}:** ${message.content || ""}`)
+    .join("\n\n");
+export const buildPromptWithinTokenBudget = (options) => {
+    const { effectiveMessage, conversationHistory, contextInfo, maxPromptTokens, maxConversationMessages, maxConversationMessageTokens, continuationInstruction, } = options;
+    const safeMaxPromptTokens = Math.max(512, maxPromptTokens);
+    const safeContinuation = typeof continuationInstruction === "string"
+        ? continuationInstruction.trim()
+        : "";
+    const continuationTokens = safeContinuation
+        ? estimateTokensFromChars(`\n\n${safeContinuation}`)
+        : 0;
+    const baseBudget = Math.max(256, safeMaxPromptTokens - continuationTokens);
+    const hasHistory = Array.isArray(conversationHistory) && conversationHistory.length > 0;
+    const historyBudget = hasHistory ? Math.max(MIN_SECTION_TOKENS, Math.floor(baseBudget * 0.6)) : 0;
+    const contextBudget = hasHistory
+        ? Math.max(MIN_SECTION_TOKENS, baseBudget - historyBudget)
+        : Math.max(MIN_SECTION_TOKENS, Math.floor(baseBudget * 0.7));
+    const budgetedConversationHistory = hasHistory
+        ? budgetConversationHistoryByTokens(conversationHistory, maxConversationMessages, maxConversationMessageTokens, historyBudget)
+        : [];
+    const budgetedContextInfo = truncateMiddleByTokens(contextInfo || "", contextBudget);
+    let prompt = "";
+    if (budgetedConversationHistory.length > 0) {
+        const transcript = formatConversationTranscript(budgetedConversationHistory);
+        prompt = `${transcript}\n\n${budgetedContextInfo}`;
+    }
+    else {
+        const messageBudget = Math.max(MIN_SECTION_TOKENS, baseBudget - contextBudget);
+        const budgetedMessage = truncateTextByTokens(effectiveMessage || "", messageBudget);
+        prompt = `${budgetedMessage}\n\n${budgetedContextInfo}`;
+    }
+    if (safeContinuation.length > 0) {
+        const promptWithContinuation = `${prompt}\n\n${safeContinuation}`;
+        if (estimateTokensFromChars(promptWithContinuation) <= safeMaxPromptTokens) {
+            prompt = promptWithContinuation;
+        }
+        else {
+            const compressedPrompt = truncateMiddleByTokens(prompt, Math.max(MIN_SECTION_TOKENS, safeMaxPromptTokens - continuationTokens));
+            prompt = `${compressedPrompt}\n\n${safeContinuation}`;
+        }
+    }
+    const promptEstimatedTokens = estimateTokensFromChars(prompt);
+    if (promptEstimatedTokens > safeMaxPromptTokens) {
+        const hardLimitedPrompt = budgetedConversationHistory.some((message) => message.continuationType === "tool_results")
+            ? truncateHeadByTokens(prompt, safeMaxPromptTokens)
+            : truncateMiddleByTokens(prompt, safeMaxPromptTokens);
+        return {
+            prompt: hardLimitedPrompt,
+            budgetedContextInfo,
+            budgetedConversationHistory,
+            promptEstimatedTokens: estimateTokensFromChars(hardLimitedPrompt),
+        };
+    }
+    return {
+        prompt,
+        budgetedContextInfo,
+        budgetedConversationHistory,
+        promptEstimatedTokens,
+    };
+};

package/dist/api/helpers/resolveImageMessageParts.d.ts

@@ -0,0 +1,9 @@
+type ImageContextFile = Record<string, any>;
+export type ResolvedImageMessagePart = {
+    type: "image";
+    image: string;
+    mediaType?: string;
+};
+export declare const isLikelyImageFile: (file: ImageContextFile) => boolean;
+export declare const resolveImageMessageParts: (filesInContext: ImageContextFile[], workspacePath: string, isWebWorkspace: boolean, allowOutOfWorkspace?: boolean) => Promise<ResolvedImageMessagePart[]>;
+export {};

package/dist/api/helpers/resolveImageMessageParts.js

@@ -0,0 +1,140 @@
+import fs from "fs/promises";
+import path from "path";
+const IMAGE_EXT_TO_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+    bmp: "image/bmp",
+    svg: "image/svg+xml",
+    avif: "image/avif",
+};
+const MAX_IMAGE_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const MAX_IMAGES_PER_REQUEST = 1;
+const isPathWithin = (basePath, targetPath) => {
+    const relative = path.relative(basePath, targetPath);
+    return !(path.isAbsolute(relative) ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`));
+};
+const resolveImageMediaType = (file) => {
+    const rawType = typeof file?.type === "string" ? file.type.trim().toLowerCase() : "";
+    if (rawType.startsWith("image/")) {
+        return rawType;
+    }
+    const ext = typeof file?.name === "string"
+        ? file.name.split(".").pop()?.toLowerCase() || ""
+        : "";
+    return IMAGE_EXT_TO_MIME[ext] || undefined;
+};
+export const isLikelyImageFile = (file) => {
+    const mediaType = resolveImageMediaType(file);
+    if (mediaType) {
+        return true;
+    }
+    const pathValue = typeof file?.path === "string" ? file.path.toLowerCase() : "";
+    return /\.(png|jpe?g|webp|gif|bmp|svg|avif)$/.test(pathValue);
+};
+const toDataUrlFromBuffer = (bytes, mediaType) => `data:${mediaType};base64,${bytes.toString("base64")}`;
+const getErrorMessage = (err) => {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    if (typeof err === "string") {
+        return err;
+    }
+    if (err === null || err === undefined) {
+        return String(err);
+    }
+    return String(err);
+};
+export const resolveImageMessageParts = async (filesInContext, workspacePath, isWebWorkspace, allowOutOfWorkspace = false) => {
+    const parts = [];
+    const resolvedWorkspace = path.resolve(workspacePath);
+    const realWorkspace = await fs
+        .realpath(resolvedWorkspace)
+        .catch(() => resolvedWorkspace);
+    let imagesIncluded = 0;
+    for (const file of filesInContext) {
+        if (!isLikelyImageFile(file)) {
+            continue;
+        }
+        if (imagesIncluded >= MAX_IMAGES_PER_REQUEST) {
+            console.warn("Skipping image: reached maximum images per request limit");
+            continue;
+        }
+        const mediaType = resolveImageMediaType(file) || "image/png";
+        const encodedFromClient = typeof file?.imageDataUrl === "string" ? file.imageDataUrl.trim() : "";
+        if (encodedFromClient.startsWith("data:image/")) {
+            parts.push({
+                type: "image",
+                image: encodedFromClient,
+                mediaType,
+            });
+            imagesIncluded++;
+            continue;
+        }
+        const directUrlCandidates = [file?.imageUrl, file?.previewUrl, file?.path]
+            .filter((value) => typeof value === "string" && value.trim().length > 0)
+            .map((value) => value.trim());
+        const httpsUrl = directUrlCandidates.find((value) => /^https?:\/\//i.test(value));
+        if (httpsUrl) {
+            parts.push({
+                type: "image",
+                image: httpsUrl,
+                mediaType,
+            });
+            imagesIncluded++;
+            continue;
+        }
+        if (isWebWorkspace) {
+            continue;
+        }
+        const filePathValue = typeof file?.path === "string" && file.path.trim().length > 0
+            ? file.path.trim()
+            : "";
+        if (!filePathValue || /^blob:/i.test(filePathValue)) {
+            continue;
+        }
+        const absolutePath = path.isAbsolute(filePathValue)
+            ? path.resolve(filePathValue)
+            : path.resolve(path.join(resolvedWorkspace, filePathValue));
+        if (!path.isAbsolute(filePathValue)) {
+            if (!isPathWithin(resolvedWorkspace, absolutePath)) {
+                console.warn("Skipping path-traversing relative image path:", filePathValue);
+                continue;
+            }
+        }
+        try {
+            let readablePath = absolutePath;
+            if (!allowOutOfWorkspace) {
+                const realAbsolutePath = await fs.realpath(absolutePath);
+                if (!isPathWithin(realWorkspace, realAbsolutePath)) {
+                    console.warn("Skipping out-of-workspace image path:", filePathValue);
+                    continue;
+                }
+                readablePath = realAbsolutePath;
+            }
+            const stats = await fs.stat(readablePath);
+            if (!stats.isFile()) {
+                continue;
+            }
+            if (stats.size > MAX_IMAGE_FILE_SIZE_BYTES) {
+                console.warn("Skipping oversized image:", filePathValue, `${stats.size} bytes exceeds limit of ${MAX_IMAGE_FILE_SIZE_BYTES} bytes`);
+                continue;
+            }
+            const bytes = await fs.readFile(readablePath);
+            parts.push({
+                type: "image",
+                image: toDataUrlFromBuffer(bytes, mediaType),
+                mediaType,
+            });
+            imagesIncluded++;
+        }
+        catch (err) {
+            console.warn("Failed to read image:", filePathValue, getErrorMessage(err));
+        }
+    }
+    return parts;
+};

package/dist/api/helpers/slashCommands.d.ts

@@ -0,0 +1,31 @@
+export type ConversationMessageLike = {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+};
+export type ContextSummaryItemLike = {
+    preview: string;
+};
+export type ParsedSlashCommand = {
+    name: string;
+    shellCommand: string;
+};
+export type SlashCommandDescriptor = {
+    name: string;
+    description: string;
+    executeImmediately: boolean;
+    kind: "builtin" | "shell";
+    aliases: string[];
+};
+export declare const getSlashCommandDescriptors: () => SlashCommandDescriptor[];
+export declare const parseSlashCommandRequest: (input?: string) => ParsedSlashCommand | null;
+export declare const isSlashCommandsFeatureEnabled: () => boolean;
+export declare const executeRegisteredSlashCommand: ({ parsedCommand, conversationHistory, contextSummary, }: {
+    parsedCommand: ParsedSlashCommand;
+    conversationHistory?: ConversationMessageLike[];
+    contextSummary?: ContextSummaryItemLike[];
+}) => {
+    success: boolean;
+    response: string;
+    toolCalls: any[];
+    executedToolResults: any[];
+};