@4onstudios/iris-agent 0.1.0

package/dist/api/core/agent/utils/multimodalTokenLimiter.js

@@ -0,0 +1,238 @@
+import { TokenLimiterProcessor } from "@mastra/core/processors";
+const EMPTY_BUDGET_ERROR_MARKER = "No messages fit within the remaining token budget";
+const EMERGENCY_TRUNCATION_NOTICE = "[conversation truncated to fit token budget for this step]";
+const EMERGENCY_MAX_CONTENT_CHARS = 1_200;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const asString = (value) => typeof value === "string" ? value : "";
+const truncateText = (value, maxChars = EMERGENCY_MAX_CONTENT_CHARS) => {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const head = value.slice(0, Math.max(0, maxChars - EMERGENCY_TRUNCATION_NOTICE.length - 2));
+    return `${head}\n${EMERGENCY_TRUNCATION_NOTICE}`;
+};
+const getMessageParts = (message) => {
+    if (Array.isArray(message.content)) {
+        return message.content;
+    }
+    if (isRecord(message.content) && Array.isArray(message.content.parts)) {
+        return message.content.parts;
+    }
+    return [];
+};
+const getMessageId = (message) => {
+    const id = message.id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+};
+const getMessageRole = (message) => {
+    const role = message.role;
+    return typeof role === "string" ? role : "";
+};
+const compactMessageContent = (message) => {
+    const content = message.content;
+    if (typeof content === "string") {
+        message.content = truncateText(content);
+        return;
+    }
+    if (Array.isArray(content)) {
+        const textParts = content
+            .filter((part) => isRecord(part) && part.type === "text")
+            .map((part) => asString(part.text).trim())
+            .filter((text) => text.length > 0);
+        const merged = textParts.join("\n\n").trim();
+        message.content = truncateText(merged || EMERGENCY_TRUNCATION_NOTICE);
+        return;
+    }
+    if (isRecord(content) && Array.isArray(content.parts)) {
+        const textParts = content.parts
+            .filter((part) => isRecord(part) && part.type === "text")
+            .map((part) => asString(part.text).trim())
+            .filter((text) => text.length > 0);
+        const merged = textParts.join("\n\n").trim();
+        message.content = truncateText(merged || EMERGENCY_TRUNCATION_NOTICE);
+        return;
+    }
+    message.content = EMERGENCY_TRUNCATION_NOTICE;
+};
+const applyEmergencyBudgetFallback = async (messageList) => {
+    const messages = messageList?.get?.all?.db?.();
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return false;
+    }
+    const records = messages.filter((msg) => isRecord(msg));
+    if (records.length === 0) {
+        return false;
+    }
+    let latestUserMessage = null;
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+        if (getMessageRole(records[index]) === "user") {
+            latestUserMessage = records[index];
+            break;
+        }
+    }
+    const lastMessage = records[records.length - 1] || null;
+    const keepSet = new Set();
+    if (latestUserMessage)
+        keepSet.add(latestUserMessage);
+    if (lastMessage)
+        keepSet.add(lastMessage);
+    if (keepSet.size === 0 && records[0])
+        keepSet.add(records[0]);
+    const removeIds = records
+        .filter((message) => !keepSet.has(message))
+        .map((message) => getMessageId(message))
+        .filter((id) => Boolean(id));
+    if (removeIds.length > 0 && typeof messageList.removeByIds === "function") {
+        await messageList.removeByIds(removeIds);
+    }
+    keepSet.forEach((message) => compactMessageContent(message));
+    return removeIds.length > 0 || keepSet.size > 0;
+};
+const isNoMessagesFitBudgetError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.includes(EMPTY_BUDGET_ERROR_MARKER);
+};
+const isImagePart = (part) => {
+    if (part.type === "image" || part.type === "image-data" || part.type === "image-url") {
+        return true;
+    }
+    if (part.type === "media") {
+        const mediaType = typeof part.mediaType === "string" ? part.mediaType : "";
+        return mediaType.startsWith("image/");
+    }
+    const mediaType = typeof part.mediaType === "string"
+        ? part.mediaType
+        : typeof part.mimeType === "string"
+            ? part.mimeType
+            : "";
+    return part.type === "file" && mediaType.startsWith("image/");
+};
+/**
+ * Tool-result parts nest their payload inside `output.value` (AI SDK v2
+ * `LanguageModelV2ToolResultOutput` with `type: 'content'`), e.g. an MCP
+ * screenshot tool returns `{ type: 'tool-result', output: { type: 'content',
+ * value: [{ type: 'media', data, mediaType }] } }`. Images here are *not*
+ * top-level content parts, so callers must also inspect this nested array to
+ * find/redact images embedded in tool results.
+ */
+const getToolResultOutputValueParts = (part) => {
+    if (part.type !== "tool-result") {
+        return [];
+    }
+    const output = part.output;
+    if (!isRecord(output) || output.type !== "content" || !Array.isArray(output.value)) {
+        return [];
+    }
+    return output.value.filter(isRecord);
+};
+const redactPartPayload = (part, restorations) => {
+    for (const key of ["image", "data", "url"]) {
+        if (!(key in part)) {
+            continue;
+        }
+        const payload = part[key];
+        part[key] = "[multimodal image]";
+        restorations.push(() => {
+            part[key] = payload;
+        });
+    }
+};
+export const redactMultimodalPayloads = (messages) => {
+    const restorations = [];
+    for (const message of messages) {
+        if (!isRecord(message)) {
+            continue;
+        }
+        for (const part of getMessageParts(message)) {
+            if (!isRecord(part)) {
+                continue;
+            }
+            if (isImagePart(part)) {
+                redactPartPayload(part, restorations);
+            }
+            for (const nested of getToolResultOutputValueParts(part)) {
+                if (isImagePart(nested)) {
+                    redactPartPayload(nested, restorations);
+                }
+            }
+        }
+    }
+    return () => {
+        for (const restore of restorations) {
+            restore();
+        }
+    };
+};
+const IMAGE_UNSUPPORTED_PLACEHOLDER_TEXT = "[Image omitted: the selected model does not support image input]";
+/**
+ * Permanently converts image content parts (e.g. tool-result screenshots or
+ * user-attached images) into a text placeholder. Used when the target model
+ * does not support image input, to avoid provider-level 400/404 errors such
+ * as OpenRouter's "No endpoints found that support image input".
+ */
+const stripUnsupportedImageParts = (messages) => {
+    for (const message of messages) {
+        if (!isRecord(message)) {
+            continue;
+        }
+        const parts = getMessageParts(message);
+        if (parts.length === 0) {
+            continue;
+        }
+        for (let i = 0; i < parts.length; i += 1) {
+            const part = parts[i];
+            if (!isRecord(part)) {
+                continue;
+            }
+            if (isImagePart(part)) {
+                parts[i] = { type: "text", text: IMAGE_UNSUPPORTED_PLACEHOLDER_TEXT };
+                continue;
+            }
+            // Tool-result parts carry images nested inside `output.value[]`; strip
+            // those in place so the surrounding tool-result part (and its other
+            // text entries) are preserved.
+            const nestedParts = getToolResultOutputValueParts(part);
+            if (nestedParts.length === 0) {
+                continue;
+            }
+            for (let j = 0; j < nestedParts.length; j += 1) {
+                if (isImagePart(nestedParts[j])) {
+                    nestedParts[j] = { type: "text", text: IMAGE_UNSUPPORTED_PLACEHOLDER_TEXT };
+                }
+            }
+            part.output.value = nestedParts;
+        }
+    }
+};
+export class MultimodalTokenLimiterProcessor extends TokenLimiterProcessor {
+    supportsVision;
+    constructor(limit, supportsVision = true) {
+        super(limit);
+        this.supportsVision = supportsVision;
+    }
+    async processInputStep(args) {
+        const messages = args.messageList.get.all.db();
+        if (!this.supportsVision) {
+            stripUnsupportedImageParts(messages);
+        }
+        const restore = redactMultimodalPayloads(messages);
+        try {
+            await super.processInputStep(args);
+        }
+        catch (error) {
+            if (!isNoMessagesFitBudgetError(error)) {
+                throw error;
+            }
+            const didApplyFallback = await applyEmergencyBudgetFallback(args.messageList);
+            if (!didApplyFallback) {
+                throw error;
+            }
+            await super.processInputStep(args);
+        }
+        finally {
+            restore();
+        }
+    }
+}

