dominds 1.4.2 → 1.5.2

package/dist/llm/driver-v2-ref-only/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDriverV2RuntimeState = createDriverV2RuntimeState;
+function createDriverV2RuntimeState() {
+    return {
+        driveCount: 0,
+        totalGenIterations: 0,
+        usedLegacyDriveCore: false,
+    };
+}

package/dist/llm/gen/anthropic.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicGen = void 0;
+exports.buildAnthropicRequestMessagesWrapper = buildAnthropicRequestMessagesWrapper;
 exports.consumeAnthropicStream = consumeAnthropicStream;
 exports.reconstructAnthropicContextWrapper = reconstructAnthropicContextWrapper;
 exports.reconstructAnthropicContextWrapperAsync = reconstructAnthropicContextWrapperAsync;
@@ -14,6 +15,7 @@ const log_1 = require("../../log");
 const text_1 = require("../../shared/i18n/text");
 const runtime_language_1 = require("../../shared/runtime-language");
 const artifacts_1 = require("./artifacts");
+const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/anthropic');
 const ANTHROPIC_JSON_RESPONSE_TOOL_NAME = 'dominds_json_response';
 const ANTHROPIC_JSON_RESPONSE_TOOL_DESCRIPTION = 'Return the final answer as a JSON object. Do not include any non-JSON text.';
@@ -21,6 +23,50 @@ const ANTHROPIC_JSON_RESPONSE_TOOL_INPUT_SCHEMA = {
     type: 'object',
     additionalProperties: true,
 };
+function limitAnthropicToolOutputText(text, msg, limitChars) {
+    const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
+    if (limited.truncated) {
+        log.warn('ANTH tool output truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalChars: limited.originalChars,
+            limitChars: limited.limitChars,
+        });
+    }
+    return limited.text;
+}
+function limitAnthropicToolOutputBlocks(content, msg, limitChars) {
+    let remainingChars = limitChars;
+    let truncated = false;
+    const limited = [];
+    for (const block of content) {
+        if (block.type !== 'text') {
+            limited.push(block);
+            continue;
+        }
+        if (remainingChars <= 0) {
+            truncated = true;
+            break;
+        }
+        const next = (0, tool_output_limit_1.truncateProviderToolOutputText)(block.text, remainingChars);
+        limited.push({ type: 'text', text: next.text });
+        remainingChars -= next.text.length;
+        if (next.truncated) {
+            truncated = true;
+            break;
+        }
+    }
+    if (truncated) {
+        const originalChars = content.reduce((sum, block) => sum + (block.type === 'text' ? block.text.length : 0), 0);
+        log.warn('ANTH tool output blocks truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalTextChars: originalChars,
+            limitChars,
+        });
+    }
+    return limited;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -192,13 +238,13 @@ function normalizeToolCallPairs(context) {
     }
     return out;
 }
-async function funcResultToAnthropicToolResultBlock(chatMsg) {
+async function funcResultToAnthropicToolResultBlock(chatMsg, limitChars) {
     const items = chatMsg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return {
             type: 'tool_result',
             tool_use_id: chatMsg.id,
-            content: chatMsg.content,
+            content: limitAnthropicToolOutputText(chatMsg.content, chatMsg, limitChars),
         };
     }
     const content = [];
@@ -243,23 +289,23 @@ async function funcResultToAnthropicToolResultBlock(chatMsg) {
         return {
             type: 'tool_result',
             tool_use_id: chatMsg.id,
-            content: chatMsg.content,
+            content: limitAnthropicToolOutputText(chatMsg.content, chatMsg, limitChars),
         };
     }
     return {
         type: 'tool_result',
         tool_use_id: chatMsg.id,
-        content,
+        content: limitAnthropicToolOutputBlocks(content, chatMsg, limitChars),
     };
 }
