harn-stdlib 0.8.39

Embedded Harn standard library source catalog
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

type ToolRegistry = {_type: "tool_registry", tools: list<dict>}

type ToolDefinitionConfig = {
  parameters?: dict,
  returns?: dict,
  output_schema?: dict,
  handler?: any,
  executor?: string,
  host_capability?: string,
  mcp_server?: string,
  defer_loading?: bool,
  namespace?: string,
  annotations?: dict,
}

type ToolDefinitionSpec = {
  name: string,
  description?: string,
  desc?: string,
  config?: ToolDefinitionConfig,
  parameters?: dict,
  returns?: dict,
  output_schema?: dict,
  handler?: any,
  executor?: string,
  host_capability?: string,
  mcp_server?: string,
  defer_loading?: bool,
  namespace?: string,
  annotations?: dict,
}

type PathScopeMatcherOptions = {
  scope?: string,
  arg_keys?: list<string>,
  mount_modes?: list<string>,
  on_violation?: string,
  patterns?: list<string>,
}?

/**
 * path_scope returns a dynamic-permissions matcher that checks path args
 * against the active session workspace anchor.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: experimental
 * @example: path_scope({mount_modes: ["extend"]})
 */
pub fn path_scope(options: PathScopeMatcherOptions = nil) -> dict {
  let opts = options ?? {}
  var matcher = {
    type: "path_scope",
    scope: opts?.scope ?? "anchor_plus_mounted",
    arg_keys: opts?.arg_keys ?? ["path", "destination", "source", "file"],
    on_violation: opts?.on_violation ?? "deny",
  }
  if opts?.mount_modes != nil {
    matcher = matcher + {mount_modes: opts.mount_modes}
  }
  if opts?.patterns != nil {
    matcher = matcher + {patterns: opts.patterns}
  }
  return matcher
}

fn __tool_spec_config(spec: ToolDefinitionSpec) -> ToolDefinitionConfig {
  if type_of(spec) != "dict" {
    throw "tool_define_many: each spec must be a dict"
  }
  var config = spec.config ?? {}
  for key in spec.keys() {
    if !contains(["name", "description", "desc", "config"], key) {
      config = config + {[key]: spec[key]}
    }
  }
  return config
}

/**
 * tool_define_many adds a list of tool specs to a registry.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: tool_define_many(registry, specs)
 */
pub fn tool_define_many(registry, specs: list<ToolDefinitionSpec>? = nil) -> ToolRegistry {
  var target = registry
  var items = specs
  if items == nil {
    target = tool_registry()
    items = registry
  }
  if type_of(items) != "list" {
    throw "tool_define_many: specs must be a list"
  }
  var tools = target ?? tool_registry()
  for spec in items {
    let name = spec.name
    let description = spec.description ?? spec.desc
    if name == nil || name == "" {
      throw "tool_define_many: each spec needs a non-empty name"
    }
    if description == nil || description == "" {
      throw "tool_define_many: each spec needs a non-empty description"
    }
    tools = tool_define(tools, name, description, __tool_spec_config(spec))
  }
  return tools
}

/**
 * tool_registry_from creates a registry from a list of tool specs.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: tool_registry_from(specs)
 */
pub fn tool_registry_from(specs: list<ToolDefinitionSpec>) -> ToolRegistry {
  return tool_define_many(tool_registry(), specs)
}