package/dist/api/core/agent/utils/openRouterModelSettings.d.ts

@@ -0,0 +1,12 @@
+type OpenRouterModelSettings = {
+    reasoning?: {
+        max_tokens: number;
+    };
+    provider: {
+        order?: string[];
+        allow_fallbacks?: boolean;
+        require_parameters?: boolean;
+    };
+};
+export declare const resolveOpenRouterModelSettings: (modelId: string) => OpenRouterModelSettings | undefined;
+export {};

package/dist/api/core/agent/utils/openRouterModelSettings.js

@@ -0,0 +1,34 @@
+export const resolveOpenRouterModelSettings = (modelId) => {
+    const id = modelId.toLowerCase();
+    if (id === "moonshotai/kimi-k3") {
+        return {
+            reasoning: {
+                max_tokens: 2048,
+            },
+            provider: {
+                order: ["moonshotai", "baseten", "wafer", "morph", "fireworks"],
+                allow_fallbacks: true,
+                require_parameters: true,
+            },
+        };
+    }
+    if (id === "z-ai/glm-5.2") {
+        return {
+            provider: {
+                order: ["z-ai"],
+                allow_fallbacks: false,
+                require_parameters: true,
+            },
+        };
+    }
+    if (id === "deepseek/deepseek-v4-flash" || id === "deepseek/deepseek-chat") {
+        return {
+            provider: {
+                order: ["deepseek", "together", "fireworks", "lepton"],
+                allow_fallbacks: true,
+                require_parameters: true,
+            },
+        };
+    }
+    return undefined;
+};

