import "std/collections"
import "std/context"
/** workflow_model_spec. */
pub fn workflow_model_spec(config) {
let target = config?.model ?? config?.model_alias ?? config?.model_tier ?? config?.tier
if target == nil || target == "" {
return nil
}
return llm_pick_model(target, filter_nil({provider: config?.provider}))
}
/** workflow_options. */
pub fn workflow_options(config) {
let spec = workflow_model_spec(config)
return filter_nil({
provider: config?.provider ?? spec?.provider,
model: config?.model ?? spec?.id,
max_tokens: config?.max_tokens,
temperature: config?.temperature,
top_p: config?.top_p,
top_k: config?.top_k,
stop: config?.stop,
seed: config?.seed,
frequency_penalty: config?.frequency_penalty,
presence_penalty: config?.presence_penalty,
response_format: config?.response_format,
schema: config?.schema,
thinking: config?.thinking,
tools: config?.tools,
tool_choice: config?.tool_choice,
cache: config?.cache,
timeout: config?.timeout,
persistent: config?.persistent,
max_iterations: config?.max_iterations,
max_nudges: config?.max_nudges,
nudge: config?.nudge,
turn_policy: config?.turn_policy,
stop_after_successful_tools: config?.stop_after_successful_tools,
require_successful_tools: config?.require_successful_tools,
tool_retries: config?.tool_retries,
tool_backoff_ms: config?.tool_backoff_ms,
tool_format: config?.tool_format,
context_callback: config?.context_callback ?? config?.context_filter,
transcript: config?.transcript
})
}
/** stage_config. */
pub fn stage_config(flow, overrides, stage_name) {
let combined = (flow ?? {}) + (overrides ?? {})
let stage = combined[stage_name] ?? {}
let merged = combined + stage
return filter_nil(merged + {_stage: stage_name})
}
/** stage_prompt. */
pub fn stage_prompt(task, config) {
let ctx = config?.context
return prompt_compose(task, ctx, filter_nil({
system: config?.system,
task_label: config?.task_label,
separator: config?.context_separator,
max_chars: config?.context_max_chars,
section_max_chars: config?.context_section_max_chars
}))
}
/** run_stage. */
pub fn run_stage(task, config) {
let prompt = stage_prompt(task, config)
let opts = workflow_options(config)
if config?.mode == "completion" {
return llm_completion(prompt?.prompt, config?.suffix, prompt?.system, opts)
}
if config?.mode == "llm" || config?.persistent == false {
return llm_call(prompt?.prompt, prompt?.system, opts)
}
return agent_loop(prompt?.prompt, prompt?.system, opts + {
persistent: config?.persistent ?? true
})
}
/** verify_command. */
pub fn verify_command(config) {
if config?.command == nil || config?.command == "" {
return nil
}
let output = host_call("process.exec", {command: config?.command})
var ok = output?.success == true
if config?.expect_status != nil {
ok = output?.status == config?.expect_status
}
if config?.expect_text != nil {
ok = ok && contains(output?.combined ?? "", config?.expect_text)
}
return {
kind: "command",
ok: ok,
output: output
}
}
/** verify_result. */
pub fn verify_result(task, result, config) {
if config == nil {
return nil
}
if config?.command != nil {
return verify_command(config)
}
if config?.assert_text != nil {
return {
kind: "text",
ok: contains(result?.text ?? "", config?.assert_text),
output: result?.text ?? ""
}
}
return nil
}
/** repair_task. */
pub fn repair_task(original_task, verification, config) {
if config?.prompt != nil {
return config?.prompt
}
let summary = json_stringify(verification)
let message = "The previous attempt did not pass verification.\n\nVerification:\n" + summary + "\n\nContinue working on the original task and fix the problem.\n\nOriginal task:\n" + original_task
return message
}
/** workflow. */
pub fn workflow(config) {
return workflow_graph(config ?? {})
}
/** task_run. */
pub fn task_run(task, flow, overrides) {
let graph = workflow_graph(flow ?? {})
let runtime = workflow_execute(task, graph, overrides?.artifacts ?? [], overrides)
let stages = runtime?.run?.stages ?? []
var act = nil
var verify = nil
var repair = nil
let artifacts = runtime?.artifacts ?? []
let latest_text = if len(artifacts) > 0 {
artifacts[len(artifacts) - 1]?.text
} else {
act?.visible_text
}
for stage in stages {
if act == nil {
act = stage
continue
}
if verify == nil && (stage?.node_id == "verify" || stage?.kind == "verify") {
verify = stage
continue
}
if repair == nil && stage?.node_id == "repair" {
repair = stage
}
}
let status = if verify?.status == "failed" || repair != nil {
"needs_attention"
} else {
runtime?.status ?? "completed"
}
return {
task: task,
workflow: graph?.name ?? "workflow",
status: status,
text: latest_text,
result: runtime,
act: act,
repair: repair,
verification: verify,
final_verification: verify,
transcript: runtime?.transcript,
run: runtime?.run,
artifacts: artifacts
}
}
/** workflow_continue. */
pub fn workflow_continue(prev, task, flow, overrides) {
let transcript = prev?.transcript ?? prev
let merged = (overrides ?? {}) + {transcript: transcript}
return task_run(task, flow, merged)
}
/** workflow_result_text. */
pub fn workflow_result_text(result) {
let raw = if type_of(result) == "string" {
result
} else {
result?.visible_text ?? result?.text ?? result?.result?.text ?? ""
}
if raw == nil || raw == "" {
return ""
}
if type_of(raw) == "string" {
return raw
}
return json_stringify(raw)
}
/** workflow_result_transcript. */
pub fn workflow_result_transcript(task, workflow_name, result, metadata) {
let existing = result?.run?.transcript ?? result?.transcript ?? result?.result?.transcript
if existing {
return existing
}
var built = transcript((metadata ?? {}) + {workflow: workflow_name})
if task {
built = add_user(
built,
[{type: "text", text: task, visibility: "public"}],
)
}
let text = workflow_result_text(result)
if text {
built = add_assistant(
built,
[{type: "output_text", text: text, visibility: "public"}],
)
}
return built
}
/** workflow_result_run. */
pub fn workflow_result_run(task, workflow_name, result, artifacts, options) {
let base_run = if result?._type == "run_record" {
result
} else {
result?.run ?? {}
}
let text = workflow_result_text(result)
let metadata = (base_run?.metadata ?? {}) + (options?.metadata ?? {})
let transcript = if result?.run?.transcript ?? result?.transcript ?? result?.result?.transcript {
result?.run?.transcript ?? result?.transcript ?? result?.result?.transcript
} else {
var built = transcript((metadata ?? {}) + {workflow: workflow_name})
if task {
built = add_user(
built,
[{type: "text", text: task, visibility: "public"}],
)
}
if text {
built = add_assistant(
built,
[{type: "output_text", text: text, visibility: "public"}],
)
}
built
}
var run_artifacts = base_run?.artifacts ?? result?.artifacts ?? artifacts ?? []
var has_visible_result_artifact = false
if text {
for item in run_artifacts {
if item?.text == text {
has_visible_result_artifact = true
}
}
if !has_visible_result_artifact {
run_artifacts = run_artifacts + [
artifact(
{
kind: "summary",
title: "Visible result",
text: text,
source: workflow_name,
freshness: "fresh",
relevance: 1.0,
metadata: {visibility: "public"},
},
),
]
}
}
return run_record(
base_run + {
workflow_id: base_run?.workflow_id ?? workflow_name,
workflow_name: base_run?.workflow_name ?? workflow_name,
task: task,
status: options?.status ?? base_run?.status ?? "completed",
transcript: transcript,
artifacts: run_artifacts,
trace_spans: trace_spans(),
metadata: metadata,
},
)
}
/** workflow_result_persist. */
pub fn workflow_result_persist(task, workflow_name, result, artifacts, options) {
let base_run = if result?._type == "run_record" {
result
} else {
result?.run ?? {}
}
let text = workflow_result_text(result)
let metadata = (base_run?.metadata ?? {}) + (options?.metadata ?? {})
let transcript = if result?.run?.transcript ?? result?.transcript ?? result?.result?.transcript {
result?.run?.transcript ?? result?.transcript ?? result?.result?.transcript
} else {
var built = transcript((metadata ?? {}) + {workflow: workflow_name})
if task {
built = add_user(
built,
[{type: "text", text: task, visibility: "public"}],
)
}
if text {
built = add_assistant(
built,
[{type: "output_text", text: text, visibility: "public"}],
)
}
built
}
var run_artifacts = base_run?.artifacts ?? result?.artifacts ?? artifacts ?? []
var has_visible_result_artifact = false
if text {
for item in run_artifacts {
if item?.text == text {
has_visible_result_artifact = true
}
}
if !has_visible_result_artifact {
run_artifacts = run_artifacts + [
artifact(
{
kind: "summary",
title: "Visible result",
text: text,
source: workflow_name,
freshness: "fresh",
relevance: 1.0,
metadata: {visibility: "public"},
},
),
]
}
}
let run = run_record(
base_run + {
workflow_id: base_run?.workflow_id ?? workflow_name,
workflow_name: base_run?.workflow_name ?? workflow_name,
task: task,
status: options?.status ?? base_run?.status ?? "completed",
transcript: transcript,
artifacts: run_artifacts,
trace_spans: trace_spans(),
metadata: metadata,
},
)
let persisted = run_record_save(run, options?.path)
return {
path: persisted?.path,
persisted_path: persisted?.path,
run: persisted?.run,
status: persisted?.run?.status ?? "completed",
transcript: persisted?.run?.transcript,
artifacts: persisted?.run?.artifacts ?? [],
visible_text: text,
}
}
/** workflow_session. */
pub fn workflow_session(prev) {
let transcript = prev?.transcript ?? prev?.result?.transcript ?? prev
let run = prev?.run ?? prev?.result?.run
let persisted_path = prev?.persisted_path ?? prev?.path ?? run?.persisted_path
return {
_type: "workflow_session",
transcript: transcript,
run: run,
persisted_path: persisted_path,
status: prev?.status ?? run?.status ?? transcript?.state ?? "active",
workflow: prev?.workflow ?? run?.workflow?.name,
task: prev?.task ?? run?.task,
summary: transcript_summary(transcript),
transcript_state: transcript?.state ?? "active",
message_count: len(transcript_messages(transcript)),
event_count: len(transcript_events(transcript)),
asset_count: len(transcript_assets(transcript)),
usage: run?.usage ?? prev?.usage,
}
}
/** workflow_session_new. */
pub fn workflow_session_new(metadata) {
return workflow_session(
{
status: "active",
transcript: transcript(metadata ?? {}),
},
)
}
/** workflow_session_restore. */
pub fn workflow_session_restore(source) {
let run = if type_of(source) == "string" {
run_record_load(source)
} else {
source?.run ?? source
}
return workflow_session(
{
status: run?.status ?? "restored",
run: run,
persisted_path: run?.persisted_path,
transcript: run?.transcript ?? transcript(),
},
)
}
/** workflow_session_fork. */
pub fn workflow_session_fork(prev) {
let session = workflow_session(prev)
return workflow_session(session + {transcript: transcript_fork(session?.transcript)})
}
/** workflow_session_archive. */
pub fn workflow_session_archive(prev) {
let session = workflow_session(prev)
return workflow_session(
session + {
status: "archived",
transcript: transcript_archive(session?.transcript),
},
)
}
/** workflow_session_resume. */
pub fn workflow_session_resume(prev) {
let session = workflow_session(prev)
return workflow_session(
session + {
status: "active",
transcript: transcript_resume(session?.transcript),
},
)
}
/** workflow_compact. */
pub fn workflow_compact(prev, options) {
let transcript = prev?.transcript ?? prev
return transcript_summarize(transcript, options)
}
/** workflow_session_compact. */
pub fn workflow_session_compact(prev, options) {
let session = workflow_session(prev)
return workflow_session(
session + {
transcript: transcript_summarize(session?.transcript, options),
},
)
}
/** workflow_reset. */
pub fn workflow_reset(prev, carry_summary) {
let transcript = prev?.transcript ?? prev
if carry_summary && transcript_summary(transcript) {
return transcript_compact(transcript, {keep_last: 0})
}
return transcript()
}
/** workflow_session_reset. */
pub fn workflow_session_reset(prev, carry_summary) {
let session = workflow_session(prev)
return workflow_session(
{
workflow: session?.workflow,
status: "active",
transcript: workflow_reset(session?.transcript, carry_summary),
},
)
}
/** workflow_session_persist. */
pub fn workflow_session_persist(prev, path) {
let session = workflow_session(prev)
if session?.run == nil {
return session
}
let persisted = run_record_save(session?.run, path)
return workflow_session(
session + {
run: persisted?.run,
persisted_path: persisted?.path,
},
)
}