const hasStructuredEvidence = (runtimeOutput) =>
runtimeOutput &&
Array.isArray(runtimeOutput.results) &&
runtimeOutput.results.some((item) => item && item.success === true && item.structured);
const plannerTaskInput = () => {
const planner = loopContract.planner && typeof loopContract.planner === "object"
? loopContract.planner
: null;
if (!planner || !planner.output_schema || !isNonEmptyString(planner.prompt)) {
return null;
}
return {
schema: planner.output_schema,
schema_name: "deep_research_plan",
schema_description: "LLM-authored adaptive DeepResearch plan and budget",
prompt: planner.prompt,
mode: "auto",
max_repair_attempts: 1,
timeout_ms: Math.max(5000, Math.min(120000, Number(planner.timeout_ms) || 120000)),
};
};
const structuredTaskOutput = (output) => {
const results = output && output.metadata && Array.isArray(output.metadata.results)
? output.metadata.results
: [];
const delegated = results
.filter((item) => item && item.success === true && item.structured && typeof item.structured === "object")
.map((item) => item.structured)[0] || null;
if (delegated) {
return delegated;
}
const raw = output && isNonEmptyString(output.output) ? output.output : "";
if (!raw) {
return null;
}
try {
const generated = JSON.parse(raw);
return generated && generated.object && typeof generated.object === "object" && !Array.isArray(generated.object)
? generated.object
: null;
} catch (_) {
return null;
}
};
const checkerStepId = (kind, roundNumber) => {
if (kind === "direct") {
return "research_checker_direct";
}
if (kind === "direct_follow_up") {
return `research_checker_direct_follow_up_${roundNumber}`;
}
if (kind === "round_follow_up") {
return `research_checker_round_${roundNumber}_direct_follow_up`;
}
return `research_checker_round_${roundNumber}`;
};
const boundedDigestStrings = (values, charBudget, maxItems) => {
const candidates = uniqueStrings(values);
const count = Math.min(candidates.length, maxItems);
if (count === 0 || charBudget <= 0) {
return [];
}
// Leave room for JSON quotes, separators, and occasional escaped
// characters so each field remains independently bounded.
const perItemChars = Math.max(48, Math.floor((charBudget * 0.8) / count));
return candidates.slice(0, count).map((item) => compactText(item, perItemChars));
};
const checkerEvidenceClassDigest = (research, charBudget) => {
if (!research || typeof research !== "object" || Array.isArray(research)) {
return { present: false };
}
const metadata = research.metadata && typeof research.metadata === "object"
? research.metadata
: {};
const results = Array.isArray(research.results) ? research.results : [];
const structured = results
.filter((item) => item && item.success === true && item.structured && typeof item.structured === "object")
.map((item) => item.structured);
const summaries = structured.map((item) => item.summary);
const sources = [];
const seenSources = new Set();
for (const item of structured) {
for (const source of Array.isArray(item.sources) ? item.sources : []) {
if (!source || typeof source !== "object") {
continue;
}
const url = compactText(source.url_or_path, 300);
const key = canonicalObservedSourceKey(url) || url.toLowerCase();
if (!url || seenSources.has(key)) {
continue;
}
seenSources.add(key);
const title = compactText(source.title, 140);
const fact = compactText(source.quote_or_fact, 320);
sources.push(`${url}${title ? ` — ${title}` : ""}${fact ? `: ${fact}` : ""}`);
}
}
const keyEvidence = structured.flatMap((item) =>
Array.isArray(item.key_evidence) ? item.key_evidence : []
);
const gaps = structured.flatMap((item) => Array.isArray(item.gaps) ? item.gaps : []);
const contradictions = structured.flatMap((item) =>
Array.isArray(item.contradictions) ? item.contradictions : []
);
const confidence = structured.map((item) => item.confidence);
const failedTasks = research.warnings && Array.isArray(research.warnings.failed_tasks)
? research.warnings.failed_tasks
: [];
const failedRounds = research.warnings && Array.isArray(research.warnings.failed_rounds)
? research.warnings.failed_rounds
: [];
const failures = [
...failedTasks.map((item) => item && (item.error_summary || item.error)),
...failedRounds.map((item) => item && item.error)
];
const contentBudget = Math.max(600, charBudget - 500);
return {
present: true,
status: compactText(research.status, 80),
algorithm: compactText(research.algorithm, 120),
counts: {
results: Number(metadata.result_count) || results.length,
validated: structured.length,
succeeded: Number(metadata.success_count) || 0,
failed: Number(metadata.failed_count) || 0
},
summaries: boundedDigestStrings(summaries, Math.floor(contentBudget * 0.16), 6),
sources: boundedDigestStrings(sources, Math.floor(contentBudget * 0.34), 8),
key_evidence: boundedDigestStrings(keyEvidence, Math.floor(contentBudget * 0.22), 8),
gaps: boundedDigestStrings(gaps, Math.floor(contentBudget * 0.09), 6),
contradictions: boundedDigestStrings(
contradictions,
Math.floor(contentBudget * 0.09),
6
),
confidence: boundedDigestStrings(confidence, Math.floor(contentBudget * 0.05), 4),
failures: boundedDigestStrings(failures, Math.floor(contentBudget * 0.05), 4)
};
};
const checkerEvidenceDigest = (evidence) => {
const combined = evidence && typeof evidence === "object" && !Array.isArray(evidence) &&
(Object.prototype.hasOwnProperty.call(evidence, "maker") ||
Object.prototype.hasOwnProperty.call(evidence, "direct"));
const maker = combined ? evidence.maker : null;
const direct = combined ? evidence.direct : evidence;
const hasMaker = maker && typeof maker === "object";
const hasDirect = direct && typeof direct === "object";
const makerBudget = hasMaker && hasDirect ? 2600 : 3600;
const directBudget = hasMaker && hasDirect ? 1800 : 3600;
// Keep maker first because it contains schema-validated, task-specific
// analysis. Each evidence class is digested independently so a verbose
// direct collection can never truncate maker evidence out of the prompt.
return JSON.stringify({
digest_version: 1,
maker: checkerEvidenceClassDigest(maker, makerBudget),
direct: checkerEvidenceClassDigest(direct, directBudget)
});
};
const makerEvidenceContext = (evidence) =>
compactText(checkerEvidenceDigest(evidence), 4000);
const checkerPlanDigest = () => JSON.stringify({
answer_shape: researchPlan && researchPlan.answer_shape,
report_title: researchPlan && researchPlan.report_title,
execution_route: researchPlan && researchPlan.execution_route,
freshness_required: Boolean(researchPlan && researchPlan.freshness_required === true),
workspace_evidence_required: Boolean(
researchPlan && researchPlan.workspace_evidence_required === true
),
phases: researchPlan && Array.isArray(researchPlan.phases)
? researchPlan.phases.slice(0, 3)
: [],
tracks: researchPlan && Array.isArray(researchPlan.tracks)
? researchPlan.tracks.slice(0, 4)
: [],
stop_conditions: researchPlan && Array.isArray(researchPlan.stop_conditions)
? researchPlan.stop_conditions.slice(0, 3)
: []
});
const workflowRemainingMs = () => {
const startedAt = Number(input.run_started_at_ms);
const timeoutMs = Number(input.workflow_timeout_ms);
if (!Number.isFinite(startedAt) || startedAt <= 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
return null;
}
return Math.max(0, Math.floor(timeoutMs - Math.max(0, Date.now() - startedAt)));
};
const checkerBudgetDirective = () => {
const remainingMs = workflowRemainingMs();
const makerFloorMs = makerAndCheckerFloorMs;
if (remainingMs === null) {
return " Workflow budget: remaining wall time is unavailable; request only one consequential next action.";
}
const makerGuidance = remainingMs < makerFloorMs
? "Do not request maker: maker plus independent checking cannot finish in the remaining window. Finalize with explicit limitations unless the core answer would be misleading."
: "A maker pass plus independent checking still fits, but request it only for a consequential multi-step or local-evidence gap.";
return ` Workflow budget: approximately ${remainingMs} ms remains; one maker pass plus an independent checker needs at least ${makerFloorMs} ms. ${makerGuidance}`;
};
const checkerTaskInput = (kind, roundNumber, evidence) => {
const checker = loopContract.checker && typeof loopContract.checker === "object"
? loopContract.checker
: null;
if (!checker || !checker.output_schema) {
return null;
}
const boundedEvidence = checkerEvidenceDigest(evidence);
const boundedPlan = compactText(checkerPlanDigest(), 2400);
const webOnlyReview = directWebEnabled && !workspaceEvidenceRequired;
const repeatedDirectDirective = kind === "direct_follow_up" || kind === "round_follow_up"
? (webOnlyReview
? " One direct follow-up already ran. Do not retrieve again or use maker for more web reading; finalize with limitations or degrade."
: " One direct follow-up already ran. Do not repeat it; use maker only for a distinct non-web task, otherwise finalize or degrade.")
: "";
const capabilityDirective = webOnlyReview
? " Public web gaps use direct_retrieval. Maker is only for evidence production or required non-web/local work."
: "";
const remainingMs = workflowRemainingMs();
const availableCheckerMs = remainingMs === null
? configuredCheckerTimeoutMs
: Math.max(5000, remainingMs - workflowClosureReserveMs);
return {
schema: checker.output_schema,
schema_name: "deep_research_check",
schema_description: "Independent DeepResearch evidence coverage decision",
prompt: `Check evidence against the semantic plan; do not call tools. Finalize a useful sourced answer with explicit limits. Continue one gap only: direct_retrieval for public evidence or maker for distinct evidence production/non-web work. Never repeat failed work or request unplanned local evidence. Degrade only if the core answer misleads. Finalize/degrade require next_action=none; empty routing arrays may be omitted.${repeatedDirectDirective}${capabilityDirective}${checkerBudgetDirective()} Return only concise schema fields. report_summary answers the request from supported evidence; recommendations are conditional and unsupported conditions stay in unresolved_gaps. verified_findings has up to five sourced facts. Findings state facts, never that sources, articles, comparisons, discussions, or collection exist. Titles/snippets are leads unless retained quotes support them. Put uncertainty only in gaps or contradictions.\n\nPlan:\n${boundedPlan}\n\nEvidence (${kind}, iteration ${roundNumber}):\n${boundedEvidence}`,
mode: "auto",
// Empty routing arrays are optional in the schema, so a valid semantic
// decision should never spend another slow model call repairing omitted
// boilerplate. Invalid output fails transparently and remains replayable.
max_repair_attempts: 0,
timeout_ms: Math.min(configuredCheckerTimeoutMs, availableCheckerMs),
};
};
const scheduleChecker = (kind, roundNumber, evidence) => {
const input = checkerTaskInput(kind, roundNumber, evidence);
return input ? {
type: "schedule_step",
step_id: checkerStepId(kind, roundNumber),
step_name: "generate_object",
input,
retry: checkerWorkflowRetry,
} : null;
};
const directFollowUpStepId = (roundNumber) => `direct_web_follow_up_${roundNumber}`;
const roundDirectFollowUpStepId = (roundNumber) =>
`direct_web_after_round_${roundNumber}`;
const collectDirectFollowUps = (outputs) => {
const followUps = [];
for (let roundNumber = 1; roundNumber <= maxResearchRounds; roundNumber += 1) {
const research = outputs[directFollowUpStepId(roundNumber)];
if (!research) {
break;
}
followUps.push({ round: roundNumber, research });
}
return followUps;
};
const collectRoundDirectFollowUps = (outputs) => {
const followUps = [];
for (let roundNumber = 1; roundNumber <= maxResearchRounds; roundNumber += 1) {
const research = outputs[roundDirectFollowUpStepId(roundNumber)];
if (research) {
followUps.push({ round: maxResearchRounds + roundNumber, research });
}
}
return followUps;
};
const cumulativeDirectResearch = (seed, followUps) => {
const attempts = [{ round: 0, research: seed }, ...followUps];
const results = [];
const collectionErrors = [];
let retrievalStartedAtMs = 0;
let retrievalElapsedMs = 0;
let successCount = 0;
let failedCount = 0;
let allEngineered = true;
for (const attempt of attempts) {
const research = attempt.research || {};
const metadata = research.metadata || {};
allEngineered = allEngineered && metadata.engineered_loop === true;
if (!retrievalStartedAtMs && Number(metadata.retrieval_started_at_ms) > 0) {
retrievalStartedAtMs = Number(metadata.retrieval_started_at_ms);
}
if (Number(metadata.retrieval_elapsed_ms) > 0) {
retrievalElapsedMs += Number(metadata.retrieval_elapsed_ms);
}
successCount += Number(metadata.success_count) || 0;
failedCount += Number(metadata.failed_count) || 0;
const attemptResults = Array.isArray(research.results) ? research.results : [];
for (let index = 0; index < attemptResults.length; index += 1) {
const item = attemptResults[index];
results.push(Object.assign({}, item, {
iteration: attempt.round,
task_id: `direct-${attempt.round}-${index + 1}`
}));
}
const errors = research.warnings && Array.isArray(research.warnings.collection_errors)
? research.warnings.collection_errors
: [];
collectionErrors.push(...errors);
}
const hasFailure = failedCount > 0 || collectionErrors.length > 0;
const metadata = {
engineered_loop: allEngineered,
retrieval_started_at_ms: retrievalStartedAtMs || undefined,
retrieval_elapsed_ms: retrievalElapsedMs,
task_count: attempts.length,
result_count: results.length,
success_count: successCount,
failed_count: failedCount,
all_success: !hasFailure && results.length > 0,
partial_failure: hasFailure && results.length > 0,
results
};
const aggregate = {
tool: "web_search/web_fetch",
algorithm: "llm_targeted_direct_retrieval",
status: results.length === 0 ? "failed" : (hasFailure ? "partial_success" : "success"),
completed_iterations: followUps.length,
metadata,
results
};
if (collectionErrors.length > 0) {
aggregate.warnings = { collection_errors: uniqueStrings(collectionErrors).slice(0, 10) };
}
return aggregate;
};
const observedDirectUrls = (research) => {
if (!research || typeof research !== "object") {
return [];
}
const urls = [];
for (const result of Array.isArray(research.results) ? research.results : []) {
const structured = result && result.structured && typeof result.structured === "object"
? result.structured
: null;
for (const source of structured && Array.isArray(structured.sources) ? structured.sources : []) {
if (source && isNonEmptyString(source.url_or_path)) {
urls.push(source.url_or_path);
}
}
}
const errors = research.warnings && Array.isArray(research.warnings.collection_errors)
? research.warnings.collection_errors
: [];
for (const error of errors) {
urls.push(...(String(error || "").match(/https?:\/\/[^\s<>"'\\]+/gi) || []));
}
const seen = new Set();
return urls
.map((url) => normalizeObservedSource(String(url).replace(/[.,;:!?)\]}]+$/, "")))
.filter((url) => {
const key = canonicalObservedSourceKey(url);
if (!key || seen.has(key)) {
return false;
}
seen.add(key);
return true;
});
};
const linkedDirectUrls = (research) => {
if (!research || typeof research !== "object") {
return [];
}
const alreadyObserved = new Set(observedDirectUrls(research).map(canonicalObservedSourceKey));
const candidates = [];
for (const result of Array.isArray(research.results) ? research.results : []) {
const structured = result && result.structured && typeof result.structured === "object"
? result.structured
: null;
if (!structured) {
continue;
}
const texts = [
structured.summary,
...(Array.isArray(structured.key_evidence) ? structured.key_evidence : []),
...(Array.isArray(structured.sources)
? structured.sources.map((source) => source && source.quote_or_fact)
: [])
];
for (const text of texts) {
candidates.push(...(String(text || "").match(/https?:\/\/[^\s<>"'\\]+/gi) || []));
}
}
const seen = new Set();
return candidates
.map((url) => normalizeObservedSource(String(url).replace(/[.,;:!?)\]}]+$/, "")))
.filter((url) => {
const key = canonicalObservedSourceKey(url);
if (!key || alreadyObserved.has(key) || seen.has(key)) {
return false;
}
seen.add(key);
return true;
})
.sort((left, right) => sourceRelevanceScore({ title: "", url: right, content: "" }) -
sourceRelevanceScore({ title: "", url: left, content: "" }))
.slice(0, directWebFetchLimit);
};
const makerFitsWorkflowBudget = () => {
const remainingMs = workflowRemainingMs();
return remainingMs === null || remainingMs >= makerAndCheckerFloorMs;
};
const checkerFitsWorkflowBudget = () => {
const remainingMs = workflowRemainingMs();
return remainingMs === null || remainingMs >= checkerReserveMs;
};
const budgetFinalizedChecker = (decision, reason) => Object.assign({}, decision || {}, {
decision: "finalize",
next_action: "none",
coverage_summary: compactText(
`${decision && decision.coverage_summary ? decision.coverage_summary : "Useful traceable evidence was collected."} Remaining checked gaps must be stated as report limitations because another full checked iteration cannot finish inside the workflow budget.`,
800
),
reason: reason || "The evidence package is reportable with explicit limitations; no further maker pass fits the remaining workflow budget."
});
const checkerContinuationTracks = (decision) => {
if (!decision || typeof decision !== "object") {
return [];
}
const requested = Array.isArray(decision.next_tracks)
? decision.next_tracks.filter((track) => track && typeof track === "object")
: [];
if (requested.length > 0) {
return requested.slice(0, maxLocalParallelTasks);
}
return (Array.isArray(decision.unresolved_gaps) ? decision.unresolved_gaps : [])
.filter(isNonEmptyString)
.slice(0, maxLocalParallelTasks)
.map((gap, index) => ({
title: `Resolve checked gap ${index + 1}`,
focus: gap,
completion_criteria: ["Return traceable evidence or an explicit source-backed limitation"]
}));
};
const directStepInput = (searchQueries, seedUrls, excludedUrls = []) => ({
query,
current_date: input.current_date,
run_started_at_ms: input.run_started_at_ms,
workflow_timeout_ms: input.workflow_timeout_ms,
engineered_loop_enabled: engineeredLoopEnabled,
engineered_loop_fixture: input.engineered_loop_fixture === true,
research_plan_fixture: input.research_plan_fixture === true,
research_plan: researchPlan,
search_queries: Array.isArray(searchQueries) ? searchQueries : [],
seed_urls: Array.isArray(seedUrls) ? seedUrls : [],
excluded_urls: Array.isArray(excludedUrls) ? excludedUrls : [],
direct_web_max_results: directWebMaxResults,
direct_web_fetch_limit: directWebFetchLimit,
direct_web_search_limit: directWebSearchLimit,
direct_web_search_timeout_secs: directWebSearchTimeoutSecs,
direct_web_fetch_timeout_secs: directWebFetchTimeoutSecs,
direct_web_engines: directWebEngines
});
if (inputs.kind === "workflow") {
const stepFailures = inputs.step_failures || {};
const plannerFailure = stepFailures.research_planner;
if (engineeredLoopEnabled && !researchPlan) {
if (plannerFailure || plannerStep) {
return {
type: "complete",
output: {
query,
mode: "planning_failed",
research: {
status: "failed",
algorithm: "llm_planned_engineered_loop",
error: plannerFailure && plannerFailure.error
? plannerFailure.error
: "The LLM planner returned no schema-valid ResearchPlan."
}
}
};
}
const plannerInput = plannerTaskInput();
if (!plannerInput) {
return {
type: "complete",
output: {
query,
mode: "planning_failed",
research: {
status: "failed",
algorithm: "llm_planned_engineered_loop",
error: "The host did not provide a valid Loop Engineering planner contract."
}
}
};
}
return {
type: "schedule_step",
step_id: "research_planner",
step_name: "generate_object",
input: plannerInput,
retry: plannerWorkflowRetry,
};
}
const directWebResearch = inputs.step_outputs.direct_web_research;
const directWebFailure = stepFailures.direct_web_research;
const directFollowUps = collectDirectFollowUps(inputs.step_outputs);
const roundDirectFollowUps = collectRoundDirectFollowUps(inputs.step_outputs);
const directAttempts = [
...(directWebResearch ? [{ round: 0, research: directWebResearch }] : []),
...directFollowUps,
...roundDirectFollowUps
];
const directEvidence = directAttempts.length === 0
? null
: (directAttempts.length === 1
? directAttempts[0].research
: cumulativeDirectResearch(
directAttempts[0].research,
directAttempts.slice(1)
));
const inheritedDirectSourceUrls = uniqueStrings([
...observedDirectUrls(directEvidence),
...evidenceSeedUrls(JSON.stringify(directEvidence || {}))
]);
const localRounds = collectRoundOutputs(
inputs.step_outputs,
"local_research",
inheritedDirectSourceUrls
);
const localRoundFailures = collectRoundFailures(stepFailures, "local_research");
const directRecoveryAfterMakerFailure =
engineeredLoopEnabled &&
input.engineered_loop_fixture !== true &&
localRounds.length === 0 &&
localRoundFailures.length > 0;
if (
retrievalBudgetExhausted &&
localRounds.length === 0 &&
!(directWebResearch && hasStructuredEvidence(directWebResearch))
) {
return {
type: "complete",
output: {
query,
plan: researchPlan,
mode: "retrieval_deadline_reached",
research: {
status: "failed",
algorithm: "llm_planned_engineered_loop",
error: "The LLM-planned retrieval deadline was reached before usable evidence was collected."
}
}
};
}
if (
directWebResearch &&
hasStructuredEvidence(directWebResearch) &&
localRounds.length === 0 &&
(localRoundFailures.length === 0 || directRecoveryAfterMakerFailure)
) {
if (!engineeredLoopEnabled || input.engineered_loop_fixture === true) {
const directMetadata = directWebResearch.metadata || {};
const fixtureReady =
maxResearchRounds === 1 &&
Number(directMetadata.source_count) >= 2 &&
Number(directMetadata.host_count) >= 2 &&
Number(directMetadata.fetched_count) >= 1 &&
Number(directMetadata.fetched_host_count) >= 2 &&
Number(directMetadata.query_term_count) > 0 &&
Number(directMetadata.matched_query_term_count) >= Number(directMetadata.query_term_count) &&
Number(directMetadata.fetched_query_term_count) >= Number(directMetadata.query_term_count) &&
directMetadata.query_terms_truncated !== true &&
(directMetadata.freshness_required !== true || Number(directMetadata.dated_source_count) >= 1) &&
directMetadata.partial_failure !== true;
if (fixtureReady || (directWebResearch.metadata && directWebResearch.metadata.terminal === true)) {
return {
type: "complete",
output: { query, mode: "direct_web", plan: researchPlan, research: directWebResearch }
};
}
return scheduleMakerStep(
roundStepId("local_research", 1),
1,
tracks,
makerEvidenceContext(directWebResearch)
);
}
const directIteration = directFollowUps.length;
// The semantic planner owns the initial route. A legacy direct_then_maker plan
// deliberately skips the expensive pre-maker checker: direct retrieval
// seeds the planned tracks, makers perform the requested investigation,
// and the checker reviews their cumulative evidence afterward. No answer
// shape, query text, track count, or topic classifier overrides this
// explicit route. New direct_then_review plans intentionally bypass this
// branch and combine synthesis with their first coverage review, removing
// one redundant structured model turn. A failed-maker direct recovery
// must not reschedule the legacy route.
if (
directThenMaker &&
directIteration === 0 &&
!directRecoveryAfterMakerFailure &&
tracks.length > 0 &&
makerFitsWorkflowBudget()
) {
return scheduleMakerStep(
roundStepId("local_research", 1),
1,
tracks,
makerEvidenceContext(directEvidence),
true
);
}
const checkerKind = directIteration === 0 ? "direct" : "direct_follow_up";
const checkerId = checkerStepId(checkerKind, directIteration);
const checkerFailure = stepFailures[checkerId];
const checkerDecision = structuredTaskOutput(stepOutputs[checkerId]);
const priorDirectChecker = directIteration > 0
? structuredTaskOutput(stepOutputs[checkerStepId("direct", 0)])
: null;
const failedFollowUp = stepFailures[directFollowUpStepId(directIteration + 1)];
if (failedFollowUp) {
return {
type: "complete",
output: {
query,
mode: "direct_web_degraded",
plan: researchPlan,
checker: checkerDecision,
research: directEvidence,
retrieval_error: failedFollowUp.error || "Targeted direct retrieval failed."
}
};
}
// Every new evidence attempt must be reviewed against the cumulative
// package. A partial direct follow-up is still new evidence; reusing the
// prior checker gaps here launches stale maker work and bypasses the
// maker/checker loop. The checker can explicitly route any remaining
// gap to one bounded maker step below.
if (
!checkerDecision &&
!checkerFailure &&
directIteration > 0 &&
priorDirectChecker &&
!checkerFitsWorkflowBudget()
) {
return {
type: "complete",
output: {
query,
mode: "direct_web",
plan: researchPlan,
checker: budgetFinalizedChecker(
priorDirectChecker,
"The previously verified findings remain reportable with explicit limitations; the targeted follow-up is retained as evidence, but another independent checker pass cannot finish inside the workflow budget."
),
research: directEvidence,
budget_limited: true
}
};
}
if (!checkerDecision && !checkerFailure) {
const checkerEvidence = directRecoveryAfterMakerFailure
? {
direct: directEvidence,
maker: aggregateResearchRounds(
[],
"maker_failed_before_direct_recovery",
localRoundFailures
)
}
: directEvidence;
const scheduled = scheduleChecker(checkerKind, directIteration, checkerEvidence);
if (scheduled) {
return scheduled;
}
}
if (checkerDecision && checkerDecision.decision === "finalize") {
return {
type: "complete",
output: {
query,
mode: "direct_web",
plan: researchPlan,
checker: checkerDecision,
research: directEvidence
}
};
}
if (checkerDecision && checkerDecision.decision === "degrade") {
return {
type: "complete",
output: {
query,
mode: "direct_web_degraded",
plan: researchPlan,
checker: checkerDecision,
research: directEvidence
}
};
}
if (checkerFailure) {
return {
type: "complete",
output: {
query,
mode: "direct_web",
plan: researchPlan,
research: directEvidence,
verification: {
status: "degraded",
checker_completed: false,
error: checkerFailure.error || "Evidence checker failed."
}
}
};
}
if (retrievalBudgetExhausted) {
return {
type: "complete",
output: {
query,
mode: "direct_web_degraded",
plan: researchPlan,
checker: checkerDecision,
research: directEvidence,
checker_error: "The LLM-planned retrieval deadline was reached before the requested follow-up evidence could start."
}
};
}
const followUpQueries = checkerDecision && Array.isArray(checkerDecision.search_queries)
? checkerDecision.search_queries.filter(isNonEmptyString).slice(0, directWebSearchLimit)
: [];
const checkerFollowUpUrls = checkerDecision && Array.isArray(checkerDecision.seed_urls)
? checkerDecision.seed_urls
.filter((item) => isNonEmptyString(item) && /^https?:\/\//i.test(item.trim()))
: [];
// A source-observed link is safest when the checker asks only for that
// linked detail. When the checker also provides focused search queries,
// its matching stable seeds belong to the same retrieval objective and
// must not be displaced by incidental links from a broad source page.
const observedFollowUpUrls = linkedDirectUrls(directEvidence);
const followUpUrls = uniqueStrings(followUpQueries.length > 0
? [...checkerFollowUpUrls, ...observedFollowUpUrls]
: [...observedFollowUpUrls, ...checkerFollowUpUrls]
).slice(0, directWebFetchLimit);
if (
checkerDecision &&
checkerDecision.decision === "continue" &&
checkerDecision.next_action === "direct_retrieval" &&
directWebEnabled &&
directIteration === 0 &&
(followUpQueries.length > 0 || followUpUrls.length > 0)
) {
const nextIteration = directIteration + 1;
return {
type: "schedule_step",
step_id: directFollowUpStepId(nextIteration),
step_name: "direct_web_research",
input: directStepInput(
followUpQueries,
followUpUrls,
observedDirectUrls(directEvidence)
),
retry: continueWorkflowRetry,
};
}
const nextTracks = checkerContinuationTracks(checkerDecision);
if (
checkerDecision &&
checkerDecision.decision === "continue" &&
(checkerDecision.next_action === "maker" ||
(checkerDecision.next_action === "direct_retrieval" && directIteration > 0)) &&
!makerFitsWorkflowBudget()
) {
return {
type: "complete",
output: {
query,
mode: "direct_web",
plan: researchPlan,
checker: budgetFinalizedChecker(checkerDecision),
research: directEvidence,
budget_limited: true
}
};
}
if (
checkerDecision &&
checkerDecision.decision === "continue" &&
(checkerDecision.next_action === "maker" ||
(checkerDecision.next_action === "direct_retrieval" && directIteration > 0)) &&
!directRecoveryAfterMakerFailure &&
nextTracks.length > 0
) {
return scheduleMakerStep(