pub import { agent_autocompact_if_needed, agent_emergency_compact } from "std/agent/autocompact"
pub import {
agent_budget_post_call_blocked,
agent_budget_post_call_stop_reason,
agent_budget_pre_call_blocked,
} from "std/agent/budget"
pub import {
agent_loop_apply_command,
agent_loop_control_invoke,
agent_loop_snapshot_state,
} from "std/agent/control"
pub import { agent_daemon_snapshot, agent_daemon_step } from "std/agent/daemon"
pub import {
agent_feedback_compose,
agent_feedback_emit,
agent_feedback_tool_example,
} from "std/agent/feedback"
pub import {
__agent_input_guardrail_fail_open,
__agent_input_guardrail_normalize,
} from "std/agent/guardrails"
pub import {
agent_done_judge_cap,
agent_has_done_judge,
agent_verify_completion_judge_cap,
agent_verify_or_continue,
} from "std/agent/judge"
pub import { agent_invoke_llm } from "std/agent/llm_dispatch"
pub import {
agent_mcp_admit_bootstrap,
agent_mcp_bootstrap_if_needed,
agent_mcp_mount_additional,
} from "std/agent/mcp"
pub import {
agent_monologue_actuation_observe_completed_dispatch,
agent_monologue_actuation_take_for_turn,
} from "std/agent/monologue_actuation"
pub import {
agent_loop_options,
agent_merge_llm_options,
agent_refresh_tool_format_for_route,
agent_sanitize_model_options,
agent_tool_format,
} from "std/agent/options"
pub import { agent_compute_post_turn, agent_compute_terminal_callback } from "std/agent/postturn"
pub import { agent_take_one_shot_prefill } from "std/agent/prefill"
pub import {
agent_build_turn_messages,
agent_build_turn_system_fragments,
agent_tool_call_paradigm,
} from "std/agent/preflight"
pub import { agent_dispatch_tool_call, agent_parse_tool_calls } from "std/agent/primitives"
pub import { agent_progress_apply_options } from "std/agent/progress"
pub import { native_tool_contract_feedback_prompt, parse_guidance_prompt } from "std/agent/prompts"
pub import {
agent_required_tools_enforce,
agent_required_tools_inject_feedback,
agent_required_tools_missing_from_session,
} from "std/agent/required_tools"
pub import { agent_scratchpad_init, agent_scratchpad_reorganize_if_due } from "std/agent/scratchpad"
pub import { agent_skills_match } from "std/agent/skills"
pub import {
agent_stall_apply_result,
agent_stall_clear_current_failure,
agent_stall_done_judge_due,
agent_stall_initial_state,
agent_stall_inject_feedback,
agent_stall_no_net_progress,
agent_stall_observe_completed_dispatch,
agent_stall_observe_tool_calls,
agent_stall_repair_config,
agent_stall_repeated_verified_pass,
agent_stall_verified_write_satisfied,
} from "std/agent/stall"
pub import {
agent_stance_apply,
agent_stance_post_turn,
agent_stance_prepare,
} from "std/agent/stance"
pub import {
agent_emit_event,
agent_record_native_tool_fallback,
agent_reminder_providers_fire,
agent_session_commit_directives,
agent_session_drain_bridge_injections,
agent_session_drain_feedback,
agent_session_drain_host_injections,
agent_session_finalize,
agent_session_flush,
agent_session_init,
agent_session_inject_feedback,
agent_session_messages,
agent_session_pair_orphaned_tool_use,
agent_session_pop_last_assistant,
agent_session_record_assistant,
agent_session_record_tool_results,
agent_session_record_undispatched_tool_results,
agent_session_record_usage,
agent_session_totals,
} from "std/agent/state"
pub import { agent_step_judge } from "std/agent/step_judge"
pub import {
agent_collapse_duplicate_read_calls,
agent_tool_annotations,
agent_tool_calls_are_read_only,
agent_tool_entry_annotations,
} from "std/agent/tool_annotations"
pub import {
agent_tool_lifecycle_error_category,
agent_tool_mutation_status,
} from "std/agent/tool_lifecycle"
pub import {
agent_tool_search_emit_queries,
agent_tool_search_inject_if_needed,
agent_tool_search_record_results,
} from "std/agent/tool_search"
import { __tool_surface_tool_allowed } from "std/agent/tool_surface"
pub import {
agent_apply_tool_surface_narrowing,
agent_reset_tool_surface_narrowing,
} from "std/agent/tool_surface"
pub import {
agent_await_resumption,
agent_lifecycle_tools,
list_agents,
suspend_agent,
} from "std/agent/workers"
pub import { omit } from "std/json"
pub import {
llm_arm_one_shot_prefill,
llm_clear_one_shot_prefill,
llm_enable_equivalent_failover,
} from "std/llm/options"
import { exact_tool_call_output_schema } from "std/llm/structural_validator"
pub import { env_bool } from "std/os"
pub fn __agent_loop_llm_overrides(opts) {
const overrides = opts?.llm_options
if type_of(overrides) == "dict" {
return overrides
}
return {}
}
pub type AgentLoopOutputContract = {schema: any?}
pub fn __agent_loop_output_contract(opts) -> AgentLoopOutputContract? {
const output = opts?.output
if output == nil || output == "text" {
return nil
}
if output == "json" {
return {schema: nil}
}
if type_of(output) == "dict" && output?.schema != nil {
return {schema: output.schema}
}
if type_of(output) == "dict" {
return {schema: output}
}
return nil
}
pub fn __agent_loop_has_terminal_output_contract(opts) -> bool {
return __agent_loop_output_contract(opts) != nil
}
pub fn __agent_loop_ordinary_turn_llm_options(opts) {
// `output` constrains the final answer, not intermediate tool-calling turns.
if !__agent_loop_has_terminal_output_contract(opts) {
return opts
}
return omit(opts, ["output"])
}
pub fn __agent_loop_next_tool_output_contract(opts) -> any? {
const claim = opts?._next_tool_claim
if claim == nil {
return nil
}
if claim?.source == "missing_tool_call_recovery" {
const recovery = opts?.missing_tool_call_recovery
if type_of(recovery) == "bool" && !recovery {
return nil
}
if type_of(recovery) == "dict" && !(recovery?.output_contract ?? true) {
return nil
}
}
const tool_name = claim?.tool_name ?? ""
if !__tool_surface_tool_allowed(opts?.tools, opts?.policy, tool_name) {
throw "agent_loop: next-turn `next_tool_claim` names unavailable or policy-denied tool `"
+ tool_name
+ "`"
}
const schema = exact_tool_call_output_schema(opts?.tools, tool_name)
if schema == nil {
throw "agent_loop: next-turn `next_tool_claim` names unavailable tool `" + tool_name + "`"
}
return schema
}
pub fn __agent_loop_next_tool_claim_receipt(
agent: HarnessAgent,
session_id,
opts,
iteration_index,
) -> nil {
if !(opts?._next_tool_claim_applied ?? false) {
return nil
}
const claim = opts?._next_tool_claim
agent_emit_event(
agent,
session_id,
"typed_checkpoint",
{
schema: "harn.agent_next_tool_claim_receipt.v1",
kind: "next_tool_claim_applied",
receipt_kind: "next_tool_claim_applied",
status: "applied",
iteration: iteration_index + 1,
tool_name: claim?.tool_name ?? "",
source: claim?.source ?? "post_turn_callback",
},
)
}
pub fn __turn_llm_opts(harness: Harness, session, opts, iteration_index) -> dict {
return __agent_loop_effective_llm_options(harness.llm, opts)
}
pub fn __agent_loop_effective_llm_options(llm: HarnessLlm, opts) {
const base = opts ?? {}
let merged = agent_merge_llm_options(base, __agent_loop_llm_overrides(base))
const claim_schema = __agent_loop_next_tool_output_contract(merged)
if claim_schema != nil {
merged = merged
+ {
output: {schema: claim_schema},
_next_tool_claim_applied: true,
// JSON Schema constrains a text response to the canonical bare call
// envelope regardless of the ambient tool dialect. Result projection
// consumes this marker so parser and contract cannot diverge.
_next_tool_claim_parser_format: "json",
}
}
const call_opts = if (merged?._next_tool_claim_applied ?? false)
|| (merged?._output_contract_repair
?? false) {
merged
} else {
__agent_loop_ordinary_turn_llm_options(merged)
}
return agent_sanitize_model_options(llm, agent_refresh_tool_format_for_route(llm, call_opts))
+ {
mock_scope: call_opts?.mock_scope ?? call_opts?.call_role ?? "agent.main",
}
}
pub fn __agent_loop_route_options(provider, model, tool_format) {
return {
provider: to_string(provider ?? ""),
model: to_string(model ?? ""),
tool_format: to_string(tool_format ?? ""),
}
}
pub fn __agent_loop_enable_equivalent_failover(
llm_opts,
primary_provider,
primary_model,
loop_opts,
) {
const provider = to_string(llm_opts?.provider ?? "")
const model = to_string(llm_opts?.model ?? "")
const has_primary = primary_provider != "" || primary_model != ""
const has_current = provider != "" || model != ""
const partial_route_patch = (loop_opts?._agent_loop_last_llm_route_patch_seen ?? false)
&& !(loop_opts
?._agent_loop_last_llm_route_patch_complete
?? false)
const changed_partial_route = has_primary && has_current
&& (provider != primary_provider
|| model
!= primary_model)
&& partial_route_patch
return llm_enable_equivalent_failover(llm_opts, changed_partial_route)
}
pub fn __agent_loop_finalize_failed(agent: HarnessAgent, session, iteration) {
try {
agent_session_finalize(
agent,
session.session_id,
{final_status: "failed", stop_reason: "error", iterations: iteration},
)
} catch (e) {
}
}
pub fn __agent_loop_current_worker(agents: HarnessAgent, runtime: HarnessRuntime) {
const ctx = runtime.context()
const worker_id = ctx?.worker_id
if type_of(worker_id) != "string" || worker_id == "" {
return nil
}
for worker in list_agents(agents) {
if worker?.id == worker_id {
return worker
}
}
return nil
}
pub fn __agent_loop_suspend_reminder_body(reason) {
if type_of(reason) == "string" && reason != "" {
return "Worker suspended before the next turn: " + reason
}
return "Worker suspended before the next turn."
}
pub fn __agent_loop_suspend_initiator(value) {
let text = to_string(value ?? "operator")
if text == "self_initiated" {
return "self"
}
return text
}
pub fn __agent_loop_suspend_checkpoint(
agent: HarnessAgent,
runtime: HarnessRuntime,
session,
iteration,
) {
const worker = __agent_loop_current_worker(agent, runtime)
if worker == nil || worker?.status != "suspended" {
return nil
}
const suspension = worker?.suspension ?? {}
const reason = to_string(suspension?.reason ?? "")
const initiator = __agent_loop_suspend_initiator(suspension?.initiator)
const conditions = suspension?.conditions
const payload = {
status: "suspended",
handle: worker,
worker: worker,
reason: reason,
initiator: initiator,
conditions: conditions,
iterations_completed: iteration,
session_id: session.session_id,
}
agent.inject(
session.session_id,
transcript_reminder_event(
{
body: __agent_loop_suspend_reminder_body(reason),
source: "in_pipeline",
tags: ["agent_loop", "worker_suspend"],
dedupe_key: "worker_suspend:" + worker.id,
ttl_turns: 1,
fired_at_turn: iteration + 1,
},
),
)
return payload
}
pub fn __agent_loop_with_llm_render_context(harness: Harness, opts, render) {
const effective = __agent_loop_effective_llm_options(harness.llm, opts)
const provider = to_string(effective?.provider ?? "")
const model = to_string(effective?.model ?? "")
const pushed = harness.agent.push_llm_render_context(provider, model)
defer {
if pushed {
harness.agent.pop_llm_render_context()
}
}
return render(harness, effective)
}
pub fn __agent_loop_build_turn_prompt(harness: Harness, session, opts, iteration) {
const append_only = if type_of(opts?.reminders) == "dict"
&& opts.reminders?.append_only != nil {
opts.reminders.append_only
} else {
env_bool(harness.env, "HARN_REMINDERS_APPEND_ONLY", false)
}
if append_only {
// Commit the active directives into one durable trailing user message
// before this turn's history is read, so every later request re-sends those
// exact bytes at the same index instead of moving the envelope.
let _ = agent_session_commit_directives(harness.agent, session.session_id)
}
return __agent_loop_with_llm_render_context(
harness,
opts,
{ render_harness, effective ->
const fragments = agent_build_turn_system_fragments(
render_harness,
session,
effective,
iteration,
)
let parts = []
for fragment in fragments {
parts = parts.appending(fragment.body)
}
const prompt_opts = effective + {_reminders_append_only: append_only}
return {
fragments: fragments,
system: join(parts, "\n\n"),
messages: agent_build_turn_messages(
render_harness.agent,
render_harness.clock,
session,
prompt_opts,
iteration,
),
}
},
)
}