dominds 1.13.2 → 1.15.2

package/dist/recovery/reply-special.js

@@ -55,8 +55,8 @@ async function dialogNeedsReplyRecovery(dialogId) {
     const events = await persistence_1.DialogPersistence.loadCourseEvents(dialogId, currentCourse, 'running');
     const funcResultIds = new Set();
     for (const event of events) {
-        if (event.type === 'func_result_record') {
-            const callId = event.id.trim();
+        if (event.type === 'func_result_record' || event.type === 'tellask_result_record') {
+            const callId = event.type === 'func_result_record' ? event.id.trim() : event.callId.trim();
             if (callId !== '') {
                 funcResultIds.add(callId);
             }
@@ -64,7 +64,7 @@ async function dialogNeedsReplyRecovery(dialogId) {
         }
     }
     return events.some((event) => {
-        if (event.type !== 'tellask_special_call_record') {
+        if (event.type !== 'tellask_call_record') {
             return false;
         }
         if (event.name !== 'replyTellask' &&

package/dist/runtime/inter-dialog-format.d.ts

@@ -60,7 +60,7 @@ export type TellaskReplacementNoticeFormatInput = {
 };
 export type TellaskCarryoverResultFormatInput = {
     originCourse: number;
-    callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
+    callName: 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning';
     responderId: string;
     mentionList?: string[];
     sessionSlug?: string;

package/dist/runtime/inter-dialog-format.js

@@ -367,7 +367,7 @@ function formatTellaskCarryoverResultContent(input) {
         '',
         (0, markdown_format_1.markdownQuote)(responseBody),
         '',
-        'Note: this is not a new user request or a newly initiated function call in the current course; it is the asynchronous completion of an older pending tellask.',
+        'Note: this is not a new user request or a newly initiated function call in the current course; it is the canonical current-course carryover of an older pending tellask completion.',
         '',
     ];
     return lines.join('\n');

package/dist/runtime/reply-prompt-copy.js

@@ -68,8 +68,8 @@ function buildSubdialogRoleHeaderCopy(args) {
     const requester = `@${args.requesterId}`;
     if (args.expectedReplyTool === undefined) {
         return args.language === 'zh'
-            ? `${requester} 的诉请已交给你处理。只有需要回问时，才调用 \`tellaskBack\`。`
-            : `You are handling ${requester}'s request. Call \`tellaskBack\` only when you truly need to ask back.`;
+            ? `${requester} 已通过诉请安排你处理下述诉请内容。只有需要回问时，才调用 \`tellaskBack\`。`
+            : `${requester} has assigned you to handle the request content below. Call \`tellaskBack\` only when you truly need to ask back.`;
     }
     const kindLabel = (0, tellask_labels_1.getTellaskKindLabel)({
         language: args.language,
@@ -77,8 +77,8 @@ function buildSubdialogRoleHeaderCopy(args) {
         bracketed: true,
     });
     return args.language === 'zh'
-        ? `${requester} 的${kindLabel}已交给你处理。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有需要回问时，才调用 \`tellaskBack\`。`
-        : `${requester}'s ${kindLabel} is now assigned to you. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask back.`;
+        ? `${requester} 已通过${kindLabel}安排你处理下述诉请内容。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有需要回问时，才调用 \`tellaskBack\`。`
+        : `${requester} has assigned you, via this ${kindLabel}, to handle the request content below. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask back.`;
 }
 function buildReplyObligationSuppressionGuideText(language) {
     if (language === 'zh') {

package/dist/server/setup-routes.js

@@ -61,7 +61,8 @@ async function buildSetupStatusResponse() {
             error: builtin.errorText,
         };
     }
-    const providers = await buildProviderSummaries(builtin.providers, builtin.providerKeysInOrder, {
+    const providerKeysInOrder = mergeProviderKeysInOrder(rtwsLlmYaml.providerKeys ?? [], builtin.providerKeysInOrder, merged.providers);
+    const providers = await buildProviderSummaries(merged.providers, providerKeysInOrder, {
         envLocalPath: RTWS_ENV_LOCAL_PATH,
         bashrcPath,
         zshrcPath,
@@ -265,7 +266,7 @@ async function loadBuiltinProviders() {
         if (!isRecord(parsed) || !isRecord(parsed.providers)) {
             return { kind: 'error', errorText: 'Invalid defaults.yaml: expected providers object' };
         }
-        const providerKeysInOrder = extractProvidersKeysFromDefaultsYamlDoc(doc);
+        const providerKeysInOrder = extractProvidersKeysFromYamlDoc(doc);
         return {
             kind: 'ok',
             providers: parsed.providers,
@@ -415,6 +416,25 @@ function orderedProviderEntries(providers, providerKeysInOrder) {
     }
     return out;
 }
+function mergeProviderKeysInOrder(preferredProviderKeysInOrder, secondaryProviderKeysInOrder, providers) {
+    const out = [];
+    const seen = new Set();
+    const appendKey = (providerKey) => {
+        if (providerKey === '' || seen.has(providerKey))
+            return;
+        if (!Object.prototype.hasOwnProperty.call(providers, providerKey))
+            return;
+        out.push(providerKey);
+        seen.add(providerKey);
+    };
+    for (const providerKey of preferredProviderKeysInOrder)
+        appendKey(providerKey);
+    for (const providerKey of secondaryProviderKeysInOrder)
+        appendKey(providerKey);
+    for (const providerKey of Object.keys(providers))
+        appendKey(providerKey);
+    return out;
+}
 function extractYamlMapStringKeys(value) {
     if (!yaml_1.default.isMap(value))
         return [];
@@ -432,7 +452,7 @@ function extractYamlMapStringKeys(value) {
     }
     return out;
 }
-function extractProvidersKeysFromDefaultsYamlDoc(doc) {
+function extractProvidersKeysFromYamlDoc(doc) {
     const root = doc.contents;
     if (!yaml_1.default.isMap(root))
         return [];
@@ -494,7 +514,8 @@ async function readRtwsLlmYamlProviderKeys() {
         return { path: RTWS_LLM_YAML_PATH, exists: false };
     try {
         const raw = await promises_1.default.readFile(RTWS_LLM_YAML_PATH, 'utf-8');
-        const parsed = yaml_1.default.parse(raw);
+        const doc = yaml_1.default.parseDocument(raw);
+        const parsed = doc.toJS();
         if (!isRecord(parsed)) {
             return {
                 path: RTWS_LLM_YAML_PATH,
@@ -513,7 +534,7 @@ async function readRtwsLlmYamlProviderKeys() {
         return {
             path: RTWS_LLM_YAML_PATH,
             exists: true,
-            providerKeys: Object.keys(providersUnknown).sort(),
+            providerKeys: extractProvidersKeysFromYamlDoc(doc),
         };
     }
     catch (error) {

package/dist/server/snippets-routes.d.ts

@@ -1,4 +1,5 @@
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+import '../tools/builtins';
 type SnippetTemplateSource = 'builtin' | 'rtws';
 type SnippetTemplate = {
     id: string;

package/dist/server/snippets-routes.js

@@ -46,6 +46,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const log_1 = require("../log");
+require("../tools/builtins");
 const log = (0, log_1.createLogger)('snippets-routes');
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -643,14 +644,7 @@ async function handleToolsetManual(rawBody) {
     if (!req)
         return { success: false, error: 'Invalid request body' };
     try {
-        const { getTool } = await Promise.resolve().then(() => __importStar(require('../tools/registry')));
-        const tool = getTool('man');
-        if (!tool || tool.type !== 'func') {
-            return { success: false, error: 'man tool not available' };
-        }
-        const fakeDlg = {
-            getLastUserLanguageCode: () => req.uiLanguage,
-        };
+        const { renderToolsetManualContent } = await Promise.resolve().then(() => __importStar(require('../tools/toolset-manual')));
         const { Team } = await Promise.resolve().then(() => __importStar(require('../team')));
         const caller = new Team.Member({
             id: 'webui',
@@ -659,10 +653,27 @@ async function handleToolsetManual(rawBody) {
             write_dirs: ['.minds/**'],
             toolsets: [req.toolsetId],
         });
-        const markdown = await tool.call(fakeDlg, caller, {
+        const dynamicToolsetNames = await Team.listDynamicToolsetNamesForMember({
+            member: caller,
+        });
+        const declaredMcpToolsets = await Team.readMcpDeclaredToolsets();
+        const declaredMcpToolsetNames = declaredMcpToolsets.kind === 'loaded' ? declaredMcpToolsets.declaredServerIds : undefined;
+        const invalidMcpToolsetNames = declaredMcpToolsets.kind === 'loaded' ? declaredMcpToolsets.invalidServerIds : undefined;
+        const availableToolNames = new Set(caller
+            .listTools({
+            onMissingToolset: 'silent',
+            onMissingTool: 'silent',
+            dynamicToolsetNames,
+            declaredMcpToolsetNames,
+            invalidMcpToolsetNames,
+        })
+            .map((tool) => tool.name));
+        const markdown = await renderToolsetManualContent({
             toolsetId: req.toolsetId,
+            language: req.uiLanguage,
             ...(req.topic ? { topic: req.topic } : {}),
             ...(req.topics ? { topics: req.topics } : {}),
+            availableToolNames,
         });
         return { success: true, markdown: String(markdown) };
     }

package/dist/server/websocket-handler.js

@@ -11,9 +11,11 @@ exports.cleanupEventSystems = cleanupEventSystems;
 const diligence_1 = require("@longrun-ai/kernel/diligence");
 const evt_1 = require("@longrun-ai/kernel/evt");
 const language_1 = require("@longrun-ai/kernel/types/language");
+const storage_1 = require("@longrun-ai/kernel/types/storage");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const ws_1 = require("ws");
 const runtime_1 = require("../apps/runtime");
+const global_dialog_event_broadcaster_1 = require("../bootstrap/global-dialog-event-broadcaster");
 const dialog_1 = require("../dialog");
 const dialog_display_state_1 = require("../dialog-display-state");
 const dialog_global_registry_1 = require("../dialog-global-registry");
@@ -27,6 +29,7 @@ const priming_1 = require("../priming");
 const problems_1 = require("../problems");
 const reply_special_1 = require("../recovery/reply-special");
 const driver_messages_1 = require("../runtime/driver-messages");
+const inter_dialog_format_1 = require("../runtime/inter-dialog-format");
 const work_language_1 = require("../runtime/work-language");
 const team_1 = require("../team");
 const team_config_updates_1 = require("../team-config-updates");
@@ -261,7 +264,7 @@ async function handleWebSocketMessage(ws, packet) {
                 await handleUserMsg2Dlg(ws, packet);
                 break;
             case 'drive_dialog_by_user_answer':
-                await handleUserAnswer2Q4H(ws, packet);
+                await handleReceiveHumanReply(ws, packet);
                 break;
             case 'interrupt_dialog':
                 await handleInterruptDialog(ws, packet);
@@ -861,7 +864,6 @@ async function handleDisplayDialog(ws, packet) {
                     tellaskContent: q.tellaskContent,
                     askedAt: q.askedAt,
                     callId: q.callId,
-                    remainingCallIds: q.remainingCallIds,
                     callSiteRef: q.callSiteRef,
                 })),
             };
@@ -903,7 +905,6 @@ async function handleGetQ4HState(ws, _packet) {
             tellaskContent: q.tellaskContent,
             askedAt: q.askedAt,
             callId: q.callId,
-            remainingCallIds: q.remainingCallIds,
             callSiteRef: q.callSiteRef,
         }));
         // Send single response packet with all questions (not PubChan events)
@@ -1213,10 +1214,17 @@ async function handleResumeAll(ws, packet) {
     emitRunControlRefresh('resume_all');
 }
 /**
- * Handle user answer to a Q4H (Questions for Human) question
- * Validates questionId, clears q4h.yaml entry, and resumes dialog with user's answer
+ * Receive a human reply for a Q4H question.
+ * Validates questionId, clears q4h.yaml entry, records askHuman result/carryover,
+ * and optionally queues a continuation drive input carrying the answered callId.
+ *
+ * Important: the human answer itself is canonicalized as askHuman tellask result/carryover first.
+ * For cross-course Q4H answers, the carryover is the canonical latest-course context; it is not a
+ * tool-result pair for the older-course askHuman call.
+ * The follow-up drive input here is only control-flow glue for the resumed round, not a separate
+ * persisted "user prompt" business fact.
  */
-async function handleUserAnswer2Q4H(ws, packet) {
+async function handleReceiveHumanReply(ws, packet) {
     try {
         const { dialog: dialogIdent, content, msgId, questionId, continuationType } = packet;
         const userLanguageCode = resolveUserLanguageCode(ws, packet.userLanguageCode);
@@ -1235,7 +1243,7 @@ async function handleUserAnswer2Q4H(ws, packet) {
         if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
             ws.send(JSON.stringify({
                 type: 'error',
-                message: 'Invalid dialog identifiers for drive_dialog_by_user_answer: selfId/rootId must be strings',
+                message: 'Invalid dialog identifiers for receiveHumanReply: selfId/rootId must be strings',
             }));
             return;
         }
@@ -1282,12 +1290,30 @@ async function handleUserAnswer2Q4H(ws, packet) {
         if (!removedQuestion) {
             throw new Error(`Q4H remove invariant violation: found=true but removedQuestion missing (rootId=${dialog.id.rootId} selfId=${dialog.id.selfId} questionId=${questionId})`);
         }
-        const askHumanCallIds = Array.from(new Set([removedQuestion.callId, ...(removedQuestion.remainingCallIds ?? [])]
-            .map((value) => (typeof value === 'string' ? value.trim() : ''))
-            .filter((value) => value !== '')));
-        for (const callId of askHumanCallIds) {
-            await dialog.receiveTellaskCallResult('human', 'askHuman', undefined, removedQuestion.tellaskContent, effectivePrompt.content, 'completed', callId);
-        }
+        const askHumanCallId = removedQuestion.callId.trim();
+        if (askHumanCallId === '') {
+            throw new Error(`Q4H remove invariant violation: missing callId on answered question ` +
+                `(rootId=${dialog.id.rootId} selfId=${dialog.id.selfId} questionId=${questionId})`);
+        }
+        const askHumanOriginCourse = removedQuestion.callSiteRef.course;
+        const askHumanCarryoverContent = (0, inter_dialog_format_1.formatTellaskCarryoverResultContent)({
+            originCourse: askHumanOriginCourse,
+            callName: 'askHuman',
+            responderId: 'human',
+            tellaskContent: removedQuestion.tellaskContent,
+            responseBody: effectivePrompt.content,
+            status: 'completed',
+            language: (0, work_language_1.getWorkLanguage)(),
+        });
+        const askHumanResultMirror = await dialog.receiveTellaskResponse('human', 'askHuman', undefined, removedQuestion.tellaskContent, 'completed', undefined, {
+            response: effectivePrompt.content,
+            agentId: 'human',
+            callId: askHumanCallId,
+            originMemberId: dialog.agentId,
+            originCourse: (0, storage_1.toCallingCourseNumber)(askHumanOriginCourse),
+            carryoverContent: askHumanCarryoverContent,
+        });
+        await dialog.addChatMessages(askHumanResultMirror);
         // Emit q4h_answered event for answered question
         const answeredEvent = {
             type: 'q4h_answered',
@@ -1297,14 +1323,17 @@ async function handleUserAnswer2Q4H(ws, packet) {
         (0, evt_registry_1.postDialogEvent)(dialog, answeredEvent);
         const hasPendingSubdialogs = await dialog.hasPendingSubdialogs();
         if (hasPendingSubdialogs) {
+            // This queued item is only the post-answer continuation input that resumes the suspended
+            // round after subdialogs settle. The human answer fact has already been persisted above as
+            // askHuman tellask result/carryover and must not be reinterpreted as a new user prompt.
             dialog.queueDeferredQ4HAnswerPrompt({
                 prompt: effectivePrompt.content,
                 msgId: effectivePrompt.msgId,
                 grammar: effectivePrompt.grammar,
                 userLanguageCode: effectivePrompt.userLanguageCode,
-                q4hAnswerCallIds: askHumanCallIds,
+                q4hAnswerCallId: askHumanCallId,
             });
-            log.debug('Deferred Q4H answer until pending subdialogs resolve', undefined, {
+            log.debug('Deferred post-Q4H continuation input until pending subdialogs resolve', undefined, {
                 rootId: dialog.id.rootId,
                 selfId: dialog.id.selfId,
                 questionId,
@@ -1312,13 +1341,14 @@ async function handleUserAnswer2Q4H(ws, packet) {
             });
             return;
         }
-        // Resume the dialog with the user's answer.
+        // Resume the dialog after the answer has been materialized as askHuman tellask result/carryover.
+        // The continuation input carries correlation only; it does not persist another user prompt fact.
         await (0, kernel_driver_1.driveDialogStream)(dialog, {
             content: effectivePrompt.content,
             msgId: effectivePrompt.msgId,
             grammar: effectivePrompt.grammar,
             userLanguageCode: effectivePrompt.userLanguageCode,
-            q4hAnswerCallIds: askHumanCallIds,
+            q4hAnswerCallId: askHumanCallId,
             origin: 'user',
         }, true, {
             source: 'ws_user_answer',
@@ -1326,10 +1356,10 @@ async function handleUserAnswer2Q4H(ws, packet) {
         });
     }
     catch (error) {
-        log.error('Error processing Q4H user answer:', error);
+        log.error('Error processing receiveHumanReply:', error);
         ws.send(JSON.stringify({
             type: 'error',
-            message: `Failed to process Q4H answer: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            message: `Failed to process human reply: ${error instanceof Error ? error.message : 'Unknown error'}`,
         }));
     }
 }
@@ -1351,13 +1381,16 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage) {
     // - Q4H updates are rtws-global state in WebUI
     // - subdialog creation must refresh hierarchy/list even when current subscription is elsewhere
     // - dlg_touched_evt keeps dialog list timestamps/reordering in sync across clients
-    (0, evt_registry_1.setGlobalDialogEventBroadcaster)((evt) => {
-        const data = JSON.stringify(evt);
-        for (const ws of clients) {
-            if (ws.readyState === 1) {
-                ws.send(data);
+    (0, global_dialog_event_broadcaster_1.installGlobalDialogEventBroadcaster)({
+        label: 'websocket-server',
+        publish: (evt) => {
+            const data = JSON.stringify(evt);
+            for (const ws of clients) {
+                if (ws.readyState === 1) {
+                    ws.send(data);
+                }
             }
-        }
+        },
     });
     // Broadcast dialog index changes (create/move/delete) so other tabs refresh their lists.
     // This ensures multi-tab/multi-browser updates stay consistent without polling.

package/dist/shared/utils/fbr.js

@@ -15,20 +15,24 @@ function appendDistinctPerspectiveFbrBody(input) {
         if (input.language === 'zh') {
             return [
                 iteration === 1
-                    ? `【第 ${iteration}/${total} 轮 FBR】请开启首轮独立推理角度。`
-                    : `【第 ${iteration}/${total} 轮 FBR】请切换到与前 ${iteration - 1} 轮不同的推理角度。`,
+                    ? `【第 ${iteration}/${total} 轮 FBR 发散】请开启首轮独立推理角度。`
+                    : `【第 ${iteration}/${total} 轮 FBR 发散】请切换到与前 ${iteration - 1} 轮不同的推理角度。`,
+                '这一阶段要对反直觉、离谱、少数派、最后可能被淘汰的想法保持开放，把它们先当作待检验候选，而不是急着压成共识。',
                 isFinalRound
-                    ? '最后一轮也不能复述前文结论，必须补充新的切入点与新增证据。'
-                    : '要求：不复述上一轮已结论文本，补充本轮独立切入点与未覆盖证据。',
+                    ? '最后一轮发散也不能复述前文结论；必须继续补充新的切入点、额外证据或新的解释路径。'
+                    : '要求：不复述前几轮已结论文本；补充本轮独立切入点、未覆盖证据或新的解释路径。',
+                '此时不要急于收敛或下最终结论。',
             ].join('\n');
         }
         return [
             iteration === 1
-                ? `[FBR round ${iteration}/${total}] start with a first independent reasoning angle.`
-                : `[FBR round ${iteration}/${total}] switch to an angle different from the previous ${iteration - 1} rounds.`,
+                ? `[FBR divergence round ${iteration}/${total}] start with a first independent reasoning angle.`
+                : `[FBR divergence round ${iteration}/${total}] switch to an angle different from the previous ${iteration - 1} rounds.`,
+            'In this phase, stay open to counterintuitive, wild, minority, or eventually-discarded ideas; treat them as candidates to test instead of forcing early consensus.',
             isFinalRound
-                ? 'The final round must also avoid repeating prior-round conclusions and provide new angles and additional evidence.'
-                : 'Requirement: do not repeat prior-round conclusion text; add a distinct independent approach and missing evidence.',
+                ? 'The final divergence round must still avoid repeating prior-round conclusions and add new angles, extra evidence, or alternative explanations.'
+                : 'Requirement: do not repeat prior-round conclusion text; add a distinct approach, missing evidence, or a genuinely new explanatory path.',
+            'Do not converge or produce a final conclusion yet.',
         ].join('\n');
     })();
     if (iteration <= 1) {

package/dist/shared/utils/inter-dialog-format.js

@@ -111,9 +111,10 @@ function formatAssignmentFromSupdialog(input) {
                 '# 扪心自问（FBR）自诉请',
                 '',
                 '- 约束：这是一个扪心自问（self tellask）支线对话；请独立推理与总结。',
-                '- 系统规则：本支线对话为函数禁用模式，不允许任何函数调用（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
+                '- 系统规则：当前仍处于 FBR 的无工具阶段；这一阶段不允许任何函数调用。',
+                '- 后续只有在完成既定的发散轮与收敛轮之后，运行时才会开放两个“结论函数”供你正式收口。',
                 '- 协议：回贴标记由 Dominds 运行时自动注入，禁止手写。',
-                '- 系统提示：不要受诉请正文中的定调、分析方向或维度清单约束；请聚焦总体目标，自由发挥并开辟新的分析切入角度。',
+                '- 系统提示：不要受诉请正文中的定调、分析方向或维度清单约束；请聚焦总体目标，自由发挥并开辟新的分析切入角度，对离谱想法保持开放，但不要过早收敛。',
                 '',
                 '---',
             ].join('\n')
@@ -121,9 +122,10 @@ function formatAssignmentFromSupdialog(input) {
                 '# Fresh Boots Reasoning (FBR) request',
                 '',
                 '- Constraint: this is a self-tellask FBR sideline dialog; reason independently and produce conclusions.',
-                '- System rule: this sideline runs with function-calls disabled; do not emit any function call (including `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
+                '- System rule: this FBR stage is still tool-less; do not emit any function call in this stage.',
+                '- Only after the planned divergence and convergence rounds are complete will runtime expose the two conclusion functions for formal closure.',
                 '- Protocol: reply markers are auto-injected by Dominds runtime; do not hand-write markers.',
-                '- System prompt: do not be constrained by framing, analysis directions, or dimension checklists embedded in the tellask body; stay focused on the overall objective and open new analytical entry points freely.',
+                '- System prompt: do not be constrained by framing, analysis directions, or dimension checklists embedded in the tellask body; stay focused on the overall objective, open new analytical entry points freely, stay open to wild ideas, and do not converge too early.',
                 '',
                 '---',
             ].join('\n');

package/dist/team.d.ts

@@ -26,19 +26,11 @@ export declare namespace Team {
     };
     export function readMcpDeclaredToolsets(): Promise<McpDeclaredToolsets>;
     export function listExplicitToolsets(member: Team.Member): string[];
-    type OpenAiStyleModelParams = {
+    type CodexModelParams = {
         temperature?: number;
         max_tokens?: number;
         service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
         top_p?: number;
-        frequency_penalty?: number;
-        presence_penalty?: number;
-        seed?: number;
-        logprobs?: boolean;
-        top_logprobs?: number;
-        stop?: string | string[];
-        logit_bias?: Record<string, number>;
-        user?: string;
         reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
         reasoning_summary?: 'auto' | 'concise' | 'detailed' | 'none';
         verbosity?: 'low' | 'medium' | 'high';
@@ -46,11 +38,30 @@ export declare namespace Team {
         web_search?: 'disabled' | 'cached' | 'live';
         json_response?: boolean;
     };
+    type OpenAiModelParams = {
+        temperature?: number;
+        max_tokens?: number;
+        service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
+        top_p?: number;
+        reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+        reasoning_summary?: 'auto' | 'concise' | 'detailed' | 'none';
+        verbosity?: 'low' | 'medium' | 'high';
+        parallel_tool_calls?: boolean;
+        safety_identifier?: string;
+        text_format?: 'text' | 'json_object' | 'json_schema';
+        text_format_json_schema_name?: string;
+        text_format_json_schema?: string;
+        text_format_json_schema_strict?: boolean;
+        web_search_tool?: boolean;
+        web_search_context_size?: 'low' | 'medium' | 'high';
+        web_search_allowed_domains?: string[];
+        web_search_include_sources?: boolean;
+    };
     export interface ModelParams {
         max_tokens?: number;
         json_response?: boolean;
-        codex?: OpenAiStyleModelParams;
-        openai?: OpenAiStyleModelParams;
+        codex?: CodexModelParams;
+        openai?: OpenAiModelParams;
         anthropic?: {
             temperature?: number;
             max_tokens?: number;
@@ -169,8 +180,8 @@ export declare namespace Team {
     export const TEAM_YAML_MEMBER_KEYS: readonly ["name", "from", "use", "import", "provider", "model", "gofor", "nogo", "toolsets", "tools", "model_params", "fbr-effort", "fbr_effort", "fbr_model_params", "diligence-push-max", "diligence_push_max", "read_dirs", "write_dirs", "no_read_dirs", "no_write_dirs", "read_file_ext_names", "write_file_ext_names", "no_read_file_ext_names", "no_write_file_ext_names", "icon", "streaming", "hidden"];
     export const TEAM_YAML_MODEL_PARAMS_ROOT_KEYS: readonly ["max_tokens", "json_response", "general", "codex", "openai", "anthropic"];
     export const TEAM_YAML_MODEL_PARAMS_GENERAL_KEYS: readonly ["max_tokens"];
-    export const TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS: readonly ["temperature", "max_tokens", "service_tier", "top_p", "frequency_penalty", "presence_penalty", "seed", "logprobs", "top_logprobs", "stop", "logit_bias", "user", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "web_search", "json_response"];
-    export const TEAM_YAML_MODEL_PARAMS_CODEX_KEYS: readonly ["temperature", "max_tokens", "service_tier", "top_p", "frequency_penalty", "presence_penalty", "seed", "logprobs", "top_logprobs", "stop", "logit_bias", "user", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "web_search", "json_response"];
+    export const TEAM_YAML_MODEL_PARAMS_OPENAI_KEYS: readonly ["temperature", "max_tokens", "service_tier", "top_p", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "safety_identifier", "text_format", "text_format_json_schema_name", "text_format_json_schema", "text_format_json_schema_strict", "web_search_tool", "web_search_context_size", "web_search_allowed_domains", "web_search_include_sources"];
+    export const TEAM_YAML_MODEL_PARAMS_CODEX_KEYS: readonly ["temperature", "max_tokens", "service_tier", "top_p", "reasoning_effort", "reasoning_summary", "verbosity", "parallel_tool_calls", "web_search", "json_response"];
     export const TEAM_YAML_MODEL_PARAMS_ANTHROPIC_KEYS: readonly ["temperature", "max_tokens", "top_p", "top_k", "stop_sequences", "reasoning_split", "json_response"];
     export {};
 }