harn-vm 0.7.0

Async bytecode virtual machine for the Harn programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

import "std/collections"

/** clip_text. */
pub fn clip_text(text, max_chars) {
  if max_chars == nil || max_chars <= 0 {
    return text
  }
  if len(text) <= max_chars {
    return text
  }
  if max_chars <= 16 {
    return text.substring(0, max_chars)
  }
  return text.substring(0, max_chars - 15) + "\n...[truncated]"
}

/** render_section. */
pub fn render_section(section, include_headers, section_max_chars) {
  if section == nil || section?.enabled == false {
    return ""
  }
  let content = section?.content ?? ""
  if content == "" {
    return ""
  }
  let body = clip_text(content, section?.max_chars ?? section_max_chars)
  if include_headers == false || section?.name == nil || section?.name == "" {
    return body
  }
  return "[" + section?.name + "]\n" + body
}

/** context_section. */
pub fn context_section(name, content, options) {
  let opts = options ?? {}
  return filter_nil({
    _type: "context_section",
    name: name,
    content: content,
    kind: opts?.kind,
    path: opts?.path,
    priority: opts?.priority,
    max_chars: opts?.max_chars,
    enabled: opts?.enabled
  })
}

/** section. */
pub fn section(name, content, options) {
  return context_section(name, content, options)
}

/** context_attach. */
pub fn context_attach(name, path, content, options) {
  let opts = options ?? {}
  return context_section(name, "Path: " + path + "\n\n" + content, opts + {
    kind: opts?.kind ?? "attachment",
    path: path
  })
}

/** context. */
pub fn context(sections, options) {
  let opts = options ?? {}
  return filter_nil({
    _type: "context",
    sections: sections ?? [],
    separator: opts?.separator ?? "\n\n",
    include_headers: opts?.include_headers,
    max_chars: opts?.max_chars,
    section_max_chars: opts?.section_max_chars
  })
}

/** context_add. */
pub fn context_add(ctx, new_section) {
  let sections = (ctx?.sections ?? []) + [new_section]
  return context(sections, ctx)
}

/** context_render. */
pub fn context_render(ctx, options) {
  let opts = (ctx ?? {}) + (options ?? {})
  let separator = opts?.separator ?? "\n\n"
  let max_chars = opts?.max_chars
  let section_max_chars = opts?.section_max_chars
  let include_headers = opts?.include_headers != false

  var pieces = []
  var used = 0
  var section_text = ""
  var remaining = nil
  var clipped = ""
  for sec in opts?.sections ?? [] {
    section_text = render_section(sec, include_headers, section_max_chars)
    if section_text == "" {
      continue
    }
    remaining = if max_chars == nil { nil } else { max_chars - used }
    if remaining != nil && remaining <= 0 {
      break
    }
    clipped = clip_text(section_text, remaining)
    pieces = pieces + [clipped]
    used = used + len(clipped) + len(separator)
  }
  return join(pieces, separator)
}

/** context_compact. */
pub fn context_compact(ctx, options) {
  let opts = (ctx ?? {}) + (options ?? {})
  return context(opts?.sections ?? [], {
    separator: opts?.separator,
    include_headers: opts?.include_headers,
    max_chars: opts?.max_chars,
    section_max_chars: opts?.section_max_chars
  })
}

/** prompt_compose. */
pub fn prompt_compose(task, ctx, options) {
  let opts = options ?? {}
  let rendered = context_render(ctx, opts)
  let task_label = opts?.task_label ?? "Task"
  let prompt = "<workflow_task>\n<label>"
    + task_label
    + "</label>\n<instructions>\n"
    + task
    + "\n</instructions>\n</workflow_task>"
    + if rendered == "" {
      ""
    } else {
      "\n\n<workflow_context>\n" + rendered + "\n</workflow_context>"
    }
    + "\n\n<workflow_response_contract>\n"
    + "Respond to the workflow task above. Do not continue the trailing artifact text verbatim. Keep commentary minimal and use the active tool-calling contract for concrete progress.\n"
    + "</workflow_response_contract>"
  return filter_nil({
    prompt: prompt,
    system: opts?.system,
    rendered_context: rendered,
    context: ctx
  })
}