@reconcrap/boss-recommend-mcp 1.3.30 → 1.3.32

package/vendor/boss-chat-cli/src/cli.js

@@ -38,6 +38,7 @@ import {
 } from './services/profile-store.js';
 import { ReportStore } from './services/report-store.js';
 import { ResumeCaptureService } from './services/resume-capture.js';
+import { ResumeNetworkTracker } from './services/resume-network.js';
 import { NoopStateStore, StateStore } from './services/state-store.js';
 
 const CLI_FILE_PATH = fileURLToPath(import.meta.url);
@@ -264,6 +265,14 @@ function parseArgs(argv) {
       case 'reasoning-effort':
         args.overrides.llm.thinkingLevel = value || '';
         break;
+      case 'llm-timeout-ms':
+      case 'timeout-ms':
+        args.overrides.llm.timeoutMs = Number.parseInt(value, 10);
+        break;
+      case 'llm-max-retries':
+      case 'max-retries':
+        args.overrides.llm.maxRetries = Number.parseInt(value, 10);
+        break;
       case 'port':
         args.overrides.chrome.port = Number.parseInt(value, 10);
         break;
@@ -315,6 +324,8 @@ function printUsage() {
   console.log('  --apikey <key>                  Override LLM API key');
   console.log('  --model <name>                  Override LLM model');
   console.log('  --thinking-level <level>        LLM thinking level: off|low|medium|high|current');
+  console.log('  --llm-timeout-ms <n>            Override per-request LLM timeout (default: 60000)');
+  console.log('  --llm-max-retries <n>           Override per-request LLM retry count (default: 3)');
   console.log('  --port <n>                      Override Chrome remote debugging port');
 }
 
@@ -925,6 +936,12 @@ function buildDetachedRunArgs(args, runId) {
   if (args.overrides.llm.thinkingLevel) {
     workerArgs.push('--thinking-level', String(args.overrides.llm.thinkingLevel));
   }
+  if (Number.isFinite(args.overrides.llm.timeoutMs) && args.overrides.llm.timeoutMs > 0) {
+    workerArgs.push('--llm-timeout-ms', String(args.overrides.llm.timeoutMs));
+  }
+  if (Number.isFinite(args.overrides.llm.maxRetries) && args.overrides.llm.maxRetries > 0) {
+    workerArgs.push('--llm-max-retries', String(args.overrides.llm.maxRetries));
+  }
   if (Number.isFinite(args.overrides.chrome.port)) {
     workerArgs.push('--port', String(args.overrides.chrome.port));
   }
@@ -1341,6 +1358,7 @@ async function executeRunCommand(args, dataDir) {
     });
     const llmClient = new LlmClient(runProfile.llm);
     const resumeCaptureService = new ResumeCaptureService({ chromeClient, logger });
+    const resumeNetworkTracker = new ResumeNetworkTracker({ chromeClient, logger });
     const stateStore = args.noState ? new NoopStateStore() : new StateStore(dataDir, args.profile);
     const reportStore = new ReportStore(dataDir);
     const app = new BossChatApp({
@@ -1350,6 +1368,7 @@ async function executeRunCommand(args, dataDir) {
       resumeCaptureService,
       stateStore,
       reportStore,
+      resumeNetworkTracker,
       runControl,
       logger,
       dryRun: args.dryRun,
@@ -1540,6 +1559,7 @@ async function main() {
 }
 
 export const __testables = {
+  parseArgs,
   connectBossChatPage,
   hasHydratedChatShell,
   promptRunProfile,

package/vendor/boss-chat-cli/src/services/chrome-client.js

@@ -15,14 +15,20 @@ export class ChromeClient {
     }
 
     this.client = await CDP({ port: this.port, target });
-    const { Runtime, DOM, Page, Input } = this.client;
+    const { Runtime, DOM, Page, Input, Network } = this.client;
 
-    await Promise.all([Runtime.enable(), DOM.enable(), Page.enable()]);
+    await Promise.all([
+      Runtime.enable(),
+      DOM.enable(),
+      Page.enable(),
+      Network && typeof Network.enable === 'function' ? Network.enable() : Promise.resolve(),
+    ]);
 
     this.Runtime = Runtime;
     this.DOM = DOM;
     this.Page = Page;
     this.Input = Input;
+    this.Network = Network || null;
 
     return target;
   }

package/vendor/boss-chat-cli/src/services/llm.js

@@ -43,6 +43,22 @@ function getCompletionContent(data) {
   return '';
 }
 
+function flattenChatMessageContent(content) {
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (item && typeof item === 'object') {
+          return item.text || item.content || item.reasoning_content || '';
+        }
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return String(content || '');
+}
+
 function getResponsesContent(data) {
   if (typeof data?.output_text === 'string' && data.output_text.trim()) {
     return data.output_text;
@@ -163,6 +179,100 @@ function toStringArray(value, maxItems = 8) {
   return normalized;
 }
 
+function collectNestedText(value, out = [], depth = 0) {
+  if (depth > 6 || value === null || value === undefined) return out;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    const normalized = normalizeText(String(value));
+    if (normalized) out.push(normalized);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectNestedText(item, out, depth + 1);
+    }
+    return out;
+  }
+  if (typeof value === 'object') {
+    const priorityKeys = ['text', 'reasoning_content', 'summary_text', 'summary', 'content', 'cot', 'reason'];
+    const seen = new Set();
+    for (const key of priorityKeys) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        seen.add(key);
+        collectNestedText(value[key], out, depth + 1);
+      }
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (seen.has(key)) continue;
+      collectNestedText(nested, out, depth + 1);
+    }
+  }
+  return out;
+}
+
+function dedupeTextFragments(fragments = []) {
+  const deduped = [];
+  const seen = new Set();
+  for (const item of fragments) {
+    const normalized = normalizeText(item);
+    if (!normalized) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    deduped.push(normalized);
+  }
+  return deduped;
+}
+
+function joinTextFragments(fragments = []) {
+  return dedupeTextFragments(fragments).join('\n');
+}
+
+function extractCompletionReasoningText(data) {
+  const choice = data?.choices?.[0] || {};
+  const fragments = [];
+  const content = choice?.message?.content;
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      const partType = normalizeText(part?.type || '').toLowerCase();
+      if (partType.includes('reason') || partType.includes('summary')) {
+        collectNestedText(part, fragments);
+      }
+    }
+  }
+  const candidates = [
+    choice?.message?.reasoning_content,
+    choice?.message?.reasoning,
+    choice?.reasoning_content,
+    choice?.reasoning,
+  ];
+  for (const candidate of candidates) {
+    collectNestedText(candidate, fragments);
+  }
+  return joinTextFragments(fragments);
+}
+
+function extractResponsesReasoningText(data) {
+  const fragments = [];
+  collectNestedText(data?.reasoning, fragments);
+  collectNestedText(data?.reasoning_content, fragments);
+
+  const output = Array.isArray(data?.output) ? data.output : [];
+  for (const item of output) {
+    const itemType = normalizeText(item?.type || '').toLowerCase();
+    if (itemType.includes('reason') || itemType.includes('summary')) {
+      collectNestedText(item, fragments);
+    }
+    const content = Array.isArray(item?.content) ? item.content : [];
+    for (const chunk of content) {
+      const chunkType = normalizeText(chunk?.type || '').toLowerCase();
+      if (chunkType.includes('reason') || chunkType.includes('summary')) {
+        collectNestedText(chunk, fragments);
+      }
+    }
+  }
+
+  return joinTextFragments(fragments);
+}
+
 function extractEvidenceTokens(text, maxItems = MAX_EVIDENCE_TOKENS) {
   const normalized = normalizeText(text);
   if (!normalized) return [];
@@ -300,8 +410,9 @@ function buildImagePrompt({ screeningCriteria, candidate }) {
     '若无法在教育经历模块确认学校名称，不要编造学校名；按信息不足处理。',
     '必须完整阅读全部简历截图分段后再判断。',
     '必须且只能返回 JSON，不要输出 Markdown。',
-    '返回格式：{"passed":true/false,"reason":"简短中文原因","summary":"简短总结","evidence":["证据原文1","证据原文2"]}',
-    '当信息不足以支持通过时，返回 passed=false。',
+    '返回格式：{"passed":true} 或 {"passed":false}。',
+    '不要返回理由、总结、证据、思维过程或额外字段。',
+    '当信息不足以支持通过时，返回 {"passed":false}。',
     '',
     `筛选标准：${screeningCriteria}`,
     '',
@@ -316,7 +427,7 @@ function buildTextPrompt({ screeningCriteria, candidate, resumeText, chunkIndex
   const profileContext = buildProfileContext(candidate);
   const chunkHint =
     chunkTotal > 1
-      ? `\n\n当前输入是简历分段 ${chunkIndex}/${chunkTotal}。请严格基于本分段文本判断；如果本分段证据不足，必须返回 passed=false。`
+      ? `\n\n当前输入是简历分段 ${chunkIndex}/${chunkTotal}。请严格基于本分段文本判断；如果本分段证据不足，必须返回 {"passed":false}。`
       : '';
   return [
     '你是招聘筛选助手，请基于简历文本判断候选人是否符合筛选标准。',
@@ -325,8 +436,9 @@ function buildTextPrompt({ screeningCriteria, candidate, resumeText, chunkIndex
     '必须忽略推荐模块与匿名卡片信息（例如“其他名企大厂经历牛人”“相似牛人”“推荐牛人”）。',
     '若无法在教育经历模块确认学校名称，不要编造学校名；按信息不足处理。',
     '必须且只能返回 JSON，不要输出 Markdown。',
-    '返回格式：{"passed":true/false,"reason":"简短中文原因","summary":"简短总结","evidence":["证据原文1","证据原文2"]}',
-    '当信息不足以支持通过时，返回 passed=false。',
+    '返回格式：{"passed":true} 或 {"passed":false}。',
+    '不要返回理由、总结、证据、思维过程或额外字段。',
+    '当信息不足以支持通过时，返回 {"passed":false}。',
     '',
     `筛选标准：${screeningCriteria}`,
     '',
@@ -339,12 +451,52 @@ function buildTextPrompt({ screeningCriteria, candidate, resumeText, chunkIndex
   ].join('\n');
 }
 
+function pickFirstText(...values) {
+  for (const value of values) {
+    const normalized = normalizeText(value);
+    if (normalized) return normalized;
+  }
+  return '';
+}
+
 export function parseLlmJson(content, options = {}) {
   const text = String(content || '').trim();
   if (!text) {
     throw new Error('LLM returned empty content');
   }
 
+  const normalizedText = normalizeText(text);
+  const chunkIndex = Number.isInteger(options.chunkIndex) && options.chunkIndex > 0 ? options.chunkIndex : 1;
+  const chunkTotal = Number.isInteger(options.chunkTotal) && options.chunkTotal > 0 ? options.chunkTotal : 1;
+
+  if (/^(pass|passed|true)$/i.test(normalizedText)) {
+    return {
+      passed: true,
+      rawOutputText: text,
+      rawReasoningText: normalizeText(options.reasoningText || ''),
+      cot: normalizeText(options.reasoningText || ''),
+      reason: '',
+      summary: '',
+      evidence: [],
+      chunkIndex,
+      chunkTotal,
+    };
+  }
+
+  if (/^(fail|failed|false)$/i.test(normalizedText)) {
+    return {
+      passed: false,
+      rawOutputText: text,
+      rawReasoningText: normalizeText(options.reasoningText || ''),
+      cot: normalizeText(options.reasoningText || ''),
+      reason: '',
+      summary: '',
+      evidence: [],
+      chunkIndex,
+      chunkTotal,
+    };
+  }
+
   const codeFenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
   const candidate = codeFenceMatch ? codeFenceMatch[1] : text;
   const jsonMatch = candidate.match(/\{[\s\S]*\}/);
@@ -353,54 +505,40 @@ export function parseLlmJson(content, options = {}) {
   }
 
   const parsed = JSON.parse(jsonMatch[0]);
-  const parsedPassed = typeof parsed.passed === 'boolean' ? parsed.passed : parsed.matched;
+  const parsedPassed =
+    typeof parsed.passed === 'boolean'
+      ? parsed.passed
+      : typeof parsed.matched === 'boolean'
+      ? parsed.matched
+      : /^pass$/i.test(String(parsed.decision || '').trim())
+      ? true
+      : /^fail$/i.test(String(parsed.decision || '').trim())
+      ? false
+      : null;
   if (typeof parsedPassed !== 'boolean') {
     throw new Error('LLM response missing boolean "passed"');
   }
-  if (typeof parsed.reason !== 'string' || !parsed.reason.trim()) {
-    throw new Error('LLM response missing string "reason"');
-  }
-
-  const reason = normalizeText(parsed.reason);
-  const summary = normalizeText(parsed.summary || reason);
-  const parsedEvidence = toStringArray(parsed.evidence);
 
-  const evidenceCorpus = normalizeText(options.evidenceCorpus || options.rawResumeText || '');
-  const chunkIndex = Number.isInteger(options.chunkIndex) && options.chunkIndex > 0 ? options.chunkIndex : 1;
-  const chunkTotal = Number.isInteger(options.chunkTotal) && options.chunkTotal > 0 ? options.chunkTotal : 1;
-
-  let evidence = parsedEvidence;
-  let evidenceMatchedCount = parsedEvidence.length;
-  if (evidenceCorpus) {
-    const normalizedCorpus = normalizeText(evidenceCorpus);
-    const normalizedCorpusLower = toLowerSafe(normalizedCorpus);
-    evidence = [];
-    for (const item of parsedEvidence) {
-      const matched = matchEvidenceAgainstResume(item, evidenceCorpus, normalizedCorpus, normalizedCorpusLower);
-      if (matched.matched) {
-        evidence.push(item);
-      }
-    }
-    evidenceMatchedCount = evidence.length;
-  }
-
-  const rawPassed = parsedPassed === true;
-  const evidenceRawCount = parsedEvidence.length;
-  const evidenceGateDemoted = rawPassed && evidenceMatchedCount <= 0;
-  const passed = evidenceGateDemoted ? false : rawPassed;
-  const finalReason = evidenceGateDemoted
-    ? `模型未给出可在简历原文中校验的证据，按安全策略判为不通过。${reason ? ` 原始原因: ${reason}` : ''}`
-    : reason;
+  const parsedReason = pickFirstText(parsed?.reason, parsed?.summary, parsed?.summary_text);
+  const parsedSummary = pickFirstText(parsed?.summary, parsed?.summary_text, parsed?.reason);
+  const parsedCot = pickFirstText(
+    options.reasoningText,
+    parsed?.cot,
+    parsed?.reasoning_content,
+    parsed?.reasoning,
+    parsedReason,
+    parsedSummary,
+  );
+  const parsedEvidence = toStringArray(parsed?.evidence);
 
   return {
-    passed,
-    rawPassed,
-    reason: finalReason || '模型未返回有效理由。',
-    summary: summary || finalReason || '模型未返回有效总结。',
-    evidence,
-    evidenceRawCount,
-    evidenceMatchedCount,
-    evidenceGateDemoted,
+    passed: parsedPassed,
+    rawOutputText: text,
+    rawReasoningText: normalizeText(options.reasoningText || ''),
+    cot: parsedCot,
+    reason: parsedReason || parsedCot,
+    summary: parsedSummary || parsedReason || parsedCot,
+    evidence: parsedEvidence,
     chunkIndex,
     chunkTotal,
   };
@@ -485,10 +623,16 @@ export class LlmClient {
     throw lastError || new Error(`${label} evaluation failed`);
   }
 
-  async requestResponses({ prompt, imageDataUrl = null, evidenceCorpus = '', chunkIndex = 1, chunkTotal = 1 }) {
+  async requestResponses({ prompt, imageDataUrl = null, imageDataUrls = [], evidenceCorpus = '', chunkIndex = 1, chunkTotal = 1 }) {
     const content = [{ type: 'input_text', text: prompt }];
+    const normalizedImageDataUrls = Array.isArray(imageDataUrls)
+      ? imageDataUrls.map((item) => String(item || '').trim()).filter(Boolean)
+      : [];
     if (imageDataUrl) {
-      content.push({ type: 'input_image', image_url: imageDataUrl });
+      normalizedImageDataUrls.unshift(String(imageDataUrl));
+    }
+    for (const item of normalizedImageDataUrls) {
+      content.push({ type: 'input_image', image_url: item });
     }
     const payload = {
       model: this.model,
@@ -526,6 +670,7 @@ export class LlmClient {
     }
 
     const outputContent = getResponsesContent(data);
+    const reasoningText = extractResponsesReasoningText(data);
     if (!outputContent) {
       const incompleteReason = String(data?.incomplete_details?.reason || '').trim();
       const outputTypes = Array.isArray(data?.output)
@@ -548,6 +693,7 @@ export class LlmClient {
     try {
       return parseLlmJson(outputContent, {
         evidenceCorpus,
+        reasoningText,
         chunkIndex,
         chunkTotal,
       });
@@ -560,10 +706,16 @@ export class LlmClient {
     }
   }
 
-  async requestCompletions({ prompt, imageDataUrl = null, evidenceCorpus = '', chunkIndex = 1, chunkTotal = 1 }) {
+  async requestCompletions({ prompt, imageDataUrl = null, imageDataUrls = [], evidenceCorpus = '', chunkIndex = 1, chunkTotal = 1 }) {
     const content = [{ type: 'text', text: prompt }];
+    const normalizedImageDataUrls = Array.isArray(imageDataUrls)
+      ? imageDataUrls.map((item) => String(item || '').trim()).filter(Boolean)
+      : [];
     if (imageDataUrl) {
-      content.push({ type: 'image_url', image_url: { url: imageDataUrl } });
+      normalizedImageDataUrls.unshift(String(imageDataUrl));
+    }
+    for (const item of normalizedImageDataUrls) {
+      content.push({ type: 'image_url', image_url: { url: item } });
     }
     const payload = {
       model: this.model,
@@ -605,6 +757,7 @@ export class LlmClient {
     }
 
     const outputContent = getCompletionContent(data);
+    const reasoningText = extractCompletionReasoningText(data);
     if (!String(outputContent || '').trim()) {
       const emptyError = new Error('Completions API empty textual content');
       emptyError.code = 'COMPLETIONS_EMPTY_CONTENT';
@@ -614,6 +767,7 @@ export class LlmClient {
     try {
       return parseLlmJson(outputContent, {
         evidenceCorpus,
+        reasoningText,
         chunkIndex,
         chunkTotal,
       });
@@ -648,20 +802,33 @@ export class LlmClient {
     }
   }
 
-  async evaluateImageResume({ screeningCriteria, candidate, imagePath }) {
+  async evaluateImageResume({ screeningCriteria, candidate, imagePath, imagePaths = [] }) {
     const prompt = buildImagePrompt({ screeningCriteria, candidate });
-    const imageDataUrl = await this.readImageAsDataUrl(imagePath);
+    const normalizedImagePaths = Array.isArray(imagePaths)
+      ? imagePaths.map((item) => String(item || '').trim()).filter(Boolean)
+      : [];
+    if (imagePath) {
+      normalizedImagePaths.unshift(String(imagePath));
+    }
+    const uniqueImagePaths = [...new Set(normalizedImagePaths)];
+    if (uniqueImagePaths.length <= 0) {
+      throw new Error('IMAGE_MODEL_FAILED: missing image paths');
+    }
+    const imageDataUrls = await Promise.all(
+      uniqueImagePaths.map((item) => this.readImageAsDataUrl(item)),
+    );
     const evidenceCorpus = normalizeText(candidate?.evidenceCorpus || candidate?.resumeText || '');
     const result = await this.requestByPreference({
       prompt,
-      imageDataUrl,
+      imageDataUrls,
       evidenceCorpus,
       chunkIndex: 1,
       chunkTotal: 1,
     });
     return {
       ...result,
-      evaluationMode: 'image',
+      evaluationMode: uniqueImagePaths.length > 1 ? 'image-multi-chunk' : 'image',
+      imageCount: uniqueImagePaths.length,
     };
   }
 
@@ -736,51 +903,52 @@ export class LlmClient {
       };
     }
 
-    const firstReason = chunkResults.map((item) => normalizeText(item?.reason)).find(Boolean);
     return {
       passed: false,
-      rawPassed: chunkResults.some((item) => item?.rawPassed === true),
-      reason: firstReason || `分段筛选未找到满足标准的证据（共 ${chunks.length} 段）。`,
-      summary: firstReason || `分段筛选未找到满足标准的证据（共 ${chunks.length} 段）。`,
+      rawOutputText:
+        chunkResults.map((item) => normalizeText(item?.rawOutputText)).find(Boolean) ||
+        `{"passed":false,"mode":"text-chunk-fallback","chunks":${chunks.length}}`,
+      rawReasoningText: chunkResults.map((item) => normalizeText(item?.rawReasoningText)).find(Boolean) || '',
+      cot: chunkResults.map((item) => normalizeText(item?.cot)).find(Boolean) || '',
+      reason: chunkResults.map((item) => normalizeText(item?.reason)).find(Boolean) || '',
+      summary: chunkResults.map((item) => normalizeText(item?.summary)).find(Boolean) || '',
       evidence: [],
-      evidenceRawCount: chunkResults.reduce(
-        (acc, item) =>
-          acc + (Number.isFinite(Number(item?.evidenceRawCount)) ? Number(item.evidenceRawCount) : 0),
-        0,
-      ),
-      evidenceMatchedCount: chunkResults.reduce(
-        (acc, item) =>
-          acc + (Number.isFinite(Number(item?.evidenceMatchedCount)) ? Number(item.evidenceMatchedCount) : 0),
-        0,
-      ),
-      evidenceGateDemoted: chunkResults.some((item) => item?.evidenceGateDemoted === true),
       chunkIndex: null,
       chunkTotal: chunks.length,
       evaluationMode: 'text',
     };
   }
 
-  async evaluateResume({ screeningCriteria, candidate, imagePath }) {
+  async evaluateResume({ screeningCriteria, candidate, imagePath, imagePaths = [] }) {
+    const normalizedImagePaths = Array.isArray(imagePaths)
+      ? imagePaths.map((item) => String(item || '').trim()).filter(Boolean)
+      : [];
+    if (imagePath) {
+      normalizedImagePaths.unshift(String(imagePath));
+    }
+    const uniqueImagePaths = [...new Set(normalizedImagePaths)];
+    if (uniqueImagePaths.length > 0) {
+      return this.evaluateImageResume({
+        screeningCriteria,
+        candidate,
+        imagePaths: uniqueImagePaths,
+      });
+    }
+
     const hasResumeText = Boolean(normalizeText(candidate?.resumeText || ''));
     if (hasResumeText) {
-      try {
-        return await this.evaluateTextResume({ screeningCriteria, candidate });
-      } catch (textError) {
-        if (!imagePath) {
-          throw textError;
-        }
-        const imageResult = await this.evaluateImageResume({ screeningCriteria, candidate, imagePath });
-        return {
-          ...imageResult,
-          textFallbackError: normalizeText(textError?.message || textError),
-        };
-      }
+      return this.evaluateTextResume({ screeningCriteria, candidate });
     }
-    return this.evaluateImageResume({ screeningCriteria, candidate, imagePath });
+
+    throw new Error('LLM evaluation requires at least one resume image or non-empty resume text');
   }
 }
 
 export const __testables = {
+  flattenChatMessageContent,
+  collectNestedText,
+  extractCompletionReasoningText,
+  extractResponsesReasoningText,
   extractEvidenceTokens,
   matchEvidenceAgainstResume,
   splitTextByChunks,

package/vendor/boss-chat-cli/src/services/profile-store.js

@@ -11,6 +11,8 @@ const DEFAULT_PROFILE = {
     apiKey: '',
     model: '',
     thinkingLevel: '',
+    timeoutMs: 60000,
+    maxRetries: 3,
   },
   chrome: {
     port: 9222,
@@ -80,6 +82,8 @@ export function toPersistentProfile(profile = {}) {
       apiKey: normalized.llm.apiKey,
       model: normalized.llm.model,
       thinkingLevel: normalized.llm.thinkingLevel,
+      timeoutMs: normalized.llm.timeoutMs,
+      maxRetries: normalized.llm.maxRetries,
     },
     chrome: {
       port: normalized.chrome.port,
@@ -104,6 +108,8 @@ export function normalizeProfile(profile = {}) {
   merged.llm.thinkingLevel = String(
     merged.llm.thinkingLevel || merged.llm.llmThinkingLevel || merged.llm.reasoningEffort || merged.llm.reasoning_effort || '',
   ).trim();
+  merged.llm.timeoutMs = normalizeNumber(merged.llm.timeoutMs, DEFAULT_PROFILE.llm.timeoutMs);
+  merged.llm.maxRetries = normalizeNumber(merged.llm.maxRetries, DEFAULT_PROFILE.llm.maxRetries);
   merged.runtime.batchRestEnabled = merged.runtime.batchRestEnabled !== false;
   merged.runtime.safePacing = merged.runtime.safePacing !== false;
   return merged;