harn-stdlib 0.8.18

import { agent_typed_output_checkpoint } from "std/agent/primitives"
import { completion_judge_user_prompt } from "std/agent/prompts"
import {
  agent_emit_event,
  agent_session_inject_feedback,
  agent_session_messages,
} from "std/agent/state"

fn __unique_names(names) {
  var unique = []
  for name in names {
    if name != "" && !contains(unique, name) {
      unique = unique.push(name)
    }
  }
  return unique
}

fn __session_tool_names(messages) {
  var names = []
  for message in messages {
    if message?.role == "tool" {
      names = names.push(message?.name ?? "")
    }
  }
  return __unique_names(names)
}

fn __judge_payload(session, opts, stop_reason, text, iteration) {
  let messages = agent_session_messages(session.session_id)
  let tool_names = __session_tool_names(messages)
  return {
    session_id: session.session_id,
    task: session?.task ?? "",
    stop_reason: stop_reason,
    text: text,
    visible_text: text,
    last_text: text,
    transcript: json_stringify(messages),
    all_tools_used: join(tool_names, ", "),
    successful_tools_used: join(tool_names, ", "),
    iteration: iteration,
  }
}

fn __judge_invoke_closure(verify_completion, payload) {
  let result = verify_completion(payload)
  if result == nil || result == "" {
    return {vetoed: false}
  }
  if type_of(result) == "bool" {
    return {vetoed: !result}
  }
  if type_of(result) == "string" {
    return {vetoed: true, feedback: result}
  }
  if type_of(result) == "dict" {
    let confirm = result?.confirm ?? false
    let message = result?.message ?? result?.feedback
    return {vetoed: !confirm, feedback: message}
  }
  return {vetoed: false}
}

fn __judge_invoke_structured(judge_cfg, opts, payload) {
  let system = judge_cfg?.system ?? ""
  let user = completion_judge_user_prompt(payload)
  let schema = {
    type: "object",
    properties: {
      verdict: {type: "string", description: "Use `done` or `continue`."},
      reasoning: {type: "string"},
      next_step: {type: "string"},
    },
    required: ["verdict"],
  }
  let base = opts?.llm_options ?? {}
  var llm_opts = base
    + {
    model: judge_cfg?.model ?? opts?.model,
    provider: judge_cfg?.provider ?? opts?.provider,
    output_schema: schema,
    session_id: payload.session_id,
    system: system,
  }
  for key in ["temperature", "max_tokens", "top_p", "tool_format", "reasoning_effort"] {
    if judge_cfg[key] != nil {
      llm_opts[key] = judge_cfg[key]
    }
  }
  let started = monotonic_ms()
  let checkpoint = agent_typed_output_checkpoint("agent.completion_judge", user, schema, llm_opts)
  let duration_ms = monotonic_ms() - started
  if !checkpoint.ok {
    if judge_cfg?.fail_open_on_error ?? judge_cfg?.fail_open ?? false {
      return {
        vetoed: false,
        verdict: "done",
        reasoning: checkpoint.error,
        next_step: "",
        judge_duration_ms: duration_ms,
        typed_checkpoint: checkpoint,
      }
    }
    return {
      vetoed: true,
      feedback: checkpoint.error,
      verdict: "continue",
      reasoning: checkpoint.error,
      next_step: checkpoint.error,
      judge_duration_ms: duration_ms,
      typed_checkpoint: checkpoint,
    }
  }
  let result = checkpoint.data
  let verdict = lowercase(trim(to_string(result?.verdict ?? "continue")))
  let reasoning = result?.reasoning ?? ""
  let next_step = result?.next_step ?? ""
  let done_verdicts = ["done", "pass", "passed", "safe", "true", "yes", "yield", "yield_to_user", "complete", "completed"]
  let outcome = if contains(done_verdicts, verdict) {
    {vetoed: false}
  } else {
    let feedback = result?.next_step ?? result?.reasoning
      ?? (judge_cfg?.feedback_fallback ?? "")
    {vetoed: true, feedback: feedback}
  }
  return outcome
    + {
    verdict: verdict,
    reasoning: reasoning,
    next_step: next_step,
    judge_duration_ms: duration_ms,
    typed_checkpoint: checkpoint,
  }
}

fn __emit_judge_decision(session_id, iteration, verdict) {
  agent_emit_event(
    session_id,
    "judge_decision",
    {
      iteration: iteration,
      verdict: verdict?.verdict
        ?? if verdict.vetoed {
        "continue"
      } else {
        "done"
      },
      reasoning: verdict?.reasoning ?? "",
      next_step: verdict?.next_step ?? "",
      judge_duration_ms: verdict?.judge_duration_ms ?? 0,
      trigger: verdict?.trigger ?? nil,
    },
  )
}

/** agent_verify_or_continue. */
pub fn agent_verify_or_continue(session, opts, stop_reason, text, iteration = 0) {
  let payload = __judge_payload(session, opts, stop_reason, text, iteration)
  var verdict = {vetoed: false}
  if opts?.verify_completion != nil {
    verdict = __judge_invoke_closure(opts.verify_completion, payload)
  }
  if !verdict.vetoed && opts?.verify_completion_judge != nil {
    verdict = __judge_invoke_structured(opts.verify_completion_judge, opts, payload)
    __emit_judge_decision(session.session_id, iteration, verdict)
  }
  let done_judge_due = opts?._done_judge_due ?? true
  let done_judge_applies = opts?.done_judge != nil
    && (stop_reason == "sentinel" || stop_reason == "natural" || stop_reason == "stalled")
    && done_judge_due
  if !verdict.vetoed && done_judge_applies {
    verdict = __judge_invoke_structured(opts.done_judge, opts, payload)
    verdict = verdict + {done_judge_invoked: true, trigger: opts?._done_judge_trigger ?? nil}
    __emit_judge_decision(session.session_id, iteration, verdict)
  }
  if verdict.vetoed && verdict?.feedback != nil && verdict.feedback != "" {
    agent_session_inject_feedback(session.session_id, "verify_completion", verdict.feedback)
  }
  return verdict
}