package/dist/api/core/agent/utils/pathRecovery.d.ts

@@ -0,0 +1 @@
+export declare const buildRecoveryQueries: (inputPath: string, basePath: string) => string[];

package/dist/api/core/agent/utils/pathRecovery.js

@@ -0,0 +1,29 @@
+import path from "path";
+export const buildRecoveryQueries = (inputPath, basePath) => {
+    const normalizedInput = inputPath.replace(/\\/g, "/");
+    const queries = new Set();
+    queries.add(inputPath);
+    const baseName = path.basename(normalizedInput);
+    if (baseName) {
+        queries.add(baseName);
+    }
+    if (path.isAbsolute(inputPath)) {
+        const resolved = path.resolve(inputPath).replace(/\\/g, "/");
+        const workspaceName = path.basename(basePath.replace(/\\/g, "/"));
+        const workspaceAnchor = `/${workspaceName}/`;
+        const anchorIndex = resolved.indexOf(workspaceAnchor);
+        if (anchorIndex >= 0) {
+            const afterAnchor = resolved.slice(anchorIndex + workspaceAnchor.length);
+            if (afterAnchor) {
+                queries.add(afterAnchor);
+            }
+        }
+        const segments = resolved.split("/").filter(Boolean);
+        for (let depth = 2; depth <= 4; depth++) {
+            if (segments.length >= depth) {
+                queries.add(segments.slice(-depth).join("/"));
+            }
+        }
+    }
+    return Array.from(queries).filter(Boolean);
+};

package/dist/api/core/agent/utils/repoMapIndex.d.ts

@@ -0,0 +1,3 @@
+export declare const findFilesViaRepoMap: (workspaceRoot: string, query: string, limit?: number) => Promise<string[]>;
+export declare const rankFileCandidates: (workspaceRoot: string, query: string, candidates: string[]) => Promise<string[]>;
+export declare const clearRepoMapCache: () => void;

package/dist/api/core/agent/utils/repoMapIndex.js

