dominds 1.22.1 → 1.23.0

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

@@ -30,6 +30,8 @@ const path_1 = __importDefault(require("path"));
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
+const dominds_running_version_1 = require("../../server/dominds-running-version");
+const api_quirks_1 = require("../api-quirks");
 const gen_1 = require("../gen");
 const stop_reason_i18n_1 = require("../stop-reason-i18n");
 const artifacts_1 = require("./artifacts");
@@ -43,6 +45,47 @@ const OPENAI_COMPAT_CAPTURE_DIR_ENV = 'DOMINDS_OPENAI_COMPAT_CAPTURE_DIR';
 const OPENAI_COMPAT_REJECTED_DIR_ENV = 'DOMINDS_OPENAI_COMPAT_REJECTED_DIR';
 const OPENAI_COMPATIBLE_MALFORMED_BATCH_TOOL_CALL_ERROR_CODE = 'OPENAI_COMPATIBLE_MALFORMED_BATCH_TOOL_CALL';
 const OPENAI_COMPATIBLE_REJECTED_REQUEST_ERROR_CODE = 'OPENAI_COMPATIBLE_REJECTED_REQUEST';
+const KIMI_CODE_API_QUIRK = 'kimi-code';
+const KIMI_CODE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
+const KIMI_CLI_CLOAK_API_QUIRK = 'kimi-cli-cloak';
+const KIMI_CLI_USER_AGENT = 'KimiCLI/1.41.0';
+const DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK = 'disable-assistant-tool-call-reasoning-content';
+const JSON_SCHEMA_COMBINATOR_KEYS = new Set([
+    'anyOf',
+    'oneOf',
+    'allOf',
+    'not',
+    'if',
+    'then',
+    'else',
+    '$ref',
+]);
+const JSON_SCHEMA_BRANCH_ARRAY_KEYS = ['anyOf', 'oneOf', 'allOf'];
+const JSON_SCHEMA_OBJECT_KEYS = new Set([
+    'properties',
+    'additionalProperties',
+    'patternProperties',
+    'propertyNames',
+    'required',
+    'minProperties',
+    'maxProperties',
+]);
+const JSON_SCHEMA_ARRAY_KEYS = new Set([
+    'items',
+    'prefixItems',
+    'minItems',
+    'maxItems',
+    'uniqueItems',
+    'contains',
+]);
+const JSON_SCHEMA_STRING_KEYS = new Set(['minLength', 'maxLength', 'pattern', 'format']);
+const JSON_SCHEMA_NUMERIC_KEYS = new Set([
+    'minimum',
+    'maximum',
+    'multipleOf',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+]);
 function resolveOpenAiCompatibleToolChoice(funcTools, requestContext, modelInfo) {
     const requirement = requestContext.toolUseRequirement ?? 'auto';
     if (funcTools.length === 0) {
@@ -71,6 +114,14 @@ function resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestC
         return undefined;
     return providerConfig.models[modelKey];
 }
+function resolveOpenAiCompatibleParallelToolCalls(args) {
+    if (args.openAiParams.parallel_tool_calls !== undefined) {
+        return args.openAiParams.parallel_tool_calls;
+    }
+    if (isKimiCodeProvider(args.providerConfig))
+        return undefined;
+    return true;
+}
 function isOpenAiCompatibleSseCaptureEnabled() {
     const configured = process.env[OPENAI_COMPAT_CAPTURE_SSE_ENV]?.trim().toLowerCase();
     return configured === '1' || configured === 'true' || configured === 'yes' || configured === 'on';
@@ -525,6 +576,16 @@ function createOpenAiCompatibleClient(args) {
         apiKey: args.apiKey,
         baseURL: args.providerConfig.baseUrl,
     };
+    if (isKimiCliCloakProvider(args.providerConfig)) {
+        options.defaultHeaders = {
+            'User-Agent': KIMI_CLI_USER_AGENT,
+        };
+    }
+    else if (isKimiCodeProvider(args.providerConfig)) {
+        options.defaultHeaders = {
+            'User-Agent': `Dominds/${dominds_running_version_1.DOMINDS_RUNNING_VERSION || 'dev'}`,
+        };
+    }
     if (args.providerConfig.apiType === 'openai-compatible' &&
         isOpenAiCompatibleSseCaptureEnabled()) {
         options.fetch = buildOpenAiCompatibleCaptureFetch({
@@ -553,6 +614,129 @@ function limitOpenAiCompatibleToolOutputText(text, msg, limitChars) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isKimiCodeProvider(providerConfig) {
+    return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(KIMI_CODE_API_QUIRK);
+}
+function isKimiCliCloakProvider(providerConfig) {
+    return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(KIMI_CLI_CLOAK_API_QUIRK);
+}
+function isKimiCodeReasoningEffort(value) {
+    return typeof value === 'string' && KIMI_CODE_REASONING_EFFORTS.has(value);
+}
+function isKimiCodeThinkingMode(value) {
+    return (value === 'auto' || value === 'off' || value === 'low' || value === 'medium' || value === 'high');
+}
+function cloneJsonSchemaValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => cloneJsonSchemaValue(item));
+    if (isRecord(value)) {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] = cloneJsonSchemaValue(child);
+        }
+        return out;
+    }
+    return value;
+}
+function hasAnyOwnKey(value, keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            return true;
+    }
+    return false;
+}
+function inferJsonSchemaTypeFromValues(values) {
+    const inferred = new Set();
+    for (const value of values) {
+        if (typeof value === 'boolean')
+            inferred.add('boolean');
+        else if (typeof value === 'number')
+            inferred.add(Number.isInteger(value) ? 'integer' : 'number');
+        else if (typeof value === 'string')
+            inferred.add('string');
+        else if (value === null)
+            inferred.add('null');
+        else if (Array.isArray(value))
+            inferred.add('array');
+        else if (isRecord(value))
+            inferred.add('object');
+        else
+            return 'string';
+    }
+    if (inferred.size === 1) {
+        const only = [...inferred][0];
+        return only ?? 'string';
+    }
+    if (inferred.size === 2 && inferred.has('integer') && inferred.has('number')) {
+        return 'number';
+    }
+    return 'string';
+}
+function inferJsonSchemaTypeFromStructure(value) {
+    if (hasAnyOwnKey(value, JSON_SCHEMA_OBJECT_KEYS))
+        return 'object';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_ARRAY_KEYS))
+        return 'array';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_STRING_KEYS))
+        return 'string';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_NUMERIC_KEYS))
+        return 'number';
+    return 'string';
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(value) {
+    if (!isRecord(value))
+        return;
+    if (!Object.prototype.hasOwnProperty.call(value, 'type') &&
+        !hasAnyOwnKey(value, JSON_SCHEMA_COMBINATOR_KEYS)) {
+        const enumValues = value.enum;
+        if (Array.isArray(enumValues) && enumValues.length > 0) {
+            value.type = inferJsonSchemaTypeFromValues(enumValues);
+        }
+        else if (Object.prototype.hasOwnProperty.call(value, 'const')) {
+            value.type = inferJsonSchemaTypeFromValues([value.const]);
+        }
+        else {
+            value.type = inferJsonSchemaTypeFromStructure(value);
+        }
+    }
+    normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(value);
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(value) {
+    if (!isRecord(value))
+        return;
+    const properties = value.properties;
+    if (isRecord(properties)) {
+        for (const property of Object.values(properties)) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(property);
+        }
+    }
+    const items = value.items;
+    if (isRecord(items)) {
+        normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(items);
+    }
+    else if (Array.isArray(items)) {
+        for (const item of items) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(item);
+        }
+    }
+    const additionalProperties = value.additionalProperties;
+    if (isRecord(additionalProperties)) {
+        normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(additionalProperties);
+    }
+    for (const key of JSON_SCHEMA_BRANCH_ARRAY_KEYS) {
+        const branches = value[key];
+        if (!Array.isArray(branches))
+            continue;
+        for (const branch of branches) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(branch);
+        }
+    }
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchema(value) {
+    const cloned = cloneJsonSchemaValue(value);
+    normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(cloned);
+    return cloned;
+}
 function isLlmRequestContext(value) {
     return (isRecord(value) &&
         typeof value.dialogSelfId === 'string' &&
@@ -618,8 +802,14 @@ function buildReasoningPayloadFromText(text) {
     };
 }
 function buildOpenAiCompatibleExtraParams(args) {
+    if (args.providerConfig !== undefined && isKimiCodeProvider(args.providerConfig)) {
+        return buildKimiCodeOpenAiCompatibleExtraParams(args);
+    }
     const model = args.agent.model ?? '';
     const thinking = args.openAiParams.thinking;
+    if (typeof thinking === 'string') {
+        throw new Error(`Invalid openai-compatible model_params: string thinking mode '${thinking}' requires apiQuirks: ${KIMI_CODE_API_QUIRK} for model '${model}'.`);
+    }
     const reasoningEffort = args.openAiParams.reasoning_effort;
     const thinkingDisabled = thinking === false || (isRecord(thinking) && thinking.type === 'disabled');
     if (thinkingDisabled && reasoningEffort !== undefined) {
@@ -633,6 +823,57 @@ function buildOpenAiCompatibleExtraParams(args) {
         ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
     };
 }
+function buildKimiCodeOpenAiCompatibleExtraParams(args) {
+    const model = args.agent.model ?? '';
+    const thinking = args.openAiParams.thinking;
+    const reasoningEffort = args.openAiParams.reasoning_effort;
+    const promptCacheKey = args.requestContext?.promptCacheKey?.trim();
+    if (reasoningEffort !== undefined && !isKimiCodeReasoningEffort(reasoningEffort)) {
+        throw new Error(`Invalid Kimi Code openai-compatible model_params: reasoning_effort=${reasoningEffort} is not supported for model '${model}'; expected low|medium|high.`);
+    }
+    const base = promptCacheKey !== undefined && promptCacheKey.length > 0
+        ? { prompt_cache_key: promptCacheKey }
+        : {};
+    if (thinking === undefined) {
+        return {
+            ...base,
+            ...(reasoningEffort !== undefined
+                ? { thinking: { type: 'enabled' }, reasoning_effort: reasoningEffort }
+                : {}),
+        };
+    }
+    if (thinking === 'auto' || thinking === 'off') {
+        if (reasoningEffort !== undefined) {
+            throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking=${thinking} conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+        }
+        if (thinking === 'auto')
+            return base;
+        return {
+            ...base,
+            thinking: { type: 'disabled' },
+        };
+    }
+    if (isKimiCodeThinkingMode(thinking)) {
+        if (reasoningEffort !== undefined && reasoningEffort !== thinking) {
+            throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking=${thinking} conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+        }
+        return {
+            ...base,
+            thinking: { type: 'enabled' },
+            reasoning_effort: thinking,
+        };
+    }
+    const thinkingDisabled = thinking === false || (isRecord(thinking) && thinking.type === 'disabled');
+    if (thinkingDisabled && reasoningEffort !== undefined) {
+        throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking disabled conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+    }
+    const thinkingPayload = typeof thinking === 'boolean' ? { type: thinking ? 'enabled' : 'disabled' } : thinking;
+    return {
+        ...base,
+        ...(thinkingPayload !== undefined ? { thinking: thinkingPayload } : {}),
+        ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
+    };
+}
 async function wrapOpenAiCompatibleRejectedRequestError(args) {
     const status = (0, failure_classifier_1.readErrorStatus)(args.error);
     if (status !== 400)
@@ -719,10 +960,18 @@ function attachReasoningContent(message, reasoningContent) {
         reasoning_content: reasoningContent,
     };
 }
-function funcToolToChatCompletionTool(funcTool) {
+function shouldAttachReasoningContentToAssistantToolCalls(providerConfig) {
+    if (providerConfig === undefined)
+        return true;
+    return !(0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK);
+}
+function funcToolToChatCompletionTool(funcTool, providerConfig) {
     // MCP schemas are passed through to providers. Chat Completions expects a narrower JSON schema
     // shape; runtime compatibility is handled by provider validation + the driver stop policy.
-    const parameters = funcTool.parameters;
+    const rawParameters = funcTool.parameters;
+    const parameters = (providerConfig !== undefined && isKimiCodeProvider(providerConfig)
+        ? normalizeOpenAiCompatibleKimiCodeJsonSchema(rawParameters)
+        : rawParameters);
     const description = (0, i18n_text_1.getTextForLanguage)({ i18n: funcTool.descriptionI18n, fallback: funcTool.description }, (0, work_language_1.getWorkLanguage)());
     return {
         type: 'function',
@@ -748,7 +997,6 @@ function chatMessageToChatCompletionMessage(msg) {
         case 'func_call_msg':
             return {
                 role: 'assistant',
-                content: null,
                 tool_calls: [
                     {
                         id: msg.id,
@@ -1102,7 +1350,9 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
     const input = [];
     const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(options?.providerConfig);
     const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestImagesWithinBudget)(normalized, tool_result_image_ingest_1.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES);
+    const attachToolCallReasoning = shouldAttachReasoningContentToAssistantToolCalls(options?.providerConfig);
     let pendingReasoningContent;
+    let assistantTurnReasoningContent;
     const takePendingReasoningContent = () => {
         const current = pendingReasoningContent;
         pendingReasoningContent = undefined;
@@ -1116,10 +1366,16 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
                 ? `${pendingReasoningContent}\n${value}`
                 : value;
     };
+    const noteAssistantTurnReasoningContent = (value) => {
+        if (!value)
+            return;
+        assistantTurnReasoningContent = value;
+    };
     const flushPendingReasoningAsAssistantMessage = () => {
         const reasoningContent = takePendingReasoningContent();
         if (!reasoningContent)
             return;
+        noteAssistantTurnReasoningContent(reasoningContent);
         input.push(attachReasoningContent({
             role: 'assistant',
             content: '',
@@ -1135,7 +1391,12 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
         }
         if (msg.type === 'func_call_msg') {
             const mapped = chatMessageToChatCompletionMessage(msg);
-            input.push(attachReasoningContent(mapped, takePendingReasoningContent()));
+            const pending = takePendingReasoningContent();
+            noteAssistantTurnReasoningContent(pending);
+            const reasoningContent = attachToolCallReasoning
+                ? (pending ?? assistantTurnReasoningContent)
+                : undefined;
+            input.push(attachReasoningContent(mapped, reasoningContent));
             continue;
         }
         if (msg.type === 'func_result_msg') {
@@ -1143,6 +1404,12 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
             input.push(...(await funcResultToChatCompletionMessages(msg, toolResultMaxChars, requestContext, options?.providerConfig, allowedImageKeys, options?.onToolResultImageIngest)));
             continue;
         }
+        if (msg.type === 'environment_msg' ||
+            msg.type === 'prompting_msg' ||
+            msg.type === 'tellask_result_msg' ||
+            msg.type === 'tellask_carryover_msg') {
+            assistantTurnReasoningContent = undefined;
+        }
         const mapped = (msg.type === 'prompting_msg' ||
             msg.type === 'tellask_result_msg' ||
             msg.type === 'tellask_carryover_msg') &&
@@ -1150,7 +1417,9 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
             msg.contentItems.length > 0
             ? await userLikeMessageToChatCompletionMessageWithImages(msg, requestContext, options?.providerConfig, allowedImageKeys, options?.onUserImageIngest)
             : chatMessageToChatCompletionMessage(msg);
-        input.push(attachReasoningContent(mapped, takePendingReasoningContent()));
+        const reasoningContent = takePendingReasoningContent();
+        noteAssistantTurnReasoningContent(reasoningContent);
+        input.push(attachReasoningContent(mapped, reasoningContent));
     }
     flushPendingReasoningAsAssistantMessage();
     return mergeAdjacentMessages(input);
@@ -1506,14 +1775,19 @@ class OpenAiCompatibleGen {
             onUserImageIngest: receiver.userImageIngest,
         });
         const openAiParams = agent.model_params?.['openai-compatible'] || {};
-        const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
+        const parallelToolCalls = resolveOpenAiCompatibleParallelToolCalls({
+            providerConfig,
+            openAiParams,
+        });
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
         const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
         const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
+            providerConfig,
             agent,
             openAiParams,
+            requestContext,
         });
         const payload = {
             model: agent.model,
@@ -1528,9 +1802,11 @@ class OpenAiCompatibleGen {
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
-            ...(requestTools.length > 0 ? { tools: requestTools.map(funcToolToChatCompletionTool) } : {}),
+            ...(requestTools.length > 0
+                ? { tools: requestTools.map((tool) => funcToolToChatCompletionTool(tool, providerConfig)) }
+                : {}),
             ...(toolChoice !== undefined && { tool_choice: toolChoice }),
-            parallel_tool_calls: parallelToolCalls,
+            ...(parallelToolCalls !== undefined && { parallel_tool_calls: parallelToolCalls }),
         };
         try {
             const stream = await client.chat.completions.create(payload, {
@@ -1588,14 +1864,19 @@ class OpenAiCompatibleGen {
             },
         });
         const openAiParams = agent.model_params?.['openai-compatible'] || {};
-        const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
+        const parallelToolCalls = resolveOpenAiCompatibleParallelToolCalls({
+            providerConfig,
+            openAiParams,
+        });
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
         const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
         const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
+            providerConfig,
             agent,
             openAiParams,
+            requestContext,
         });
         const payload = {
             model: agent.model,
@@ -1608,9 +1889,11 @@ class OpenAiCompatibleGen {
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
-            ...(requestTools.length > 0 && { tools: requestTools.map(funcToolToChatCompletionTool) }),
+            ...(requestTools.length > 0 && {
+                tools: requestTools.map((tool) => funcToolToChatCompletionTool(tool, providerConfig)),
+            }),
             ...(toolChoice !== undefined && { tool_choice: toolChoice }),
-            parallel_tool_calls: parallelToolCalls,
+            ...(parallelToolCalls !== undefined && { parallel_tool_calls: parallelToolCalls }),
         };
         try {
             const response = await client.chat.completions.create(payload, {

package/dist/minds/system-prompt-parts.js

@@ -148,11 +148,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? '当前是告急处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、且已完成合并时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
             : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。接续包提醒项默认应保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
@@ -166,11 +166,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Current mode is critical remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting and you have merged against the current content. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Current mode is caution remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting and you have merged against the current content. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
             : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps; reminders should also keep only scannable excerpts. Keep continuation-package reminders structured and fast to resume from by default.';
     if (ctx.language === 'zh') {
         return {
@@ -181,7 +181,7 @@ function getMemoryPromptCopy(ctx) {
             taskdocSemanticsLine: '- 章节语义约定：`progress` 是全队共享、准实时、可扫读的任务公告牌，用来记录当前有效状态、关键决策、下一步与仍成立阻塞；不是流水账，也不是个人工作记录。`goals` / `constraints` 是较稳定的任务契约；每次更新都必须保留仍然有效的他人条目。',
             taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
-                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
+                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并，同时带上当前 \`content_hash\` 作为 \`previous_content_hash\`；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
@@ -202,7 +202,7 @@ function getMemoryPromptCopy(ctx) {
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
-            mainDialogWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用 `change_mind(progress)`；要删除整章文件时用 `never_mind`）→ 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -215,7 +215,7 @@ function getMemoryPromptCopy(ctx) {
         taskdocSemanticsLine: '- Section semantics: `progress` is the team-shared, quasi-real-time, scannable task bulletin board for current effective state, key decisions, next steps, and still-active blockers; it is not a raw log or personal work record. `goals` / `constraints` are the more stable task contract; every update must preserve still-valid entries from others.',
         taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
-            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
+            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content and include the current \`content_hash\` as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
         progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
             : '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
@@ -236,7 +236,7 @@ function getMemoryPromptCopy(ctx) {
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
             : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
-        mainDialogWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `mind_more(progress)`; use `change_mind(progress)` when compression/deletion is needed; use `never_mind` when removing a whole section file) → then `clear_mind` to drop noise.',
+        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; use `change_mind` with `previous_content_hash` when compression/deletion is needed; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };

package/dist/runtime/driver-messages.js

@@ -407,7 +407,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '操作：',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
+                '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
                 '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             ].join('\n');
@@ -443,7 +443,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             '操作：',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并时，才更新：change_mind({ ... })',
+            '- 只有在确实需要改写已有章节、且已对照当前差遣牒内容完成合并并带上 `previous_content_hash` 时，才更新：change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
             '- 优先新增过桥提醒项：add_reminder({ "content": "..." })',
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
@@ -484,7 +484,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Operations:',
             '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: change_mind({ ... })',
+            '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
             '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         ].join('\n');
@@ -520,7 +520,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         'Operations:',
         '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
-        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content: change_mind({ ... })',
+        '- Only update when an existing section truly needs rewriting and you have merged against the current Taskdoc content and can provide `previous_content_hash`: change_mind({"selector":"<selector>","content":"...","previous_content_hash":"sha256:..."})',
         '- Prefer adding a bridge reminder first: add_reminder({ "content": "..." })',
         '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- clear_mind({})',

package/dist/team.d.ts

@@ -55,6 +55,7 @@ export declare namespace Team {
         web_search_allowed_domains?: string[];
         web_search_include_sources?: boolean;
     };
+    type OpenAiCompatibleThinkingMode = 'auto' | 'off' | 'low' | 'medium' | 'high';
     type OpenAiCompatibleModelParams = {
         temperature?: number;
         service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
@@ -66,7 +67,7 @@ export declare namespace Team {
         text_format_json_schema?: string;
         text_format_json_schema_strict?: boolean;
         reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-        thinking?: boolean | Record<string, unknown>;
+        thinking?: boolean | OpenAiCompatibleThinkingMode | Record<string, unknown>;
     };
     type AnthropicThinkingConfig = {
         type: 'adaptive';

package/dist/team.js

@@ -2322,7 +2322,17 @@ exports.Team = Team;
             asOptionalString(params.text_format_json_schema_name, `${at2}.text_format_json_schema_name`);
             asOptionalString(params.text_format_json_schema, `${at2}.text_format_json_schema`);
             asOptionalBoolean(params.text_format_json_schema_strict, `${at2}.text_format_json_schema_strict`);
-            validateOptionalBooleanOrObject(params.thinking, `${at2}.thinking`);
+            const thinking = params.thinking;
+            if (thinking !== undefined &&
+                typeof thinking !== 'boolean' &&
+                !isRecordValue(thinking) &&
+                thinking !== 'auto' &&
+                thinking !== 'off' &&
+                thinking !== 'low' &&
+                thinking !== 'medium' &&
+                thinking !== 'high') {
+                throw new Error(`Invalid ${at2}.thinking: expected boolean|object|auto|off|low|medium|high (got ${describeValueType(thinking)})`);
+            }
             const serviceTier = params.service_tier;
             if (serviceTier !== undefined &&
                 serviceTier !== 'auto' &&