roundStepId("local_research", 1),
1,
nextTracks,
makerEvidenceContext(directEvidence)
);
}
return {
type: "complete",
output: {
query,
mode: "direct_web_degraded",
plan: researchPlan,
checker: checkerDecision,
research: directEvidence,
checker_error: "The checker requested continuation without an actionable in-budget retrieval step."
}
};
}
if (localRounds.length > 0) {
if (!engineeredLoopEnabled || input.engineered_loop_fixture === true) {
if (shouldScheduleFollowUpRound(localRounds, localRoundFailures)) {
const nextRound = localRounds.length + 1;
return scheduleMakerStep(
roundStepId("local_research", nextRound),
nextRound,
followUpTracks(localRounds),
evidenceSummary(localRounds)
);
}
const aggregate = aggregateResearchRounds(
localRounds,
localRoundFailures.length > 0 ? "round_failed_after_partial_evidence" : "bounded_rounds_complete",
localRoundFailures
);
const fixtureOutput = {
query,
plan: researchPlan,
mode: directEvidence ? "hybrid_direct_web_parallel" : "local_parallel_task",
research: aggregate
};
if (directEvidence) {
fixtureOutput.seed_research = directEvidence;
}
return { type: "complete", output: fixtureOutput };
}
const latestRound = localRounds.length;
const roundDirectStepId = roundDirectFollowUpStepId(latestRound);
const roundDirectResearch = stepOutputs[roundDirectStepId];
const roundDirectFailure = stepFailures[roundDirectStepId];
const checkerKind = roundDirectResearch ? "round_follow_up" : "round";
const checkerId = checkerStepId(checkerKind, latestRound);
const checkerFailure = stepFailures[checkerId];
const checkerDecision = structuredTaskOutput(stepOutputs[checkerId]);
const priorRoundChecker = roundDirectResearch
? structuredTaskOutput(stepOutputs[checkerStepId("round", latestRound)])
: null;
if (
!checkerDecision &&
!checkerFailure &&
roundDirectResearch &&
priorRoundChecker &&
!checkerFitsWorkflowBudget()
) {
const aggregate = aggregateResearchRounds(
localRounds,
"workflow_budget_reached_after_targeted_retrieval",
localRoundFailures
);
const completedOutput = {
query,
plan: researchPlan,
checker: budgetFinalizedChecker(
priorRoundChecker,
"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."
),
mode: directEvidence ? "hybrid_direct_web_parallel" : "local_parallel_task",
research: aggregate,
budget_limited: true
};
if (directEvidence) {
completedOutput.seed_research = directEvidence;
}
return { type: "complete", output: completedOutput };
}
if (!checkerDecision && !checkerFailure) {
const makerEvidence = aggregateResearchRounds(localRounds, "checking_evidence", []);
const scheduled = scheduleChecker(checkerKind, latestRound, {
direct: directEvidence,
maker: makerEvidence
});
if (scheduled) {
return scheduled;
}
}
const directQueries = checkerDecision && Array.isArray(checkerDecision.search_queries)
? checkerDecision.search_queries.filter(isNonEmptyString).slice(0, directWebSearchLimit)
: [];
const directUrls = checkerDecision && Array.isArray(checkerDecision.seed_urls)
? checkerDecision.seed_urls
.filter((item) => isNonEmptyString(item) && /^https?:\/\//i.test(item.trim()))
.slice(0, directWebFetchLimit)
: [];
if (
checkerDecision &&
checkerDecision.decision === "continue" &&
checkerDecision.next_action === "direct_retrieval" &&
directWebEnabled &&
!retrievalBudgetExhausted &&
!roundDirectResearch &&
!roundDirectFailure &&
localRounds.length < maxResearchRounds &&
(directQueries.length > 0 || directUrls.length > 0)
) {
return {
type: "schedule_step",
step_id: roundDirectStepId,
step_name: "direct_web_research",
input: directStepInput(
directQueries,
directUrls,
observedDirectUrls(directEvidence)
),
retry: continueWorkflowRetry,
};
}
const nextTracks = checkerContinuationTracks(checkerDecision);
const makerContinuationRequested = Boolean(
checkerDecision &&
checkerDecision.decision === "continue" &&
(checkerDecision.next_action === "maker" ||
(checkerDecision.next_action === "direct_retrieval" && Boolean(roundDirectResearch))) &&
localRounds.length < maxResearchRounds &&
nextTracks.length > 0
);
if (makerContinuationRequested && !makerFitsWorkflowBudget()) {
const aggregate = aggregateResearchRounds(
localRounds,
"workflow_budget_reached_after_checked_evidence",
localRoundFailures
);
const completedOutput = {
query,
plan: researchPlan,
checker: budgetFinalizedChecker(checkerDecision),
mode: directEvidence ? "hybrid_direct_web_parallel" : "local_parallel_task",
research: aggregate,
budget_limited: true
};
if (directEvidence) {
completedOutput.seed_research = directEvidence;
}
return { type: "complete", output: completedOutput };
}
if (
makerContinuationRequested
) {
const nextRound = localRounds.length + 1;
return scheduleMakerStep(
roundStepId("local_research", nextRound),
nextRound,
nextTracks,
compactText(JSON.stringify({
direct: directEvidence,
maker: evidenceSummary(localRounds)
}), 4000)
);
}
const aggregate = aggregateResearchRounds(
localRounds,
roundDirectFailure
? "direct_follow_up_failed_after_partial_evidence"
: checkerFailure
? "checker_failed_after_partial_evidence"
: (checkerDecision ? `checker_${checkerDecision.decision}` : "bounded_rounds_complete"),
localRoundFailures
);
const completedOutput = {
query,
plan: researchPlan,
checker: checkerDecision,
mode: directEvidence ? "hybrid_direct_web_parallel" : "local_parallel_task",
research: aggregate
};
if (directEvidence) {
completedOutput.seed_research = directEvidence;
}
if (roundDirectFailure) {
completedOutput.retrieval_error = roundDirectFailure.error ||
"Targeted direct retrieval after a maker round failed.";
}
if (checkerFailure) {
if (roundDirectResearch && priorRoundChecker) {
completedOutput.checker = failedRecheckFinalizedChecker(priorRoundChecker);
completedOutput.verification = {
status: "degraded",
checker_completed: false,
prior_checker_retained: true,
error: checkerFailure.error || "Evidence follow-up checker failed."
};
} else {
delete completedOutput.checker;
completedOutput.verification = {
status: "degraded",
checker_completed: false,
error: checkerFailure.error || "Evidence checker failed."
};
}
}
return {
type: "complete",
output: completedOutput
};
}
if (localRoundFailures.length > 0) {
const priorDirectChecker = structuredTaskOutput(
stepOutputs[checkerStepId("direct", 0)]
);
const retainedRounds = collectRetainedFailureRounds(stepFailures, "local_research");
if (retainedRounds.length > 0) {
const completedOutput = {
query,
plan: researchPlan,
checker: priorDirectChecker,
mode: directEvidence
? "hybrid_direct_web_parallel"
: "local_parallel_task_partial_success",
research: aggregateResearchRounds(
retainedRounds,
"source_notes_retained",
localRoundFailures
)
};
if (directEvidence) {
completedOutput.seed_research = directEvidence;
}
return { type: "complete", output: completedOutput };
}
if (
directWebSeedEnabled &&
!directWebResearch &&
!directWebFailure &&
!retrievalBudgetExhausted
) {
return {
type: "schedule_step",
step_id: "direct_web_research",
step_name: "direct_web_research",
input: directStepInput(plannedSearchQueries, plannedSeedUrls),
retry: continueWorkflowRetry,
};
}
const completedOutput = {
query,
plan: researchPlan,
checker: priorDirectChecker,
mode: "local_parallel_task_failed",
research: {
status: "failed",
algorithm: "bounded_recursive_parallel_retrieval_summary",
max_rounds: maxResearchRounds,
completed_rounds: 0,
error: localRoundFailures[0].error || "local research step failed",
note: "Local evidence fan-out failed before producing usable structured evidence; synthesis should create a transparent fallback report instead of retrying the workflow."
}
};
if (directWebResearch) {
completedOutput.seed_research = directEvidence;
}
return {
type: "complete",
output: completedOutput
};
}
if ((directWebResearch && !hasStructuredEvidence(directWebResearch)) || directWebFailure) {
return scheduleMakerStep(
roundStepId("local_research", 1),
1,
tracks,
directWebResearch ? makerEvidenceContext(directWebResearch) : ""
);
}
if (directWebSeedEnabled && directWebFirst) {
return {
type: "schedule_step",
step_id: "direct_web_research",
step_name: "direct_web_research",
input: directStepInput(plannedSearchQueries, plannedSeedUrls),
retry: continueWorkflowRetry,
};
}
if (!makerFitsWorkflowBudget()) {
return {
type: "complete",
output: {
query,
plan: researchPlan,
mode: "workflow_budget_exhausted",
research: {
status: "failed",
algorithm: "llm_planned_engineered_loop",
error: "The planned maker-first route no longer fits inside the workflow wall-clock fuse."
}
}
};
}
return scheduleMakerStep(
roundStepId("local_research", 1),
1,
tracks,
plannedSeedEvidenceContext
);
}
if (
inputs.kind === "step" &&
inputs.step_name === "direct_web_research"
) {
return await collectDirectWebResearch();
}
if (
inputs.kind === "step" &&
inputs.step_name === "generate_object"
) {
const stepStartedAtMs = Date.now();
const generatedInput = inputs.input || {};
const generated = await ctx.tool("generate_object", generatedInput);
if (!generated || Number(generated.exitCode) !== 0) {
throw new Error(generated && generated.output
? generated.output
: "generate_object returned no schema-valid object");
}
const generatedMetadata = generated.metadata && typeof generated.metadata === "object"
? generated.metadata
: {};
const generatedPrompt = isNonEmptyString(generatedInput.prompt)
? generatedInput.prompt
: "";
const sourceMarker = "Runtime-observed source anchors (reuse these exact URLs; they were observed before this step):";
const sourceEndMarker = "End runtime-observed source anchors.";
const markerAt = generatedPrompt.indexOf(sourceMarker);
const markerEnd = markerAt >= 0
? generatedPrompt.indexOf(sourceEndMarker, markerAt + sourceMarker.length)
: -1;
const inheritedSourceUrls = generatedInput.schema_name === "deep_research_evidence" && markerAt >= 0
? evidenceSeedUrls(generatedPrompt.slice(
markerAt + sourceMarker.length,
markerEnd >= 0 ? markerEnd : generatedPrompt.length
))
: [];
return {
tool: "generate_object",
output: generated.output || "",
exit_code: Number(generated.exitCode) || 0,
metadata: Object.assign({}, generatedMetadata, {
step_elapsed_ms: Math.max(0, Date.now() - stepStartedAtMs),
inherited_source_urls: inheritedSourceUrls
})
};
}
return { error: `unknown dynamic workflow invocation: ${inputs.kind}/${inputs.step_name || ""}` };
}