@@ -0,0 +1,197 @@
+import fs from "fs/promises";
+import path from "path";
+import { glob } from "glob";
+const REPO_MAP_TTL_MS = 30_000;
+const MAX_INDEX_FILES = 2_000;
+const MAX_FILE_SIZE_BYTES = 512 * 1024;
+const cache = new Map();
+const SOURCE_PATTERNS = [
+    "src/**/*.{ts,tsx,js,jsx,mjs,cjs,json,md,css,scss,yml,yaml}",
+    "api/**/*.{ts,tsx,js,jsx,mjs,cjs,json,md,yml,yaml}",
+    "tests/**/*.{ts,tsx,js,jsx,mjs,cjs,json,md}",
+    "*.{ts,tsx,js,jsx,mjs,cjs,json,md,yml,yaml}",
+    ".*",
+];
+const SYMBOL_PATTERNS = [
+    /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g,
+    /\b(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)\b/g,
+];
+const tokenizeQuery = (value) => value
+    .toLowerCase()
+    .replace(/[^a-z0-9_./-]+/g, " ")
+    .split(/[\s/._-]+/)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 2);
+const normalizeRelativeInputPath = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\//, "");
+const unique = (items) => Array.from(new Set(items));
+const extractSymbols = (content) => {
+    const symbols = new Set();
+    for (const pattern of SYMBOL_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match = pattern.exec(content);
+        while (match) {
+            const candidate = match[1]?.trim();
+            if (candidate) {
+                symbols.add(candidate);
+            }
+            match = pattern.exec(content);
+        }
+    }
+    return Array.from(symbols);
+};
+const buildRepoMap = async (workspaceRoot) => {
+    const discovered = await glob(SOURCE_PATTERNS, {
+        cwd: workspaceRoot,
+        absolute: true,
+        nodir: true,
+        dot: true,
+        follow: false,
+        ignore: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.git/**",
+            "**/coverage/**",
+            "**/target/**",
+        ],
+    });
+    const selectedFiles = unique(discovered).slice(0, MAX_INDEX_FILES);
+    const entries = [];
+    for (const absolutePath of selectedFiles) {
+        try {
+            const stats = await fs.stat(absolutePath);
+            if (!stats.isFile() || stats.size > MAX_FILE_SIZE_BYTES) {
+                continue;
+            }
+            const content = await fs.readFile(absolutePath, "utf8");
+            const relativePath = path.relative(workspaceRoot, absolutePath);
+            entries.push({
+                absolutePath,
+                relativePath,
+                relativePathLower: relativePath.replace(/\\/g, "/").toLowerCase(),
+                baseNameLower: path.basename(absolutePath).toLowerCase(),
+                symbols: extractSymbols(content),
+            });
+        }
+        catch {
+            // Ignore unreadable files and continue indexing.
+        }
+    }
+    return entries;
+};
+const getRepoMapEntries = async (workspaceRoot) => {
+    const now = Date.now();
+    const cached = cache.get(workspaceRoot);
+    if (cached && now - cached.builtAt < REPO_MAP_TTL_MS) {
+        return cached.entries;
+    }
+    const entries = await buildRepoMap(workspaceRoot);
+    cache.set(workspaceRoot, {
+        builtAt: now,
+        entries,
+    });
+    return entries;
+};
+const scoreEntry = (entry, query, normalizedQuery, tokens) => {
+    let score = 0;
+    const queryLower = query.toLowerCase();
+    const rel = entry.relativePathLower;
+    if (normalizedQuery && rel === normalizedQuery.toLowerCase()) {
+        score += 1000;
+    }
+    if (normalizedQuery && rel.endsWith(`/${normalizedQuery.toLowerCase()}`)) {
+        score += 400;
+    }
+    const queryBase = path.basename(normalizedQuery || query).toLowerCase();
+    if (queryBase && entry.baseNameLower === queryBase) {
+        score += 180;
+    }
+    if (queryLower && entry.baseNameLower.includes(queryLower)) {
+        score += 80;
+    }
+    for (const token of tokens) {
+        if (entry.baseNameLower.includes(token)) {
+            score += 24;
+        }
+        if (rel.includes(token)) {
+            score += 10;
+        }
+        for (const symbol of entry.symbols) {
+            const symbolLower = symbol.toLowerCase();
+            if (symbolLower === token) {
+                score += 50;
+            }
+            else if (symbolLower.includes(token)) {
+                score += 20;
+            }
+        }
+    }
+    return score;
+};
+export const findFilesViaRepoMap = async (workspaceRoot, query, limit = 10) => {
+    const normalizedQuery = normalizeRelativeInputPath(query);
+    const tokens = tokenizeQuery(query);
+    if (!normalizedQuery && tokens.length === 0) {
+        return [];
+    }
+    const entries = await getRepoMapEntries(workspaceRoot);
+    const ranked = entries
+        .map((entry) => ({
+        entry,
+        score: scoreEntry(entry, query, normalizedQuery, tokens),
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, Math.max(1, limit));
+    return ranked.map((candidate) => candidate.entry.absolutePath);
+};
+export const rankFileCandidates = async (workspaceRoot, query, candidates) => {
+    if (candidates.length <= 1) {
+        return candidates;
+    }
+    const normalizedQuery = normalizeRelativeInputPath(query);
+    const tokens = tokenizeQuery(query);
+    const entries = await getRepoMapEntries(workspaceRoot);
+    const entryByPath = new Map(entries.map((entry) => [entry.absolutePath, entry]));
+    const scored = candidates.map((absolutePath) => {
+        const entry = entryByPath.get(absolutePath);
+        if (entry) {
+            return {
+                absolutePath,
+                score: scoreEntry(entry, query, normalizedQuery, tokens),
+            };
+        }
+        const relativePathLower = path
+            .relative(workspaceRoot, absolutePath)
+            .replace(/\\/g, "/")
+            .toLowerCase();
+        const baseNameLower = path.basename(absolutePath).toLowerCase();
+        let score = 0;
+        if (normalizedQuery && relativePathLower === normalizedQuery.toLowerCase()) {
+            score += 1000;
+        }
+        if (normalizedQuery && relativePathLower.endsWith(`/${normalizedQuery.toLowerCase()}`)) {
+            score += 400;
+        }
+        const queryBase = path.basename(normalizedQuery || query).toLowerCase();
+        if (queryBase && baseNameLower === queryBase) {
+            score += 180;
+        }
+        for (const token of tokens) {
+            if (baseNameLower.includes(token))
+                score += 24;
+            if (relativePathLower.includes(token))
+                score += 10;
+        }
+        return { absolutePath, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((candidate) => candidate.absolutePath);
+};
+export const clearRepoMapCache = () => {
+    cache.clear();
+};

package/dist/api/core/agent/utils/skillsDiscovery.d.ts

@@ -0,0 +1,10 @@
+export type SkillEntry = {
+    name: string;
+    description: string;
+    location: string;
+};
+/**
+ * Merge skills discovered across multiple directories.
+ * Later directories have higher precedence and override earlier ones on name conflict.
+ */
+export declare function loadSkillsFromDirectories(skillDirs: string[]): Promise<SkillEntry[]>;

package/dist/api/core/agent/utils/skillsDiscovery.js

@@ -0,0 +1,50 @@
+import fs from "fs/promises";
+import path from "path";
+const shouldLogSkillDiscoveryWarnings = process.env.IRIS_VERBOSE_SKILL_DISCOVERY === "true";
+const logSkillDiscoveryWarning = (message) => {
+    if (!shouldLogSkillDiscoveryWarnings)
+        return;
+    console.warn(message);
+};
+/**
+ * Merge skills discovered across multiple directories.
+ * Later directories have higher precedence and override earlier ones on name conflict.
+ */
+export async function loadSkillsFromDirectories(skillDirs) {
+    const skillsByName = new Map();
+    for (const skillsDir of skillDirs) {
+        try {
+            const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
+                try {
+                    const content = await fs.readFile(skillMdPath, "utf8");
+                    const nameMatch = content.match(/^name:\s*(.+)$/m);
+                    const descMatch = content.match(/^description:\s*(.+)$/m);
+                    const name = nameMatch ? nameMatch[1].trim() : entry.name;
+                    const description = descMatch
+                        ? descMatch[1].trim()
+                        : "No description available";
+                    const location = `skills/${entry.name}/SKILL.md`;
+                    if (skillsByName.has(name)) {
+                        logSkillDiscoveryWarning(`[agent] overriding duplicated skill '${name}' from higher-precedence directory: ${skillsDir}`);
+                    }
+                    skillsByName.set(name, {
+                        name,
+                        description,
+                        location: location.replace(/\\/g, "/"),
+                    });
+                }
+                catch {
+                    // skip skill if SKILL.md is unreadable
+                }
+            }
+        }
+        catch {
+            // candidate directory does not exist in this runtime mode; try next
+        }
+    }
+    return Array.from(skillsByName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/api/core/agent/utils/toolCallBudget.d.ts

@@ -0,0 +1,9 @@
+export type ToolCallBudget = {
+    limit: number;
+    admitted: number;
+    consecutiveSignature?: string;
+    consecutiveCount?: number;
+    stopReason?: "limit" | "repeated_call";
+};
+export declare const enforceToolCallBudget: <TTool>(tool: TTool, toolName?: string) => TTool;
+export declare const enforceToolCallBudgetForTools: <TTools extends Record<string, unknown>>(tools: TTools) => TTools;

package/dist/api/core/agent/utils/toolCallBudget.js

@@ -0,0 +1,55 @@
+const stableStringify = (value) => {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+};
+const MAX_CONSECUTIVE_IDENTICAL_CALLS = 3;
+const admitToolCall = (toolName, input, context) => {
+    const budget = context?.requestContext?.get("toolCallBudget");
+    if (!budget) {
+        return;
+    }
+    if (budget.admitted >= budget.limit) {
+        budget.stopReason = "limit";
+        throw new Error(`Tool call budget exhausted (${budget.limit})`);
+    }
+    budget.admitted += 1;
+    const signature = `${toolName}:${stableStringify(input)}`;
+    if (budget.consecutiveSignature === signature) {
+        budget.consecutiveCount = (budget.consecutiveCount || 1) + 1;
+    }
+    else {
+        budget.consecutiveSignature = signature;
+        budget.consecutiveCount = 1;
+    }
+    if ((budget.consecutiveCount || 0) >= MAX_CONSECUTIVE_IDENTICAL_CALLS) {
+        budget.stopReason = "repeated_call";
+    }
+};
+export const enforceToolCallBudget = (tool, toolName = "tool") => {
+    if (typeof tool !== "object" || tool === null) {
+        return tool;
+    }
+    const executableTool = tool;
+    if (typeof executableTool.execute !== "function") {
+        return tool;
+    }
+    const execute = executableTool.execute;
+    const budgetedExecute = async (input, context) => {
+        admitToolCall(toolName, input, context);
+        return execute.call(tool, input, context);
+    };
+    return new Proxy(tool, {
+        get(target, property) {
+            if (property === "execute") {
+                return budgetedExecute;
+            }
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+};
+export const enforceToolCallBudgetForTools = (tools) => Object.fromEntries(Object.entries(tools).map(([name, tool]) => [name, enforceToolCallBudget(tool, name)]));

package/dist/api/core/agent/utils/toolLifecycle.d.ts

@@ -0,0 +1,30 @@
+type ToolArgs = Record<string, unknown>;
+export type PendingToolCall = {
+    name: string;
+    args: ToolArgs;
+    toolCallId?: string;
+};
+export type ExecutedToolResult = {
+    name: string;
+    args: ToolArgs;
+    result: unknown;
+    toolCallId?: string;
+    lifecycleStepIndex?: number;
+};
+export type ToolExecutionStatus = "pending" | "in_progress" | "completed" | "failed" | "pending_confirmation" | "unknown";
+export declare const resolveToolExecutionStatus: (result: unknown) => ToolExecutionStatus;
+export declare const getToolCallSignature: (name: string, args: ToolArgs) => string;
+export declare const countUniqueToolCalls: (pendingToolCalls: Array<{
+    name: string;
+    args: ToolArgs;
+    toolCallId?: string;
+}>, executedToolResults: Array<{
+    name: string;
+    args: ToolArgs;
+    toolCallId?: string;
+}>) => number;
+export declare const normalizeToolLifecycle: (pendingToolCalls: PendingToolCall[], executedToolResults: ExecutedToolResult[]) => {
+    pendingToolCalls: PendingToolCall[];
+    executedToolResults: ExecutedToolResult[];
+};
+export {};