harn-stdlib 0.8.1

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// @harn-entrypoint-category llm.stdlib
//
// std/llm/catalog — thin Harn wrappers over the runtime model catalog.
//
// The wrapper functions intentionally use shorter, idiomatic names
// (`model_info`, `resolved_options`) instead of the underlying builtin
// names (`llm_model_info`, `llm_resolved_options`) so that wrapping
// does not shadow the builtin and recurse infinitely.
/**
 * Wraps the llm_model_info(selector) Rust builtin. The runtime always
 * returns a dict; when the selector is unknown, the dict's `catalog`
 * field will be nil and the inferred provider will be the default.
 */
pub fn model_info(selector) {
  return llm_model_info(selector)
}

/** Wraps llm_resolved_options(opts). opts.model is required; throws otherwise. */
pub fn resolved_options(opts) {
  if type_of(opts) != "dict" {
    throw "resolved_options: opts must be a dict"
  }
  if opts?.model == nil || opts.model == "" {
    throw "resolved_options: opts.model is required"
  }
  return llm_resolved_options(opts)
}

fn __capability_field(caps, capability) {
  if capability == "thinking" {
    let direct = caps?.thinking ?? false
    let modes = caps?.thinking_modes ?? []
    return direct || len(modes) > 0
  }
  if capability == "tool_search" {
    return len(caps?.tool_search ?? []) > 0
  }
  if capability == "vision" {
    return caps?.vision_supported ?? false
  }
  if capability == "files_api" {
    return caps?.files_api_supported ?? false
  }
  if capability == "reasoning_effort" {
    return caps?.reasoning_effort_supported ?? false
  }
  if capability == "interleaved_thinking" {
    return caps?.interleaved_thinking_supported ?? false
  }
  if capability == "prompt_caching" {
    return caps?.prompt_caching ?? false
  }
  if capability == "native_tools" {
    return caps?.native_tools ?? false
  }
  if capability == "audio" {
    return caps?.audio ?? false
  }
  if capability == "pdf" {
    return caps?.pdf ?? false
  }
  return false
}

/**
 * True if (model, capability) is supported per the runtime catalog.
 * capability is one of: "thinking", "tool_search", "interleaved_thinking",
 * "prompt_caching", "vision", "audio", "pdf", "files_api",
 * "reasoning_effort", "native_tools". Returns false on unknown model.
 */
pub fn has_capability(model, capability) {
  let info = llm_model_info(model)
  if type_of(info) != "dict" {
    return false
  }
  let caps = info?.capabilities
  if type_of(caps) != "dict" {
    return false
  }
  return __capability_field(caps, capability)
}

fn __family_for_anthropic(id) {
  if contains(id, "haiku") {
    return "anthropic_haiku"
  }
  if contains(id, "opus-4-7") || contains(id, "opus-mythos") {
    return "anthropic_opus_adaptive"
  }
  return "anthropic_sonnet_opus"
}

fn __family_for_openai(id) {
  if starts_with(id, "gpt-5") {
    return "openai_gpt5_family"
  }
  return "openai_legacy"
}

fn __family_for_gemini(id) {
  if contains(id, "flash") {
    return "gemini_flash"
  }
  return "gemini_pro"
}

fn __family_for_ollama(id) {
  if contains(id, "qwen") {
    return "ollama_qwen3"
  }
  return "ollama_generic"
}

/**
 * Best-effort family classifier. Returns one of:
 * "anthropic_haiku", "anthropic_opus_adaptive", "anthropic_sonnet_opus",
 * "openai_gpt5_family", "openai_legacy", "gemini_flash", "gemini_pro",
 * "ollama_qwen3", "ollama_generic", or "generic".
 */
pub fn family_of(model_id) {
  let info = llm_model_info(model_id)
  if type_of(info) != "dict" {
    return "generic"
  }
  let provider = lowercase(to_string(info?.provider ?? ""))
  let id = lowercase(to_string(model_id))
  if provider == "anthropic" {
    return __family_for_anthropic(id)
  }
  if provider == "openai" {
    return __family_for_openai(id)
  }
  if provider == "gemini" {
    return __family_for_gemini(id)
  }
  if provider == "ollama" {
    return __family_for_ollama(id)
  }
  return "generic"
}