dominds 0.6.2 → 0.6.4

package/dist/llm/gen/codex.js

@@ -84,6 +84,43 @@ function funcToolToCodex(funcTool) {
         parameters,
     };
 }
+function resolveCodexWebSearchMode(agent) {
+    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
+    return codexParams?.web_search ?? 'live';
+}
+function buildCodexNativeTools(agent) {
+    const webSearchMode = resolveCodexWebSearchMode(agent);
+    if (webSearchMode === 'disabled')
+        return [];
+    const webSearchTool = {
+        type: 'web_search',
+        external_web_access: webSearchMode === 'live',
+    };
+    return [webSearchTool];
+}
+function assertNoCodexNativeToolCollisions(funcTools, nativeTools) {
+    const names = new Set();
+    for (const t of funcTools) {
+        names.add(t.name);
+    }
+    for (const nativeTool of nativeTools) {
+        if (nativeTool.type !== 'web_search' && nativeTool.type !== 'local_shell') {
+            continue;
+        }
+        const nativeName = nativeTool.type;
+        if (names.has(nativeName)) {
+            throw new Error(`Codex native tool name collision: function tool '${nativeName}' conflicts with native '${nativeName}' tool.`);
+        }
+    }
+}
+function toLlmWebSearchCall(item, phase) {
+    return {
+        phase,
+        itemId: item.id,
+        status: item.status,
+        action: item.action,
+    };
+}
 function messageItem(role, text) {
     const contentType = role === 'assistant' ? 'output_text' : 'input_text';
     return {
@@ -291,11 +328,14 @@ async function buildCodexRequest(agent, instructions, assistantPrelude, funcTool
             verbosity: codexParams.verbosity,
         };
     }
+    const nativeTools = buildCodexNativeTools(agent);
+    assertNoCodexNativeToolCollisions(funcTools, nativeTools);
+    const tools = [...funcTools.map(funcToolToCodex), ...nativeTools];
     return {
         model: agent.model,
         instructions,
         input,
-        tools: funcTools.map(funcToolToCodex),
+        tools,
         tool_choice: 'auto',
         parallel_tool_calls: parallelToolCalls,
         reasoning,
@@ -455,6 +495,9 @@ class CodexGen {
                         return;
                     }
                     case 'response.output_item.added':
+                        if (event.item.type === 'web_search_call' && receiver.webSearchCall) {
+                            await receiver.webSearchCall(toLlmWebSearchCall(event.item, 'added'));
+                        }
                         return;
                     case 'response.output_item.done': {
                         switch (event.item.type) {
@@ -511,11 +554,15 @@ class CodexGen {
                             case 'function_call_output':
                             case 'custom_tool_call':
                             case 'custom_tool_call_output':
-                            case 'web_search_call':
                             case 'ghost_snapshot':
                             case 'compaction':
                             case 'compaction_summary':
                                 return;
+                            case 'web_search_call':
+                                if (receiver.webSearchCall) {
+                                    await receiver.webSearchCall(toLlmWebSearchCall(event.item, 'done'));
+                                }
+                                return;
                             default: {
                                 const _exhaustive = event.item;
                                 return _exhaustive;

package/dist/log.js

@@ -17,6 +17,299 @@ const levelPriority = {
     warn: 30,
     error: 40,
 };
+const MAX_LOG_LINE_CHARS = 3 * 1024;
+const DETAIL_FALLBACK_BUDGET_CHARS = 512;
+const DETAIL_MIN_BUDGET_CHARS = 48;
+const DETAIL_INSPECT_PROFILES = [
+    {
+        maxDepth: 6,
+        maxObjectKeys: 120,
+        maxArrayItems: 160,
+        maxMapEntries: 80,
+        maxSetEntries: 80,
+        maxStringLength: 2048,
+    },
+    {
+        maxDepth: 5,
+        maxObjectKeys: 80,
+        maxArrayItems: 100,
+        maxMapEntries: 40,
+        maxSetEntries: 40,
+        maxStringLength: 1536,
+    },
+    {
+        maxDepth: 4,
+        maxObjectKeys: 50,
+        maxArrayItems: 60,
+        maxMapEntries: 24,
+        maxSetEntries: 24,
+        maxStringLength: 1024,
+    },
+    {
+        maxDepth: 3,
+        maxObjectKeys: 24,
+        maxArrayItems: 30,
+        maxMapEntries: 12,
+        maxSetEntries: 12,
+        maxStringLength: 768,
+    },
+    {
+        maxDepth: 2,
+        maxObjectKeys: 12,
+        maxArrayItems: 12,
+        maxMapEntries: 8,
+        maxSetEntries: 8,
+        maxStringLength: 512,
+    },
+    {
+        maxDepth: 1,
+        maxObjectKeys: 6,
+        maxArrayItems: 6,
+        maxMapEntries: 4,
+        maxSetEntries: 4,
+        maxStringLength: 320,
+    },
+    {
+        maxDepth: 0,
+        maxObjectKeys: 3,
+        maxArrayItems: 3,
+        maxMapEntries: 2,
+        maxSetEntries: 2,
+        maxStringLength: 192,
+    },
+];
+function truncateText(value, maxChars, suffix) {
+    if (maxChars <= 0) {
+        return { text: '', truncated: value.length > 0 };
+    }
+    if (value.length <= maxChars) {
+        return { text: value, truncated: false };
+    }
+    const rawSuffix = typeof suffix === 'string' && suffix.trim() !== ''
+        ? suffix
+        : `...[truncated ${value.length - maxChars} chars]`;
+    if (rawSuffix.length >= maxChars) {
+        return { text: rawSuffix.slice(0, maxChars), truncated: true };
+    }
+    const keepLen = maxChars - rawSuffix.length;
+    return {
+        text: `${value.slice(0, keepLen)}${rawSuffix}`,
+        truncated: true,
+    };
+}
+function appendSignalWithinBudget(value, signal, maxChars) {
+    if (maxChars <= 0)
+        return '';
+    if (signal.length >= maxChars)
+        return signal.slice(0, maxChars);
+    if (value.length + signal.length <= maxChars)
+        return `${value}${signal}`;
+    const keepLen = maxChars - signal.length;
+    return `${value.slice(0, keepLen)}${signal}`;
+}
+function getConstructorName(value) {
+    const candidate = value.constructor;
+    if (typeof candidate === 'function') {
+        const named = candidate;
+        if (typeof named.name === 'string' && named.name.trim() !== '') {
+            return named.name;
+        }
+    }
+    return 'Object';
+}
+function isDateLike(value) {
+    return value instanceof Date;
+}
+function isRegExpLike(value) {
+    return value instanceof RegExp;
+}
+function isErrorLike(value) {
+    return value instanceof Error;
+}
+function pruneForLog(value, profile, depth, seen) {
+    if (typeof value === 'string') {
+        const truncated = truncateText(value, profile.maxStringLength);
+        return { value: truncated.text, pruned: truncated.truncated };
+    }
+    if (value === null ||
+        value === undefined ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint' ||
+        typeof value === 'symbol') {
+        return { value, pruned: false };
+    }
+    if (typeof value === 'function') {
+        const fnName = value.name && value.name.trim() !== '' ? value.name : 'anonymous';
+        return { value: `[Function ${fnName}]`, pruned: false };
+    }
+    if (isDateLike(value) || isRegExpLike(value)) {
+        return { value, pruned: false };
+    }
+    if (isErrorLike(value)) {
+        const name = typeof value.name === 'string' ? value.name : 'Error';
+        const msg = typeof value.message === 'string' ? value.message : '';
+        const stack = typeof value.stack === 'string' ? value.stack : '';
+        const msgShort = truncateText(msg, profile.maxStringLength);
+        const stackShort = truncateText(stack, profile.maxStringLength);
+        const reduced = {
+            name,
+            message: msgShort.text,
+        };
+        if (stackShort.text.trim() !== '') {
+            reduced.stack = stackShort.text;
+        }
+        return { value: reduced, pruned: msgShort.truncated || stackShort.truncated };
+    }
+    if (typeof value !== 'object') {
+        return { value, pruned: false };
+    }
+    if (seen.has(value)) {
+        return { value: '[Circular]', pruned: true };
+    }
+    if (depth >= profile.maxDepth) {
+        const ctorName = getConstructorName(value);
+        return { value: `[${ctorName} depth limit reached]`, pruned: true };
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const out = [];
+            let pruned = false;
+            const limit = Math.max(0, profile.maxArrayItems);
+            const visibleCount = Math.min(value.length, limit);
+            for (let i = 0; i < visibleCount; i++) {
+                const child = pruneForLog(value[i], profile, depth + 1, seen);
+                out.push(child.value);
+                pruned = pruned || child.pruned;
+            }
+            if (value.length > visibleCount) {
+                out.push(`[+${value.length - visibleCount} more item(s)]`);
+                pruned = true;
+            }
+            return { value: out, pruned };
+        }
+        if (value instanceof Map) {
+            const entries = [];
+            let pruned = false;
+            let index = 0;
+            for (const [mapKey, mapValue] of value.entries()) {
+                if (index >= profile.maxMapEntries) {
+                    break;
+                }
+                const keyPruned = pruneForLog(mapKey, profile, depth + 1, seen);
+                const valuePruned = pruneForLog(mapValue, profile, depth + 1, seen);
+                entries.push([keyPruned.value, valuePruned.value]);
+                pruned = pruned || keyPruned.pruned || valuePruned.pruned;
+                index++;
+            }
+            const reduced = {
+                __type__: 'Map',
+                size: value.size,
+                entries,
+            };
+            if (value.size > entries.length) {
+                reduced.__omittedEntries__ = value.size - entries.length;
+                pruned = true;
+            }
+            return { value: reduced, pruned };
+        }
+        if (value instanceof Set) {
+            const entries = [];
+            let pruned = false;
+            let index = 0;
+            for (const setValue of value.values()) {
+                if (index >= profile.maxSetEntries) {
+                    break;
+                }
+                const valuePruned = pruneForLog(setValue, profile, depth + 1, seen);
+                entries.push(valuePruned.value);
+                pruned = pruned || valuePruned.pruned;
+                index++;
+            }
+            const reduced = {
+                __type__: 'Set',
+                size: value.size,
+                values: entries,
+            };
+            if (value.size > entries.length) {
+                reduced.__omittedEntries__ = value.size - entries.length;
+                pruned = true;
+            }
+            return { value: reduced, pruned };
+        }
+        if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+            if (value instanceof ArrayBuffer) {
+                return { value: `[ArrayBuffer byteLength=${value.byteLength}]`, pruned: true };
+            }
+            const typed = value;
+            const byteLen = typeof typed.byteLength === 'number' ? typed.byteLength : 0;
+            const ctorName = getConstructorName(value);
+            return { value: `[${ctorName} byteLength=${byteLen}]`, pruned: true };
+        }
+        const source = value;
+        const allKeys = Object.keys(source).sort();
+        const visibleKeys = allKeys.slice(0, profile.maxObjectKeys);
+        const ctorName = getConstructorName(value);
+        const reduced = {};
+        let pruned = false;
+        if (ctorName !== 'Object') {
+            reduced.__class__ = ctorName;
+        }
+        for (const key of visibleKeys) {
+            const child = pruneForLog(source[key], profile, depth + 1, seen);
+            reduced[key] = child.value;
+            pruned = pruned || child.pruned;
+        }
+        if (allKeys.length > visibleKeys.length) {
+            reduced.__omittedKeys__ = allKeys.length - visibleKeys.length;
+            pruned = true;
+        }
+        return { value: reduced, pruned };
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+function inspectAdaptive(value, maxChars) {
+    if (maxChars <= 0) {
+        return { text: '', truncated: true };
+    }
+    if (typeof value === 'string') {
+        return truncateText(value, maxChars);
+    }
+    let fallback = '';
+    for (let idx = 0; idx < DETAIL_INSPECT_PROFILES.length; idx++) {
+        const profile = DETAIL_INSPECT_PROFILES[idx];
+        const pruned = pruneForLog(value, profile, 0, new WeakSet());
+        const rendered = (0, util_1.inspect)(pruned.value, {
+            depth: null,
+            breakLength: 120,
+            compact: false,
+            sorted: true,
+            maxArrayLength: profile.maxArrayItems,
+            maxStringLength: profile.maxStringLength,
+        });
+        const reducedByProfile = idx > 0 || pruned.pruned;
+        const signal = reducedByProfile
+            ? ` [details_reduced depth<=${profile.maxDepth}, keys<=${profile.maxObjectKeys}, items<=${profile.maxArrayItems}]`
+            : '';
+        if (signal === '') {
+            if (rendered.length <= maxChars) {
+                return { text: rendered, truncated: false };
+            }
+            fallback = rendered;
+            continue;
+        }
+        const signaledLen = rendered.length + signal.length;
+        if (signaledLen <= maxChars) {
+            return { text: `${rendered}${signal}`, truncated: true };
+        }
+        fallback = `${rendered}${signal}`;
+    }
+    const hard = truncateText(fallback, maxChars, `...[details_truncated >${maxChars} chars after adaptive inspect]`);
+    return { text: hard.text, truncated: true };
+}
 function resolveDefaultLevel() {
     const envLevel = (process.env.DOMINDS_LOG_LEVEL || '').toLowerCase();
     if (envLevel && envLevel in levelPriority) {
@@ -37,7 +330,7 @@ function nowTsStr() {
 function inspectValue(value) {
     if (typeof value === 'string')
         return value;
-    return (0, util_1.inspect)(value, { depth: 5, breakLength: 120, compact: false, sorted: true });
+    return inspectAdaptive(value, DETAIL_FALLBACK_BUDGET_CHARS).text;
 }
 function extractErrorDetails(error) {
     if (!error)
@@ -129,7 +422,6 @@ class Logger {
     }
     formatRecord(level, message, error, extraData = []) {
         const timestamp = nowTsStr();
-        const extraEntries = extraData.map((value) => inspectValue(value));
         const record = {
             timestamp,
             level,
@@ -145,45 +437,108 @@ class Logger {
         if (error !== undefined && error !== null) {
             record.error = extractErrorDetails(error);
         }
-        if (extraEntries.length > 0) {
-            record.extra = extraEntries;
+        if (extraData.length > 0) {
+            record.extra = [...extraData];
         }
         return record;
     }
-    formatLine(record) {
-        let errorText = '';
-        if (record.error) {
-            const { name, message, stack } = record.error;
-            if (stack) {
-                // When an error object is passed, show only the stack trace to avoid duplication
-                // The log message should already contain the error description
-                errorText = `\n${stack}`;
+    formatErrorText(error, maxChars) {
+        if (maxChars <= 0) {
+            return { text: '', truncated: true };
+        }
+        if (error.stack) {
+            if (maxChars <= 1) {
+                return { text: '\n'.slice(0, maxChars), truncated: true };
             }
-            else if (message) {
-                // Fallback for error objects without stack
-                if (name && message !== name) {
-                    errorText = ` Error: ${name}: ${message}`;
-                }
-                else {
-                    errorText = ` Error: ${message}`;
-                }
+            const rendered = inspectAdaptive(error.stack, maxChars - 1);
+            return {
+                text: `\n${rendered.text}`,
+                truncated: rendered.truncated,
+            };
+        }
+        if (error.message) {
+            const head = ' Error: ';
+            if (maxChars <= head.length) {
+                return { text: truncateText(head, maxChars).text, truncated: true };
             }
-            else {
-                // Fallback to inspect for complex error objects
-                errorText = ` Error: ${inspectValue(record.error)}`;
+            const plain = error.name && error.message !== error.name
+                ? `${error.name}: ${error.message}`
+                : error.message;
+            const rendered = inspectAdaptive(plain, maxChars - head.length);
+            return {
+                text: `${head}${rendered.text}`,
+                truncated: rendered.truncated,
+            };
+        }
+        const head = ' Error: ';
+        if (maxChars <= head.length) {
+            return { text: truncateText(head, maxChars).text, truncated: true };
+        }
+        const rendered = inspectAdaptive(error, maxChars - head.length);
+        return {
+            text: `${head}${rendered.text}`,
+            truncated: rendered.truncated,
+        };
+    }
+    formatExtraText(extra, maxChars) {
+        if (maxChars <= 0) {
+            return '';
+        }
+        const head = ' Extra: ';
+        if (maxChars <= head.length) {
+            return truncateText(head, maxChars).text;
+        }
+        let remaining = maxChars - head.length;
+        let renderedEntries = '';
+        let usedCount = 0;
+        let reduced = false;
+        for (let i = 0; i < extra.length; i++) {
+            const separator = i === 0 ? '' : '; ';
+            if (remaining <= separator.length + 1) {
+                reduced = true;
+                break;
             }
+            const entriesLeft = extra.length - i;
+            const softBudget = Math.max(DETAIL_MIN_BUDGET_CHARS, Math.floor((remaining - separator.length) / entriesLeft));
+            const entryBudget = Math.max(1, Math.min(remaining - separator.length, softBudget));
+            const rendered = inspectAdaptive(extra[i], entryBudget);
+            renderedEntries += `${separator}${rendered.text}`;
+            remaining -= separator.length + rendered.text.length;
+            usedCount++;
+            reduced = reduced || rendered.truncated;
         }
-        const extraText = record.extra && record.extra.length > 0
-            ? ` Extra: ${record.extra.map((entry) => inspectValue(entry)).join('; ')}`
-            : '';
+        if (usedCount < extra.length) {
+            reduced = true;
+        }
+        if (reduced) {
+            const omittedItems = Math.max(0, extra.length - usedCount);
+            const signal = omittedItems > 0 ? ` [extra_truncated omitted_items=${omittedItems}]` : ' [extra_reduced]';
+            renderedEntries = appendSignalWithinBudget(renderedEntries, signal, maxChars - head.length);
+        }
+        return `${head}${renderedEntries}`;
+    }
+    formatLine(record) {
+        let contentPrefix = '';
         if (record.location) {
-            const prefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}\n  @ ${stripPkgPrefix(record.location.file)}:${record.location.line}:${record.location.column}`;
-            return `${prefix}\n${record.message}${errorText}${extraText}`;
+            contentPrefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}\n  @ ${stripPkgPrefix(record.location.file)}:${record.location.line}:${record.location.column}\n${record.message}`;
         }
         else {
-            const prefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}:`;
-            return `${prefix} ${record.message}${errorText}${extraText}`;
+            contentPrefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}: ${record.message}`;
+        }
+        let line = contentPrefix;
+        if (record.error) {
+            const maxForError = Math.max(0, MAX_LOG_LINE_CHARS - line.length);
+            const renderedError = this.formatErrorText(record.error, maxForError);
+            line += renderedError.text;
+        }
+        if (record.extra && record.extra.length > 0) {
+            const maxForExtra = Math.max(0, MAX_LOG_LINE_CHARS - line.length);
+            line += this.formatExtraText(record.extra, maxForExtra);
+        }
+        if (line.length > MAX_LOG_LINE_CHARS) {
+            return appendSignalWithinBudget(line, `...[log_line_truncated limit=${MAX_LOG_LINE_CHARS}]`, MAX_LOG_LINE_CHARS);
         }
+        return line;
     }
     log(level, message, error, ...extraData) {
         if (!this.shouldLog(level))