-async function chatMessageToContentBlocksAsync(chatMsg) {
+async function chatMessageToContentBlocksAsync(chatMsg, limitChars) {
     if (chatMsg.type !== 'func_result_msg') {
         return chatMessageToContentBlocks(chatMsg);
     }
-    return [await funcResultToAnthropicToolResultBlock(chatMsg)];
+    return [await funcResultToAnthropicToolResultBlock(chatMsg, limitChars)];
 }
-async function chatMessageToAnthropicAsync(chatMsg) {
-    const contentBlocks = await chatMessageToContentBlocksAsync(chatMsg);
+async function chatMessageToAnthropicAsync(chatMsg, limitChars) {
+    const contentBlocks = await chatMessageToContentBlocksAsync(chatMsg, limitChars);
     if (contentBlocks.length === 0) {
         throw new Error(`No content blocks generated for message: ${JSON.stringify(chatMsg)}`);
     }
@@ -272,37 +318,44 @@ async function chatMessageToAnthropicAsync(chatMsg) {
         content: contentBlocks.length === 1 ? contentBlocks : contentBlocks,
     };
 }
-async function buildAnthropicRequestMessages(context) {
+async function buildAnthropicRequestMessages(context, providerConfig) {
     // We keep the async path for func_result_msg because it may contain image artifacts.
     const normalized = normalizeToolCallPairs(context);
     const messages = [];
+    const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(providerConfig);
     let lastToolUseId = null;
     for (const msg of normalized) {
         if (msg.type === 'func_call_msg') {
-            messages.push(await chatMessageToAnthropicAsync(msg));
+            messages.push(await chatMessageToAnthropicAsync(msg, toolResultMaxChars));
             lastToolUseId = msg.id;
             continue;
         }
         if (msg.type === 'func_result_msg') {
             if (lastToolUseId === msg.id) {
-                messages.push(await chatMessageToAnthropicAsync(msg));
+                messages.push(await chatMessageToAnthropicAsync(msg, toolResultMaxChars));
             }
             else {
                 messages.push({
                     role: 'user',
                     content: [
-                        { type: 'text', text: `[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}` },
+                        {
+                            type: 'text',
+                            text: limitAnthropicToolOutputText(`[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`, msg, toolResultMaxChars),
+                        },
                     ],
                 });
             }
             lastToolUseId = null;
             continue;
         }
-        messages.push(await chatMessageToAnthropicAsync(msg));
+        messages.push(await chatMessageToAnthropicAsync(msg, toolResultMaxChars));
         lastToolUseId = null;
     }
     return assembleAnthropicTurns(messages);
 }
+async function buildAnthropicRequestMessagesWrapper(context, providerConfig) {
+    return await buildAnthropicRequestMessages(context, providerConfig);
+}
 /**
  * Reconstruct Anthropic context from persisted messages.
  * Relies on natural storage order - func_result always follows func_call.
@@ -859,7 +912,7 @@ class AnthropicGen {
         if (!apiKey)
             throw new Error(`Missing API key env var ${providerConfig.apiKeyEnvVar}`);
         const client = new sdk_1.Anthropic({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestMessages = await buildAnthropicRequestMessages(context);
+        const requestMessages = await buildAnthropicRequestMessages(context, providerConfig);
         const anthropicParams = agent.model_params?.anthropic || {};
         const forceJsonResponse = resolveAnthropicJsonResponseEnabled(agent);
         const maxTokens = agent.model_params?.max_tokens;
@@ -909,7 +962,7 @@ class AnthropicGen {
         if (!apiKey)
             throw new Error(`Missing API key env var ${providerConfig.apiKeyEnvVar}`);
         const client = new sdk_1.Anthropic({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestMessages = await buildAnthropicRequestMessages(context);
+        const requestMessages = await buildAnthropicRequestMessages(context, providerConfig);
         const anthropicParams = agent.model_params?.anthropic || {};
         const forceJsonResponse = resolveAnthropicJsonResponseEnabled(agent);
         const maxTokens = agent.model_params?.max_tokens;

package/dist/llm/gen/codex.js

@@ -38,8 +38,52 @@ const log_1 = require("../../log");
 const text_1 = require("../../shared/i18n/text");
 const runtime_language_1 = require("../../shared/runtime-language");
 const artifacts_1 = require("./artifacts");
+const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/codex');
 const codexFallbackInstructions = 'You are Codex CLI.';
+function limitCodexToolOutputText(text, msg, limitChars) {
+    const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
+    if (limited.truncated) {
+        log.warn('CODEX tool output truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalChars: limited.originalChars,
+            limitChars: limited.limitChars,
+        });
+    }
+    return limited.text;
+}
+function limitCodexToolOutputItems(output, msg, limitChars) {
+    let remainingChars = limitChars;
+    let truncated = false;
+    const limited = [];
+    for (const item of output) {
+        if (item.type !== 'input_text') {
+            limited.push(item);
+            continue;
+        }
+        if (remainingChars <= 0) {
+            truncated = true;
+            break;
+        }
+        const next = (0, tool_output_limit_1.truncateProviderToolOutputText)(item.text, remainingChars);
+        limited.push({ type: 'input_text', text: next.text });
+        remainingChars -= next.text.length;
+        if (next.truncated) {
+            truncated = true;
+            break;
+        }
+    }
+    if (truncated) {
+        const originalChars = output.reduce((sum, item) => sum + (item.type === 'input_text' ? item.text.length : 0), 0);
+        log.warn('CODEX tool output items truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalTextChars: originalChars,
+        });
+    }
+    return limited;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -307,10 +351,11 @@ function normalizeToolCallPairs(context) {
     }
     return out;
 }
-async function buildCodexFunctionCallOutput(msg) {
+async function buildCodexFunctionCallOutput(msg, limitChars) {
     const items = msg.contentItems;
-    if (!Array.isArray(items) || items.length === 0)
-        return msg.content;
+    if (!Array.isArray(items) || items.length === 0) {
+        return limitCodexToolOutputText(msg.content, msg, limitChars);
+    }
     const out = [];
     for (const item of items) {
         if (item.type === 'input_text') {
@@ -344,11 +389,14 @@ async function buildCodexFunctionCallOutput(msg) {
         const _exhaustive = item;
         out.push({ type: 'input_text', text: `[unknown content item: ${String(_exhaustive)}]` });
     }
-    return out.length > 0 ? out : msg.content;
+    return out.length > 0
+        ? limitCodexToolOutputItems(out, msg, limitChars)
+        : limitCodexToolOutputText(msg.content, msg, limitChars);
 }
-async function buildCodexInput(context) {
+async function buildCodexInput(context, providerConfig) {
     const normalized = normalizeToolCallPairs(context);
     const input = [];
+    const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(providerConfig);
     let lastFuncCallId = null;
     for (const msg of normalized) {
         if (msg.type === 'func_call_msg') {
@@ -366,11 +414,11 @@ async function buildCodexInput(context) {
                 input.push({
                     type: 'function_call_output',
                     call_id: msg.id,
-                    output: await buildCodexFunctionCallOutput(msg),
+                    output: await buildCodexFunctionCallOutput(msg, toolResultMaxChars),
                 });
             }
             else {
-                input.push(messageItem('user', `[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`));
+                input.push(messageItem('user', limitCodexToolOutputText(`[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`, msg, toolResultMaxChars)));
             }
             lastFuncCallId = null;
             continue;
@@ -383,7 +431,7 @@ async function buildCodexInput(context) {
     }
     return input;
 }
-async function buildCodexRequest(agent, instructions, assistantPrelude, funcTools, context) {
+async function buildCodexRequest(providerConfig, agent, instructions, assistantPrelude, funcTools, context) {
     if (!agent.model) {
         throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
     }
@@ -392,7 +440,7 @@ async function buildCodexRequest(agent, instructions, assistantPrelude, funcTool
         // Codex backend rejects system messages; pass extra instructions as prior assistant context.
         input.push(messageItem('assistant', assistantPrelude));
     }
-    input.push(...(await buildCodexInput(context)));
+    input.push(...(await buildCodexInput(context, providerConfig)));
     const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
     let reasoning = null;
     const parallelToolCalls = codexParams?.parallel_tool_calls ?? true;
@@ -416,6 +464,7 @@ async function buildCodexRequest(agent, instructions, assistantPrelude, funcTool
         tool_choice: 'auto',
         parallel_tool_calls: parallelToolCalls,
         reasoning,
+        ...(codexParams?.service_tier !== undefined ? { service_tier: codexParams.service_tier } : {}),
         store: false,
         stream: true,
         include,
@@ -442,7 +491,7 @@ class CodexGen {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
         const resolvedInstructions = await resolveCodexInstructions(agent.model, systemPrompt, codexAuth.loadCodexPrompt);
-        const payload = await buildCodexRequest(agent, resolvedInstructions.instructions, resolvedInstructions.assistantPrelude, funcTools, context);
+        const payload = await buildCodexRequest(providerConfig, agent, resolvedInstructions.instructions, resolvedInstructions.assistantPrelude, funcTools, context);
         let sayingStarted = false;
         let thinkingStarted = false;
         let sawOutputText = false;

package/dist/llm/gen/openai-compatible.js

@@ -20,7 +20,20 @@ const log_1 = require("../../log");
 const text_1 = require("../../shared/i18n/text");
 const runtime_language_1 = require("../../shared/runtime-language");
 const artifacts_1 = require("./artifacts");
+const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/openai-compatible');
+function limitOpenAiCompatibleToolOutputText(text, msg, limitChars) {
+    const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
+    if (limited.truncated) {
+        log.warn('OPENAI-COMPATIBLE tool output truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalChars: limited.originalChars,
+            limitChars: limited.limitChars,
+        });
+    }
+    return limited.text;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -134,13 +147,23 @@ function chatMessageToChatCompletionMessage(msg) {
         }
     }
 }
-async function funcResultToChatCompletionMessages(msg) {
+async function funcResultToChatCompletionMessages(msg, limitChars) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
-        return [{ role: 'tool', tool_call_id: msg.id, content: msg.content }];
+        return [
+            {
+                role: 'tool',
+                tool_call_id: msg.id,
+                content: limitOpenAiCompatibleToolOutputText(msg.content, msg, limitChars),
+            },
+        ];
     }
     const out = [];
-    out.push({ role: 'tool', tool_call_id: msg.id, content: msg.content });
+    out.push({
+        role: 'tool',
+        tool_call_id: msg.id,
+        content: limitOpenAiCompatibleToolOutputText(msg.content, msg, limitChars),
+    });
     const parts = [];
     let sawImageUrl = false;
     let sawAnyImage = false;
@@ -203,20 +226,20 @@ async function funcResultToChatCompletionMessages(msg) {
     }
     return out;
 }
-async function orphanedFuncResultToChatCompletionMessages(msg) {
+async function orphanedFuncResultToChatCompletionMessages(msg, limitChars) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return [
             {
                 role: 'user',
-                content: `[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`,
+                content: limitOpenAiCompatibleToolOutputText(`[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`, msg, limitChars),
             },
         ];
     }
     const parts = [
         {
             type: 'text',
-            text: `[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`,
+            text: limitOpenAiCompatibleToolOutputText(`[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`, msg, limitChars),
         },
     ];
     let sawImageUrl = false;
@@ -267,7 +290,9 @@ async function orphanedFuncResultToChatCompletionMessages(msg) {
             .trim();
         return [{ role: 'user', content: text }];
     }
-    return [{ role: 'user', content: msg.content }];
+    return [
+        { role: 'user', content: limitOpenAiCompatibleToolOutputText(msg.content, msg, limitChars) },
+    ];
 }
 function normalizeToolCallPairs(context) {
     // Providers differ in how strictly they validate tool call/result ordering. Many
@@ -364,6 +389,7 @@ async function buildChatCompletionMessages(systemPrompt, context, options) {
     const normalized = normalizeToolCallPairs(context);
     const input = [];
     const reasoningContentMode = options?.reasoningContentMode === true;
+    const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(options?.providerConfig);
     let pendingReasoningContent;
     const takePendingReasoningContent = () => {
         const current = pendingReasoningContent;
@@ -408,11 +434,11 @@ async function buildChatCompletionMessages(systemPrompt, context, options) {
             // tool call. If it doesn't, downgrade to a plain text message so the request remains valid.
             if (lastFuncCallId === msg.id) {
                 flushPendingReasoningAsAssistantMessage();
-                input.push(...(await funcResultToChatCompletionMessages(msg)));
+                input.push(...(await funcResultToChatCompletionMessages(msg, toolResultMaxChars)));
             }
             else {
                 flushPendingReasoningAsAssistantMessage();
-                input.push(...(await orphanedFuncResultToChatCompletionMessages(msg)));
+                input.push(...(await orphanedFuncResultToChatCompletionMessages(msg, toolResultMaxChars)));
             }
             lastFuncCallId = null;
             continue;
@@ -518,6 +544,7 @@ class OpenAiCompatibleGen {
         const reasoningContentMode = resolveOpenAiCompatibleReasoningContentMode(providerConfig, agent);
         const messages = await buildChatCompletionMessages(systemPrompt, context, {
             reasoningContentMode,
+            providerConfig,
         });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
@@ -532,6 +559,7 @@ class OpenAiCompatibleGen {
             messages,
             stream: true,
             stream_options: { include_usage: true },
+            ...(openAiParams.service_tier !== undefined && { service_tier: openAiParams.service_tier }),
             ...(openAiParams.temperature !== undefined && { temperature: openAiParams.temperature }),
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...(openAiParams.stop !== undefined && { stop: openAiParams.stop }),
@@ -720,6 +748,7 @@ class OpenAiCompatibleGen {
         const reasoningContentMode = resolveOpenAiCompatibleReasoningContentMode(providerConfig, agent);
         const messages = await buildChatCompletionMessages(systemPrompt, context, {
             reasoningContentMode,
+            providerConfig,
         });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;

package/dist/llm/gen/openai.js

@@ -15,7 +15,51 @@ const log_1 = require("../../log");
 const text_1 = require("../../shared/i18n/text");
 const runtime_language_1 = require("../../shared/runtime-language");
 const artifacts_1 = require("./artifacts");
+const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/openai');
+function limitOpenAiToolOutputText(text, msg, limitChars) {
+    const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
+    if (limited.truncated) {
+        log.warn('OPENAI tool output truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalChars: limited.originalChars,
+            limitChars: limited.limitChars,
+        });
+    }
+    return limited.text;
+}
+function limitOpenAiToolOutputItems(output, msg, limitChars) {
+    let remainingChars = limitChars;
+    let truncated = false;
+    const limited = [];
+    for (const item of output) {
+        if (item.type !== 'input_text') {
+            limited.push(item);
+            continue;
+        }
+        if (remainingChars <= 0) {
+            truncated = true;
+            break;
+        }
+        const next = (0, tool_output_limit_1.truncateProviderToolOutputText)(item.text, remainingChars);
+        limited.push({ type: 'input_text', text: next.text });
+        remainingChars -= next.text.length;
+        if (next.truncated) {
+            truncated = true;
+            break;
+        }
+    }
+    if (truncated) {
+        const originalChars = output.reduce((sum, item) => sum + (item.type === 'input_text' ? item.text.length : 0), 0);
+        log.warn('OPENAI tool output items truncated before provider request', undefined, {
+            callId: msg.id,
+            toolName: msg.name,
+            originalTextChars: originalChars,
+        });
+    }
+    return limited;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -139,13 +183,13 @@ function thinkingMessageToOpenAiReasoningItem(msg) {
     }
     return out;
 }
-async function funcResultToOpenAiInputItem(msg) {
+async function funcResultToOpenAiInputItemWithLimit(msg, limitChars) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return {
             type: 'function_call_output',
             call_id: msg.id,
-            output: msg.content,
+            output: limitOpenAiToolOutputText(msg.content, msg, limitChars),
         };
     }
     const output = [];
@@ -189,13 +233,13 @@ async function funcResultToOpenAiInputItem(msg) {
         return {
             type: 'function_call_output',
             call_id: msg.id,
-            output: msg.content,
+            output: limitOpenAiToolOutputText(msg.content, msg, limitChars),
         };
     }
     return {
         type: 'function_call_output',
         call_id: msg.id,
-        output,
+        output: limitOpenAiToolOutputItems(output, msg, limitChars),
     };
 }
 function normalizeToolCallPairs(context) {
@@ -284,9 +328,10 @@ function mergeAdjacentOpenAiMessages(input) {
     }
     return merged;
 }
-async function buildOpenAiRequestInput(context) {
+async function buildOpenAiRequestInput(context, providerConfig) {
     const normalized = normalizeToolCallPairs(context);
     const input = [];
+    const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(providerConfig);
     let lastFuncCallId = null;
     for (const msg of normalized) {
         if (msg.type === 'func_call_msg') {
@@ -298,13 +343,13 @@ async function buildOpenAiRequestInput(context) {
             // Many OpenAI-compatible providers require the tool result to directly follow the matching
             // tool call. If it doesn't, downgrade to a plain text message so the request remains valid.
             if (lastFuncCallId === msg.id) {
-                input.push(await funcResultToOpenAiInputItem(msg));
+                input.push(await funcResultToOpenAiInputItemWithLimit(msg, toolResultMaxChars));
             }
             else {
                 input.push({
                     type: 'message',
                     role: 'user',
-                    content: `[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`,
+                    content: limitOpenAiToolOutputText(`[orphaned_tool_output:${msg.name}:${msg.id}] ${msg.content}`, msg, toolResultMaxChars),
                 });
             }
             lastFuncCallId = null;
@@ -349,8 +394,8 @@ function resolveOpenAiJsonResponseEnabled(agent, openAiParams) {
         return openAiParams.json_response;
     return agent.model_params?.json_response === true;
 }
-async function buildOpenAiRequestInputWrapper(context) {
-    return await buildOpenAiRequestInput(context);
+async function buildOpenAiRequestInputWrapper(context, providerConfig) {
+    return await buildOpenAiRequestInput(context, providerConfig);
 }
 function extractOutputMessageText(item) {
     if (!isRecord(item) || item.type !== 'message')
@@ -484,7 +529,7 @@ class OpenAiGen {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestInput = await buildOpenAiRequestInput(context);
+        const requestInput = await buildOpenAiRequestInput(context, providerConfig);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
         const jsonResponseEnabled = resolveOpenAiJsonResponseEnabled(agent, openAiParams);
@@ -501,6 +546,7 @@ class OpenAiGen {
             parallel_tool_calls: parallelToolCalls,
             store: false,
             stream: true,
+            ...(openAiParams.service_tier !== undefined && { service_tier: openAiParams.service_tier }),
             ...(openAiParams.temperature !== undefined && { temperature: openAiParams.temperature }),
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...(openAiParams.reasoning_effort !== undefined && {
@@ -938,7 +984,7 @@ class OpenAiGen {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestInput = await buildOpenAiRequestInput(context);
+        const requestInput = await buildOpenAiRequestInput(context, providerConfig);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
         const jsonResponseEnabled = resolveOpenAiJsonResponseEnabled(agent, openAiParams);
@@ -955,6 +1001,7 @@ class OpenAiGen {
             parallel_tool_calls: parallelToolCalls,
             store: false,
             stream: false,
+            ...(openAiParams.service_tier !== undefined && { service_tier: openAiParams.service_tier }),
             ...(openAiParams.temperature !== undefined && { temperature: openAiParams.temperature }),
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...(openAiParams.reasoning_effort !== undefined && {

package/dist/llm/gen/tool-output-limit.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProviderToolResultMaxChars = resolveProviderToolResultMaxChars;
+exports.truncateProviderToolOutputText = truncateProviderToolOutputText;
+const DEFAULT_PROVIDER_TOOL_OUTPUT_CHAR_LIMITS = {
+    codex: 8 * 1024 * 1024,
+    openai: 8 * 1024 * 1024,
+    'openai-compatible': 4 * 1024 * 1024,
+    anthropic: 4 * 1024 * 1024,
+    mock: 8 * 1024 * 1024,
+};
+function buildProviderToolOutputSuffix(originalChars, limitChars) {
+    return `\n[tool_output_truncated_for_provider original_chars=${originalChars} limit_chars=${limitChars}]`;
+}
+function resolveProviderToolResultMaxChars(providerConfig) {
+    const configured = providerConfig?.tool_result_max_chars;
+    if (typeof configured === 'number' && Number.isInteger(configured) && configured > 0) {
+        return configured;
+    }
+    if (!providerConfig) {
+        return DEFAULT_PROVIDER_TOOL_OUTPUT_CHAR_LIMITS['openai'];
+    }
+    return DEFAULT_PROVIDER_TOOL_OUTPUT_CHAR_LIMITS[providerConfig.apiType];
+}
+function truncateProviderToolOutputText(text, limitChars = DEFAULT_PROVIDER_TOOL_OUTPUT_CHAR_LIMITS['openai']) {
+    if (text.length <= limitChars) {
+        return {
+            text,
+            truncated: false,
+            originalChars: text.length,
+            limitChars,
+        };
+    }
+    const suffix = buildProviderToolOutputSuffix(text.length, limitChars);
+    if (suffix.length >= limitChars) {
+        return {
+            text: suffix.slice(0, limitChars),
+            truncated: true,
+            originalChars: text.length,
+            limitChars,
+        };
+    }
+    const keepChars = limitChars - suffix.length;
+    return {
+        text: `${text.slice(0, keepChars)}${suffix}`,
+        truncated: true,
+        originalChars: text.length,
+        limitChars,
+    };
+}