From b33fda56d3c76bc3887780be5321e0b8f9810356 Mon Sep 17 00:00:00 2001 From: 2kai2kai2 Date: Wed, 12 Aug 2026 14:23:23 -0700 Subject: [PATCH 1/5] Add `Read` and `Write` interfaces --- .../baml_std/baml/ns_io/read.baml | 27 + .../baml_std/baml/ns_io/write.baml | 9 + .../crates/baml_builtins2/src/lib.rs | 2 + ...tests__render_builtin_package_listing.snap | 2 + ...ests__compiles____baml_std____03_ppir.snap | 13 + ...sts__compiles____baml_std____04_5_mir.snap | 110 + ...tests__compiles____baml_std____04_tir.snap | 3493 ++ ...s__compiles____baml_std____06_codegen.snap | 50 + ...__phase5__snapshot_baml_package_items.snap | 2 + ..._type_spec__sweep__s15_sweep_baml_src.snap | 2 - .../crates/baml_tests/src/type_spec/sweep.rs | 17 +- .../bytecode_format/bytecode_display.baml | 106 - .../baml_tests/tests/bytecode_format/main.rs | 47 - ...ode_format__bytecode_display_expanded.snap | 33503 --------------- ...bytecode_display_expanded_unoptimized.snap | 34387 --------------- ...code_format__bytecode_display_textual.snap | 35251 ---------------- 16 files changed, 3712 insertions(+), 103309 deletions(-) create mode 100644 baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml create mode 100644 baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml create mode 100644 baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap delete mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/bytecode_display.baml delete mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/main.rs delete mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap delete mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap delete mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_textual.snap diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml new file mode 100644 index 00000000000..d11b6a0a722 --- /dev/null +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml @@ -0,0 +1,27 @@ +interface Read { + /// Read some bytes from the source. + /// When the end of the source has already been reached, returns `null`. + /// + /// The `limit` parameter specifies the maximum number of bytes to read. + /// + /// This is the only method that implementors are required to provide. + function read(self, limit: int) -> uint8array? throws root.errors.Io + + /// Reads all remaining bytes from the source until EOF is reached. + function read_to_end(self) -> uint8array throws root.errors.Io { + let buf = b""; + while let chunk: uint8array = self.read(int.max_value()) { + buf = buf.concat(chunk); + } + buf + } + + /// Reads all remaining bytes as a UTF-8 string until EOF is reached. + /// If the source is not valid UTF-8, an error is thrown. + function read_to_string(self) -> string throws root.errors.Io | root.errors.ParseError { + let buf = self.read_to_end(); + string.from_utf8(buf) catch (_) { + _ => throw root.errors.ParseError { message: "invalid utf-8" }, + } + } +} diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml new file mode 100644 index 00000000000..75e21cb0692 --- /dev/null +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml @@ -0,0 +1,9 @@ +interface Write { + /// Write some bytes to the destination. + /// + /// Returns the number of bytes successfully written. + function write(self, data: uint8array) -> int throws root.errors.Io + + /// Flush any buffered data to the destination. + function flush(self) -> void throws root.errors.Io +} diff --git a/baml_language/crates/baml_builtins2/src/lib.rs b/baml_language/crates/baml_builtins2/src/lib.rs index 6650083e18e..ce266e6c90e 100644 --- a/baml_language/crates/baml_builtins2/src/lib.rs +++ b/baml_language/crates/baml_builtins2/src/lib.rs @@ -105,6 +105,8 @@ pub const ALL: &[BuiltinFile] = &[ builtin!("baml", "ns_panics/panics.baml"), builtin!("baml", "ns_env/env.baml"), builtin!("baml", "ns_io/io.baml"), + builtin!("baml", "ns_io/read.baml"), + builtin!("baml", "ns_io/write.baml"), builtin!("baml", "ns_http/http.baml"), builtin!("baml", "ns_http/server.baml"), builtin!("baml", "ns_events/events.baml"), diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index 2b892f270ad..4c6c4007bc6 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -159,6 +159,8 @@ function baml.io.print /baml/ns_io/io.baml:8 function baml.io.println /baml/ns_io/io.baml:13 function baml.io.eprint /baml/ns_io/io.baml:18 function baml.io.eprintln /baml/ns_io/io.baml:23 +interface baml.io.Read /baml/ns_io/read.baml:1 +interface baml.io.Write /baml/ns_io/write.baml:1 class baml.iter.Done /baml/ns_iter/iter.baml:2 interface baml.iter.Iterable /baml/ns_iter/iter.baml:6 interface baml.iter.Iterator /baml/ns_iter/iter.baml:18 diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap index a1e73598bc3..b0ac393f1ac 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap @@ -1000,6 +1000,19 @@ function baml.io.input(prompt: string?) -> string [builtin] function baml.io.print(s: string) -> null [builtin] function baml.io.println(s: string) -> null [builtin] +--- /baml/ns_io/read.baml --- +function baml.io.read(self: ?, limit: int) -> uint8array? [missing] +function baml.io.read_to_end(self: ?) -> uint8array [expr] { + { let buf = b"<0 bytes>"; while let chunk: uint8array = self.read(int.max_value()) { buf = buf.concat(chunk) } } buf +} +function baml.io.read_to_string(self: ?) -> string [expr] { + { let buf = self.read_to_end() } string.from_utf8(buf) catch (_) { _ => throw root.errors.ParseError { message: "invalid utf-8" } } +} + +--- /baml/ns_io/write.baml --- +function baml.io.flush(self: ?) -> void [missing] +function baml.io.write(self: ?, data: uint8array) -> int [missing] + --- /baml/ns_iter/iter.baml --- class baml.iter.ArrayIterator { arr: T[] diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index d8e4add4290..4e5af863d78 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -4197,6 +4197,116 @@ fn baml.io.eprint = builtin(io) fn baml.io.eprintln = builtin(io) +fn baml.io.Read.read(_1: void, _2: void) -> void { + // Locals: + let _0: void // return + let _1: void // param + let _2: void // param + + bb0: { + unreachable; + } +} + +fn baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { + // Locals: + let _0: uint8array // _0 // return + let _1: baml.io.Read // self // param + let _2: uint8array // buf + let _3: null | uint8array + let _4: int + let _5: null | uint8array + let _6: uint8array // chunk + let _7: uint8array + + bb0: { + _2 = b"<0 bytes>"; + goto -> bb1; + } + + bb1: { + _4 = call const fn baml.Int.max_value() -> [bb2]; + } + + bb2: { + _3 = virtual_call read as baml.io.Read(copy _1, copy _4) -> [bb3]; + } + + bb3: { + _5 = copy _3; + _5 = narrow_bind copy _5 as Uint8Array { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb6, bb4]; + } + + bb4: { + _0 = copy _2; + goto -> bb5; + } + + bb5: { + return; + } + + bb6: { + fresh_cell(_6); + _6 = copy _5; + _7 = copy _6; + _2 = call const fn baml.Uint8Array.concat(copy _2, copy _7) -> [bb1]; + } +} + +fn baml.io.Read.read_to_string(self: baml.io.Read) -> string { + // Locals: + let _0: string // _0 // return + let _1: baml.io.Read // self // param + let _2: uint8array // buf + let _3: unknown // _ + let _4: uint8array + let _5: baml.errors.ParseError + + bb0: { + _2 = virtual_call read_to_end as baml.io.Read(copy _1) -> [bb1]; + } + + bb1: { + _4 = copy _2; + _0 = call const fn baml.String.from_utf8(copy _4) -> [bb2, unwind: bb3]; + } + + bb2: { + return; + } + + bb3: { + throw_if_panic copy _3 -> bb4; + } + + bb4: { + _5 = baml.errors.ParseError { const "invalid utf-8" }; + throw copy _5; + } +} + +fn baml.io.Write.write(_1: void, _2: void) -> void { + // Locals: + let _0: void // return + let _1: void // param + let _2: void // param + + bb0: { + unreachable; + } +} + +fn baml.io.Write.flush(_1: void) -> void { + // Locals: + let _0: void // return + let _1: void // param + + bb0: { + unreachable; + } +} + fn baml.iter.Iterable.iter(_1: void) -> void { // Locals: let _0: void // return diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap new file mode 100644 index 00000000000..fc6f631b0d3 --- /dev/null +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap @@ -0,0 +1,3493 @@ +--- +source: crates/baml_tests/src/generated_tests.rs +--- +=== TIR2 === + +=== TIR2 (package baml) === + +--- /baml/bigint.baml --- +class baml.Bigint { +} +class baml.Bigint$stream { +} + +--- /baml/bool.baml --- +class baml.Bool { +} +class baml.Bool$stream { +} + +--- /baml/comparable.baml --- +function baml.compare(self: unknown, other: !error) -> int throws never { + { : -1 | 1 | 0 + if (self < other : bool) : -1 | 1 | 0 + { : -1 + Neg 1 : -1 + } + else + if (self > other : bool) : 1 | 0 + { : 1 + 1 : 1 + } + else + { : 0 + 0 : 0 + } + } +} +function baml.compare(self: unknown, other: !error) -> int throws never { + { : -1 | 1 | 0 + if (self < other : bool) : -1 | 1 | 0 + { : -1 + Neg 1 : -1 + } + else + if (self > other : bool) : 1 | 0 + { : 1 + 1 : 1 + } + else + { : 0 + 0 : 0 + } + } +} +function baml.compare(self: unknown, other: !error) -> int throws never { + { : -1 | 1 | 0 + if (self < other : bool) : -1 | 1 | 0 + { : -1 + Neg 1 : -1 + } + else + if (self > other : bool) : 1 | 0 + { : 1 + 1 : 1 + } + else + { : 0 + 0 : 0 + } + } +} +function baml.sort(self: unknown) -> !error throws !error { + { : T[] + if (root._is_primitive_array(self) : bool) : T[] + { : T[] + root._rust_sort(self) : T[] + } + else + { : T[] + self.sort_by((a: T, b: T) -> int throws T.CompareError { ... }) : T[] + (a: T, b: T) -> int throws T.CompareError { ... } : (a: T, b: T) -> int throws (T as baml.Comparable).CompareError + { + root._compare_shim(a, b) + } + } + } +} +lambda baml.sort { +} +function baml.compare(self: unknown, other: !error) -> int throws never { + { : int + root._float_total_cmp(self, other) : int + } +} + +--- /baml/containers.baml --- +class baml.Array { +} +function baml.Array.generate(length: int, f: (int) -> T throws E) -> T[] throws E { + { : T[] + let out: T[] = [] : T[] + let i = 0 : 0 -> int + while i < length + { : void + out.push(f(i)) : int + i Add= 1 : int + } + out : T[] + } +} +function baml.Array.for_each(self: baml.Array, fn: (T) -> void throws E) -> void throws E { + { : void + for x in self.slice(0, self.length()) + { : void + fn(x) : void + } + } +} +function baml.Array.filter_map(self: baml.Array, fn: (T) -> U | null throws E) -> U[] throws E { + { : U[] + let out: U[] = [] : U[] + for x in self.slice(0, self.length()) + { : void + match (fn(x) : U | null) : void + null => + { : void + } + y: U => + { : void + out.push(y) : int + } + } + out : U[] + } +} +function baml.Array.sort_by_key(self: baml.Array, key: (T) -> U throws E) -> T[] throws E | !error { + { : never + let n = self.length() : int + if (n <= 1 : bool) : void + { : never + return self : T[] + } + let items = self.slice(0, n) : T[] + let keys: U[] = [] : U[] + for x in items + { : void + keys.push(key(x)) : int + } + let order: int[] = [] : int[] + let p = 0 : 0 -> int + while p < n + { : void + order.push(p) : int + p Add= 1 : int + } + order.sort_by((i: int, j: int) -> int throws U.CompareError { ... }) : int[] + (i: int, j: int) -> int throws U.CompareError { ... } : (i: int, j: int) -> int throws (U as baml.Comparable).CompareError + { + match (keys.at(i)) { null => 0, ki: U => match (keys.at(j)) { null => 0, kj: U => ki.compare(kj) } } + } + let sorted: T[] = [] : T[] + for i in order + { : void + match (items.at(i) : T | null) : void + null => + { : void + } + item: T => + { : void + sorted.push(item) : int + } + } + self.clear() : null + for s in sorted + { : void + self.push(s) : int + } + return self : T[] + } +} +lambda baml.Array.sort_by_key { +} +class baml.Map { +} +function baml.sum(self: unknown) -> int throws never { + { : int + root._sum_int(self) : int + } +} +function baml.sum(self: unknown) -> float throws never { + { : float + root._sum_float(self) : float + } +} +function baml.mean(self: unknown) -> float throws baml.errors.InvalidArgument { + { : float + root._mean_float(self) : float + } +} +function baml.median(self: unknown) -> float throws baml.errors.InvalidArgument { + { : float + root._median_float(self) : float + } +} +class baml.Array$stream { +} +class baml.Map$stream { +} + +--- /baml/conversions.baml --- +function baml.ToString.to_string(self: baml.ToString) -> string throws never { + { : string + root._to_string_default(self) : string + } +} +function baml.ToJson.to_json(self: baml.ToJson) -> baml.json.json throws baml.json.JsonSerializationError { + { : baml.json.json + root._to_json_default(self) : baml.json.json + } +} + +--- /baml/core.baml --- +class baml.TaggedString { + parts: string[] + values: unknown[] +} +class baml.TaggedString$stream { + parts: string[] + values: unknown[] +} + +--- /baml/float.baml --- +class baml.Float { +} +function baml.Float.is_finite(self: baml.Float) -> bool throws never { + { : bool + Not self.is_nan() && Not self.is_infinite() : bool + } +} +function baml.Float.to_radians(self: baml.Float) -> float throws never { + { : float + self * float.pi() / 180.0 : float + } +} +function baml.Float.to_degrees(self: baml.Float) -> float throws never { + { : float + self * 180.0 / float.pi() : float + } +} +class baml.Float$stream { +} + +--- /baml/int.baml --- +class baml.Int { +} +function baml.Int.max_value() -> int throws never { + { : 4611686018427387903 + 4611686018427387903 : 4611686018427387903 + } +} +function baml.Int.min_value() -> int throws never { + { : -4611686018427387904 + Neg 4611686018427387903 - 1 : -4611686018427387904 + } +} +class baml.Int$stream { +} + +--- /baml/ns_csv/csv.baml --- +enum baml.csv.CsvErrorKind +class baml.csv.CsvError { + kind: baml.csv.CsvErrorKind + message: string + line: int | null + record: int | null + field: int | null + column: string | null + expected: int | null + found: int | null +} +class baml.csv.CsvPosition { + byte: int + line: int + record: int +} +class baml.csv.ReaderOptions { + delimiter: string | null + quote: string | null + quoting: bool | null + escape: string | null + has_header: bool | null + headers: string[] | null + comment: string | null + trim: "none" | "headers" | "fields" | "all" | null + skip_lines: int | null + skip_blank_records: bool | null + ragged: "strict" | "pad" | "truncate" | null + null_values: string[] | null + encoding: "utf8" | "utf8-lossy" | null + bom: "strip" | "keep" | null + on_error: "throw" | "skip" | null + on_skip: ((baml.csv.CsvError) -> null throws never) | null + max_skipped: int | null + limit: int | null +} +class baml.csv.WriterOptions { + delimiter: string | null + quote: string | null + quote_style: "minimal" | "all" | "never" | null + escape: string | null + terminator: "lf" | "crlf" | null + write_header: bool | null + headers: string[] | null + null_value: string | null + bom: bool | null + sanitize_formulas: bool | null +} +type baml.csv.CsvValue = null | bool | int | bigint | float | string +class baml.csv.CsvNeedData { +} +class baml.csv.CsvSkip { + error: baml.csv.CsvError +} +class baml.csv.CsvHeaders { + names: string[] | null +} +class baml.csv.CsvRecord { + _handle: $rust_type +} +function baml.csv.CsvRecord.get(self: baml.csv.CsvRecord, column: string) -> T | null throws baml.csv.CsvError { + { : T | null + _cell_by_name(self, column) : T | null + } +} +function baml.csv.CsvRecord.get_at(self: baml.csv.CsvRecord, index: int) -> T | null throws baml.csv.CsvError { + { : T | null + _cell_by_index(self, index) : T | null + } +} +function baml.csv.CsvRecord.decode(self: baml.csv.CsvRecord) -> T throws baml.csv.CsvError { + { : T + _decode_record(self) : T + } +} +class baml.csv.CsvReader { + _handle: $rust_type + _file: baml.fs.File | null + _on_skip: ((baml.csv.CsvError) -> null throws never) | null + _owns_file: bool +} +function baml.csv.CsvReader.headers(self: baml.csv.CsvReader) -> string[] | null throws baml.csv.CsvError | baml.errors.Io { + { : never + while true + { : void + match (self._poll_headers() : baml.csv.CsvHeaders | baml.csv.CsvNeedData) : void + h: CsvHeaders => + { : never + return h.names : string[] | null + } + CsvNeedData => + { : void + self._read_chunk() : null + } + } + root.sys.panic("unreachable: CsvR...") : never + } +} +function baml.csv.CsvReader.rows(self: baml.csv.CsvReader) -> baml.iter.Iterator throws baml.csv.CsvError | baml.errors.Io { + { : baml.csv.CsvRows + self.headers() : string[] | null + _validate_columns(self) : null + CsvRows { reader: self } : baml.csv.CsvRows + } +} +function baml.csv.CsvReader.close(self: baml.csv.CsvReader) -> null throws baml.errors.Io { + { : null + self._mark_closed() : null + match (self._file : baml.fs.File | null) : null + null => + null : null + f: root.fs.File => + { : null + if (self._owns_file : bool) : void + { : void + catch (f.close() : null) : null + catch (_) + root.errors.InvalidArgument => + null : null + } + null : null + } + } +} +function baml.csv.CsvReader._read_chunk(self: baml.csv.CsvReader) -> null throws baml.csv.CsvError | baml.errors.Io { + { : null + match (self._file : baml.fs.File | null) : null + null => + { : null + self._feed_eof() : null + null : null + } + f: root.fs.File => + { : null + let chunk = : uint8array + catch (f.read_bytes(65536) : uint8array) : uint8array + catch (e) + root.errors.InvalidArgument { message: message } => + { : never + throw _error(CsvErrorKind.Closed, "underlying file h..." + message) : baml.csv.CsvError + } + root.errors.Io => + { : never + self._mark_exhausted() : null + throw e : baml.errors.Io + } + if (chunk.length() == 0 : bool) : void + { : void + self._feed_eof() : null + } + else + { : void + self._feed(chunk) : null + } + null : null + } + } +} +function baml.csv.CsvReader.iter(self: baml.csv.CsvReader) -> baml.iter.Iterator throws never { + { : baml.csv.CsvReader + self : baml.csv.CsvReader + } +} +function baml.csv.CsvReader.next(self: baml.csv.CsvReader) -> baml.csv.CsvRecord | baml.iter.Done throws baml.csv.CsvError | baml.errors.Io { + { : never + while true + { : void + match (self._poll() : baml.csv.CsvRecord | baml.csv.CsvSkip | baml.csv.CsvNeedData | baml.iter.Done) : void + rec: CsvRecord => + { : never + return rec : baml.csv.CsvRecord + } + d: root.iter.Done => + { : never + return d : baml.iter.Done + } + s: CsvSkip => + { : void + match (self._on_skip : ((baml.csv.CsvError) -> null throws never) | null) : null + null => + null : null + cb: (CsvError) -> null throws never => + cb(s.error) : null + } + CsvNeedData => + { : void + self._read_chunk() : null + } + } + root.sys.panic("unreachable: CsvR...") : never + } +} +class baml.csv.CsvRows { + reader: baml.csv.CsvReader +} +function baml.csv.CsvRows.iter(self: baml.csv.CsvRows) -> baml.iter.Iterator throws never { + { : baml.csv.CsvRows + self : baml.csv.CsvRows + } +} +function baml.csv.CsvRows.next(self: baml.csv.CsvRows) -> T | baml.iter.Done throws baml.csv.CsvError | baml.errors.Io { + { : never + while true + { : void + match (self.reader.next() : baml.csv.CsvRecord | baml.iter.Done) : void + d: root.iter.Done => + { : never + return d : baml.iter.Done + } + rec: CsvRecord => + { : void + match (_try_decode(rec, self.reader) : T | baml.csv.CsvSkip) : void + s: CsvSkip => + { : void + match (self.reader._on_skip : ((baml.csv.CsvError) -> null throws never) | null) : null + null => + null : null + cb: (CsvError) -> null throws never => + cb(s.error) : null + } + v: T => + { : never + return v : T + } + } + } + root.sys.panic("unreachable: CsvR...") : never + } +} +class baml.csv.CsvWriter { + _handle: $rust_type + _file: baml.fs.File | null + _owns_file: bool +} +function baml.csv.CsvWriter.write_record(self: baml.csv.CsvWriter, record: baml.csv.CsvValue[]) -> null throws baml.csv.CsvError | baml.errors.Io { + { : null + self._emit(self._encode_record(record)) : null + } +} +function baml.csv.CsvWriter.write_row(self: baml.csv.CsvWriter, row: T) -> null throws baml.csv.CsvError | baml.errors.Io { + { : null + self._emit(_encode_row(self, row)) : null + } +} +function baml.csv.CsvWriter.write_rows(self: baml.csv.CsvWriter, rows: T[]) -> null throws baml.csv.CsvError | baml.errors.Io { + { : null + self._emit(_encode_rows(self, rows)) : null + } +} +function baml.csv.CsvWriter.write_header(self: baml.csv.CsvWriter, names: string[]) -> null throws baml.csv.CsvError | baml.errors.Io { + { : null + self._emit(self._encode_header(names)) : null + } +} +function baml.csv.CsvWriter.flush(self: baml.csv.CsvWriter) -> null throws never { + { : null + null : null + } +} +function baml.csv.CsvWriter.close(self: baml.csv.CsvWriter) -> null throws baml.errors.Io { + { : null + self._mark_closed() : null + match (self._file : baml.fs.File | null) : null + null => + null : null + f: root.fs.File => + { : null + if (self._owns_file : bool) : void + { : void + catch (f.close() : null) : null + catch (_) + root.errors.InvalidArgument => + null : null + } + null : null + } + } +} +function baml.csv.CsvWriter._emit(self: baml.csv.CsvWriter, out: string) -> null throws baml.errors.Io { + { : null + match (self._file : baml.fs.File | null) : null + null => + null : null + f: root.fs.File => + { : null + if (out.length() > 0 : bool) : void + { : void + catch (f.write(out) : int) : int + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + throw root.errors.Io { message: "underlying file h..." + message } : baml.errors.Io + } + } + null : null + } + } +} +function baml.csv.reader(source: string | uint8array | baml.fs.File, options: baml.csv.ReaderOptions | null = null) -> baml.csv.CsvReader throws baml.csv.CsvError { + { : baml.csv.CsvReader + _reader(source, options, false) : baml.csv.CsvReader + } +} +function baml.csv.open(path: string, options: baml.csv.ReaderOptions | null = null) -> baml.csv.CsvReader throws baml.csv.CsvError | baml.errors.Io { + { : baml.csv.CsvReader + let f = : baml.fs.File + catch (baml.fs.open(path, "r") : baml.fs.File) : baml.fs.File + catch (_) + root.errors.InvalidArgument { message: message } => + throw root.errors.Io { message: message } : never + _reader(f, options, true) : baml.csv.CsvReader + } +} +function baml.csv.read(path: string, options: baml.csv.ReaderOptions | null = null) -> T[] throws baml.csv.CsvError | baml.errors.Io { + { : T[] + let r = open(path, options = options) : baml.csv.CsvReader + let result = r.rows().collect() : T[] + r.close() : null + result : T[] + } +} +function baml.csv.parse(source: string | uint8array, options: baml.csv.ReaderOptions | null = null) -> string[][] throws baml.csv.CsvError { + { : string[][] + catch ({ 3 stmts + tail } : string[][]) : string[][] + catch (_) + root.errors.Io { message: message } => + { : never + root.sys.panic("unreachable: in-m..." + message) : never + } + } +} +function baml.csv.decode(source: string | uint8array, options: baml.csv.ReaderOptions | null = null) -> T[] throws baml.csv.CsvError { + { : T[] + catch ({ 0 stmts + tail } : T[]) : T[] + catch (_) + root.errors.Io { message: message } => + { : never + root.sys.panic("unreachable: in-m..." + message) : never + } + } +} +function baml.csv.decode_optional(source: string | uint8array, options: baml.csv.ReaderOptions | null = null) -> T | null throws baml.csv.CsvError { + { : T | null + let all = decode(source, options = options) : T[] + if (all.length() > 1 : bool) : void + { : never + throw _error(CsvErrorKind.TooManyRows, "expected at most ..." + root.json.stringify(all.length())) : baml.csv.CsvError + } + all.at(0) : T | null + } +} +function baml.csv.decode_one(source: string | uint8array, options: baml.csv.ReaderOptions | null = null) -> T throws baml.csv.CsvError { + { : T + let all = decode(source, options = options) : T[] + if (all.length() == 0 : bool) : void + { : never + throw _error(CsvErrorKind.NotFound, "expected exactly ...") : baml.csv.CsvError + } + if (all.length() > 1 : bool) : void + { : never + throw _error(CsvErrorKind.TooManyRows, "expected exactly ..." + root.json.stringify(all.length())) : baml.csv.CsvError + } + match (all.at(0) : T | null) : T + null => + root.sys.panic("unreachable: deco...") : never + v: T => + v : T + } +} +function baml.csv.writer(file: baml.fs.File, options: baml.csv.WriterOptions | null = null) -> baml.csv.CsvWriter throws baml.csv.CsvError { + { : baml.csv.CsvWriter + _writer(file, options, false) : baml.csv.CsvWriter + } +} +function baml.csv.create(path: string, options: baml.csv.WriterOptions | null = null) -> baml.csv.CsvWriter throws baml.csv.CsvError | baml.errors.Io { + { : baml.csv.CsvWriter + let f = : baml.fs.File + catch (baml.fs.open(path, "w") : baml.fs.File) : baml.fs.File + catch (_) + root.errors.InvalidArgument { message: message } => + throw root.errors.Io { message: message } : never + _writer(f, options, true) : baml.csv.CsvWriter + } +} +function baml.csv.buffer(options: baml.csv.WriterOptions | null = null) -> baml.csv.CsvWriter throws baml.csv.CsvError { + { : baml.csv.CsvWriter + _buffer(options = options) : baml.csv.CsvWriter + } +} +function baml.csv.write(path: string, rows: T[], options: baml.csv.WriterOptions | null = null) -> int throws baml.csv.CsvError | baml.errors.Io { + { : int + let w = create(path, options = options) : baml.csv.CsvWriter + w.write_rows(rows) : null + w.close() : null + w._bytes_written() : int + } +} +function baml.csv.stringify(rows: T[], options: baml.csv.WriterOptions | null = null) -> string throws baml.csv.CsvError { + { : string + catch ({ 2 stmts + tail } : string) : string + catch (_) + root.errors.Io { message: message } => + { : never + root.sys.panic("unreachable: buff..." + message) : never + } + } +} +function baml.csv.stringify_records(records: baml.csv.CsvValue[][], options: baml.csv.WriterOptions | null = null) -> string throws baml.csv.CsvError { + { : string + catch ({ 2 stmts + tail } : string) : string + catch (_) + root.errors.Io { message: message } => + { : never + root.sys.panic("unreachable: buff..." + message) : never + } + } +} +function baml.csv.to_markdown(rows: T[], max_rows: int = 100) -> string throws never { + { : string + _to_markdown(rows, max_rows = max_rows) : string + } +} +function baml.csv.to_markdown_records(records: string[][], headers: string[] | null = null, max_rows: int = 100) -> string throws never { + { : string + _to_markdown_records(records, headers = headers, max_rows = max_rows) : string + } +} +function baml.csv._error(kind: baml.csv.CsvErrorKind, message: string) -> baml.csv.CsvError throws never { + { : baml.csv.CsvError + CsvError { kind: kind, message: message, line: null, record: null, field: null, column: null, expected: null, found: null } : baml.csv.CsvError + } +} +class baml.csv.CsvError$stream { + kind: baml.csv.CsvErrorKind | null + message: string | null + line: int | null + record: int | null + field: int | null + column: string | null + expected: int | null + found: int | null +} +class baml.csv.CsvPosition$stream { + byte: int | null + line: int | null + record: int | null +} +class baml.csv.ReaderOptions$stream { + delimiter: string | null + quote: string | null + quoting: bool | null + escape: string | null + has_header: bool | null + headers: string[] | null + comment: string | null + trim: "none" | "headers" | "fields" | "all" | null + skip_lines: int | null + skip_blank_records: bool | null + ragged: "strict" | "pad" | "truncate" | null + null_values: string[] | null + encoding: "utf8" | "utf8-lossy" | null + bom: "strip" | "keep" | null + on_error: "throw" | "skip" | null + on_skip: unknown | null + max_skipped: int | null + limit: int | null +} +class baml.csv.WriterOptions$stream { + delimiter: string | null + quote: string | null + quote_style: "minimal" | "all" | "never" | null + escape: string | null + terminator: "lf" | "crlf" | null + write_header: bool | null + headers: string[] | null + null_value: string | null + bom: bool | null + sanitize_formulas: bool | null +} +type baml.csv.CsvValue$stream = null | bool | int | bigint | float | string +class baml.csv.CsvNeedData$stream { +} +class baml.csv.CsvSkip$stream { + error: baml.csv.CsvError$stream | null +} +class baml.csv.CsvHeaders$stream { + names: string[] | null +} +class baml.csv.CsvRecord$stream { + _handle: $rust_type +} +class baml.csv.CsvReader$stream { + _handle: $rust_type + _file: baml.fs.File$stream | null + _on_skip: unknown | null + _owns_file: bool | null +} +class baml.csv.CsvRows$stream { + reader: baml.csv.CsvReader$stream | null +} +class baml.csv.CsvWriter$stream { + _handle: $rust_type + _file: baml.fs.File$stream | null + _owns_file: bool | null +} + +--- /baml/ns_env/env.baml --- +function baml.env.get_or_panic(key: string) -> string throws never { + { : string + get(key) ?? root.sys.panic("env var not found: " + key) : string + } +} +function baml.env.get_or_panic_lenient(key: string, lenient: bool) -> string throws never { + { : string + if (lenient : bool) : string + { : string + get(key) ?? "" : string + } + else + { : string + get_or_panic(key) : string + } + } +} + +--- /baml/ns_errors/error_context.baml --- +class baml.errors.ErrorContext { + error: unknown + stack_trace: baml.errors.StackTrace + cause: baml.errors.ErrorContext | null +} +function baml.errors.ErrorContext.root_cause(self: baml.errors.ErrorContext) -> baml.errors.ErrorContext throws never { + { : baml.errors.ErrorContext + match (self.cause : baml.errors.ErrorContext | null) : baml.errors.ErrorContext + null => + self : baml.errors.ErrorContext + c: ErrorContext => + c.root_cause() : baml.errors.ErrorContext + } +} +function baml.errors.ErrorContext.to_string(self: baml.errors.ErrorContext) -> string throws never { + { : string + self._to_string_impl() : string + } +} +class baml.errors.ErrorContext$stream { + error: unknown + stack_trace: baml.errors.StackTrace$stream | null + cause: baml.errors.ErrorContext$stream | null +} + +--- /baml/ns_errors/errors.baml --- +class baml.errors.InvalidArgument { + message: string +} +class baml.errors.ParseError { + message: string +} +class baml.errors.Io { + message: string +} +class baml.errors.Timeout { + message: string + duration_ms: int | null +} +class baml.errors.Unsupported { + message: string +} +class baml.errors.AccessError { + message: string +} +class baml.errors.RenderPrompt { + message: string +} +class baml.errors.NotImplemented { + message: string +} +class baml.errors.LlmClient { + message: string +} +class baml.errors.DevOther { + message: string +} +class baml.errors.HostCallable { + message: string + class_name: string + language: string + traceback: string | null + _handle: $rust_type +} +class baml.errors.GenericSdkError { + message: string +} +class baml.errors.CompilationError { + message: string +} +class baml.errors.TypeMismatch { + message: string +} +class baml.errors.InvalidArgument$stream { + message: string | null +} +class baml.errors.ParseError$stream { + message: string | null +} +class baml.errors.Io$stream { + message: string | null +} +class baml.errors.Timeout$stream { + message: string | null + duration_ms: int | null +} +class baml.errors.Unsupported$stream { + message: string | null +} +class baml.errors.AccessError$stream { + message: string | null +} +class baml.errors.RenderPrompt$stream { + message: string | null +} +class baml.errors.NotImplemented$stream { + message: string | null +} +class baml.errors.LlmClient$stream { + message: string | null +} +class baml.errors.DevOther$stream { + message: string | null +} +class baml.errors.HostCallable$stream { + message: string | null + class_name: string | null + language: string | null + traceback: string | null + _handle: $rust_type +} +class baml.errors.GenericSdkError$stream { + message: string | null +} +class baml.errors.CompilationError$stream { + message: string | null +} +class baml.errors.TypeMismatch$stream { + message: string | null +} + +--- /baml/ns_errors/stack_trace.baml --- +class baml.errors.StackFrame { + file: string + line: int + function_name: string +} +class baml.errors.StackTrace { + frames: baml.errors.StackFrame[] +} +function baml.errors.StackTrace.to_string(self: baml.errors.StackTrace) -> string throws never { + { : string + self._to_string_impl() : string + } +} +class baml.errors.StackFrame$stream { + file: string | null + line: int | null + function_name: string | null +} +class baml.errors.StackTrace$stream { + frames: baml.errors.StackFrame$stream[] +} + +--- /baml/ns_errors/unknown_error.baml --- +class baml.errors.UnknownError { + data: unknown + message: string[] +} +class baml.errors.UnknownError$stream { + data: unknown + message: string[] +} + +--- /baml/ns_events/events.baml --- + +--- /baml/ns_fs/fs.baml --- +class baml.fs.File { + _handle: $rust_type +} +class baml.fs.DirEntry { + name: string + is_dir: bool + is_file: bool + is_symlink: bool +} +class baml.fs.MkdirOptions { + recursive: bool +} +class baml.fs.File$stream { + _handle: $rust_type +} +class baml.fs.DirEntry$stream { + name: string | null + is_dir: bool | null + is_file: bool | null + is_symlink: bool | null +} +class baml.fs.MkdirOptions$stream { + recursive: bool | null +} + +--- /baml/ns_future/future.baml --- +enum baml.future.FutureState +class baml.future.Future { +} +function baml.future.all_complete(futures: Future[]) -> Future throws never { + { : Future + spawn { () -> { ... } } : Future + } +} +lambda baml.future.all_complete { +} +lambda baml.future.all_complete { +} +function baml.future.all(futures: Future[]) -> Future throws never { + { : Future + spawn { () -> { ... } } : Future + } +} +lambda baml.future.all { +} +lambda baml.future.all { +} +lambda baml.future.all { +} +class baml.future.AllFailed { + errors: E[] +} +function baml.future.race(futures: Future[]) -> Future throws never { + { : Future + spawn { () -> { ... } } : Future + } +} +lambda baml.future.race { +} +lambda baml.future.race { +} +function baml.future.any(futures: Future[]) -> Future> throws never { + { : Future> + spawn { () -> { ... } } : Future> + } +} +lambda baml.future.any { +} +lambda baml.future.any { +} +class baml.future.Future$stream { +} +class baml.future.AllFailed$stream { + errors: E[] +} + +--- /baml/ns_glob/glob.baml --- +class baml.glob.ScanOptions { + cwd: string | null + dot: bool | null + absolute: bool | null + follow_symlinks: bool | null + throw_error_on_broken_symlink: bool | null + only_files: bool | null +} +class baml.glob.Glob { + _handle: $rust_type +} +class baml.glob.ScanOptions$stream { + cwd: string | null + dot: bool | null + absolute: bool | null + follow_symlinks: bool | null + throw_error_on_broken_symlink: bool | null + only_files: bool | null +} +class baml.glob.Glob$stream { + _handle: $rust_type +} + +--- /baml/ns_host/host.baml --- +class baml.host.HostValue { +} +class baml.host.HostValue$stream { +} + +--- /baml/ns_http/http.baml --- +class baml.http.Request { + method: string + url: string + headers: map + body: string +} +class baml.http.Response { + status_code: int + headers: map + url: string + _body: $rust_type +} +function baml.http.Response.ok(self: baml.http.Response) -> bool throws never { + { : bool + self.status_code >= 200 && self.status_code < 300 : bool + } +} +class baml.http.SseStream { + url: string + _handle: $rust_type +} +function baml.http._timeout_nanos(timeout: baml.time.Duration | null) -> bigint throws never { + { : 0n | bigint + match (timeout : baml.time.Duration | null) : 0n | bigint + null => + 0n : 0n + t: root.time.Duration => + t.to_nanoseconds() : bigint + } +} +function baml.http.fetch(url: string, timeout: baml.time.Duration | null = null) -> baml.http.Response throws baml.errors.Io | baml.errors.Timeout { + { : baml.http.Response + _fetch(url, _timeout_nanos(timeout)) : baml.http.Response + } +} +function baml.http.send(request: baml.http.Request, timeout: baml.time.Duration | null = null) -> baml.http.Response throws baml.errors.Io | baml.errors.Timeout { + { : baml.http.Response + _send(request, _timeout_nanos(timeout)) : baml.http.Response + } +} +class baml.http.Request$stream { + method: string | null + url: string | null + headers: map + body: string | null +} +class baml.http.Response$stream { + status_code: int | null + headers: map + url: string | null + _body: $rust_type +} +class baml.http.SseStream$stream { + url: string | null + _handle: $rust_type +} + +--- /baml/ns_http/server.baml --- +class baml.http.Server { + addr: string + _state: $rust_type +} +function baml.http.Server.serve(self: baml.http.Server, handler: (req: baml.http.Request) -> baml.http.Response throws never, tls_config: baml.http.TlsConfig | null = null, allow_http1: bool = true, allow_http2: bool = true, max_body_size: int = 104857600, max_connections: int = 1024, header_read_timeout: baml.time.Duration = root.time.Duration.from_seconds(30n)) -> never throws baml.errors.Io { + { : never + self._serve(handler, tls_config, allow_http1, allow_http2, max_body_size, max_connections, header_read_timeout.to_nanoseconds()) : never + } +} +class baml.http.TlsConfig { + allow_tls1_2: bool + _certificate: $rust_type + _private_key: $rust_type + _handshake_timeout_nanos: bigint +} +function baml.http.TlsConfig.new(cert_pem: uint8array, key_pem: uint8array, allow_tls1_2: bool = true, handshake_timeout: baml.time.Duration = root.time.Duration.from_seconds(10n)) -> baml.http.TlsConfig throws baml.errors.Io { + { : baml.http.TlsConfig + TlsConfig._new(cert_pem, key_pem, allow_tls1_2, handshake_timeout.to_nanoseconds()) : baml.http.TlsConfig + } +} +class baml.http.Server$stream { + addr: string | null + _state: $rust_type +} +class baml.http.TlsConfig$stream { + allow_tls1_2: bool | null + _certificate: $rust_type + _private_key: $rust_type + _handshake_timeout_nanos: bigint | null +} + +--- /baml/ns_id/id.baml --- + +--- /baml/ns_io/io.baml --- + +--- /baml/ns_io/read.baml --- +function baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array throws baml.errors.Io { + { : uint8array + let buf = b"<0 bytes>" : uint8array + while let chunk: uint8array = self.read(int.max_value()) + { : void + buf = buf.concat(chunk) : uint8array + } + buf : uint8array + } +} +function baml.io.Read.read_to_string(self: baml.io.Read) -> string throws baml.errors.Io | baml.errors.ParseError { + { : string + let buf = self.read_to_end() : uint8array + catch (string.from_utf8(buf) : string) : string + catch (_) + _ => + throw root.errors.ParseError { message: "invalid utf-8" } : never + } +} + +--- /baml/ns_io/write.baml --- + +--- /baml/ns_iter/iter.baml --- +class baml.iter.Done { +} +function baml.iter.Iterator.map(self: baml.iter.Iterator, fn: (!error) -> R throws E2) -> baml.iter.Iterator throws never { + { : baml.iter.Map<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2> + Map { source: self, func: fn } : baml.iter.Map<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2> + } +} +function baml.iter.Iterator.filter(self: baml.iter.Iterator, predicate: (!error) -> bool throws E2) -> baml.iter.Iterator throws never { + { : baml.iter.Filter<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error, E2> + Filter { source: self, predicate: predicate } : baml.iter.Filter<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error, E2> + } +} +function baml.iter.Iterator.filter_map(self: baml.iter.Iterator, fn: (!error) -> R | null throws E2) -> baml.iter.Iterator throws never { + { : baml.iter.FilterMap<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2> + FilterMap { source: self, func: fn } : baml.iter.FilterMap<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2> + } +} +function baml.iter.Iterator.flat_map(self: baml.iter.Iterator, fn: (!error) -> baml.iter.Iterable throws E2) -> baml.iter.Iterator throws never { + { : baml.iter.FlatMap<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2, E3> + FlatMap { source: self, func: fn, inner: Done { } } : baml.iter.FlatMap<(Self as baml.iter.Iterator).Item, R, (Self as baml.iter.Iterator).Error, E2, E3> + } +} +function baml.iter.Iterator.step_by(self: baml.iter.Iterator, n: int) -> baml.iter.Iterator throws never { + { : baml.iter.StepBy<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error> + StepBy { source: self, n: n, first: true } : baml.iter.StepBy<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error> + } +} +function baml.iter.Iterator.chain(self: baml.iter.Iterator, other: baml.iter.Iterable) -> baml.iter.Iterator throws never { + { : baml.iter.Chain<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error, E2> + Chain { first: self, other: other.iter(), first_done: false } : baml.iter.Chain<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error, E2> + } +} +function baml.iter.Iterator.peekable(self: baml.iter.Iterator) -> baml.iter.Peekable throws never { + { : baml.iter.Peekable<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error> + Peekable { source: self, buffer: Done { }, has_buffer: false } : baml.iter.Peekable<(Self as baml.iter.Iterator).Item, (Self as baml.iter.Iterator).Error> + } +} +function baml.iter.Iterator.collect(self: baml.iter.Iterator) -> !error[] throws !error { + { : (Self as baml.iter.Iterator).Item[] + let r: Self.Item[] = [] : (Self as baml.iter.Iterator).Item[] + while true + { : int + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : int + Done => + { : never + break + } + x: Self.Item => + r.push(x) : int + } + r : (Self as baml.iter.Iterator).Item[] + } +} +function baml.iter.Iterator.reduce(self: baml.iter.Iterator, fn: (A, !error) -> A throws E2, initial: A) -> A throws !error | E2 { + { : A + let acc: A = initial : A + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + acc = fn(acc, x) : A + } + } + acc : A + } +} +function baml.iter.Iterator.count(self: baml.iter.Iterator) -> int throws !error { + { : int + let n: int = 0 : 0 -> int + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + n Add= 1 : int + } + } + n : int + } +} +function baml.iter.Iterator.for_each(self: baml.iter.Iterator, fn: (!error) -> void throws E2) -> void throws !error | E2 { + { : void + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + fn(x) : void + } + } + } +} +function baml.iter.Iterator.some(self: baml.iter.Iterator, predicate: (!error) -> bool throws E2) -> bool throws !error | E2 { + { : false + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + if (predicate(x) : bool) : void + { : never + return true : true + } + } + } + false : false + } +} +function baml.iter.Iterator.every(self: baml.iter.Iterator, predicate: (!error) -> bool throws E2) -> bool throws !error | E2 { + { : true + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + if (Not predicate(x) : bool) : void + { : never + return false : false + } + } + } + true : true + } +} +function baml.iter.Iterator.find(self: baml.iter.Iterator, predicate: (!error) -> bool throws E2) -> !error | null throws !error | E2 { + { : null + while true + { : void + match (self.next() : (Self as baml.iter.Iterator).Item | baml.iter.Done) : void + Done => + { : never + break + } + x: Self.Item => + { : void + if (predicate(x) : bool) : void + { : never + return x : (Self as baml.iter.Iterator).Item + } + } + } + null : null + } +} +function baml.iter.flatten(src: baml.iter.Iterator) -> baml.iter.Iterator throws never { + { : baml.iter.Flatten + Flatten { source: src, inner: Done { } } : baml.iter.Flatten + } +} +class baml.iter.ArrayIterator { + arr: T[] + idx: int +} +function baml.iter.ArrayIterator.new(arr: T[]) -> baml.iter.ArrayIterator throws never { + { : baml.iter.ArrayIterator + ArrayIterator { arr: arr, idx: 0 } : baml.iter.ArrayIterator + } +} +function baml.iter.ArrayIterator.iter(self: baml.iter.ArrayIterator) -> baml.iter.Iterator throws never { + { : baml.iter.ArrayIterator + self : baml.iter.ArrayIterator + } +} +function baml.iter.ArrayIterator.next(self: baml.iter.ArrayIterator) -> T | baml.iter.Done throws never { + { : never + if (self.idx >= self.arr.length() : bool) : void + { : never + return Done { } : baml.iter.Done + } + let item = self.arr[self.idx] : T + self.idx Add= 1 : int + return item : T + } +} +class baml.iter.Range { + i: int + max: int + step: int +} +function baml.iter.Range.new(min: int, max: int, step: int = 1) -> baml.iter.Range throws never { + { : baml.iter.Range + Range { i: min, max: max, step: step } : baml.iter.Range + } +} +function baml.iter.Range.iter(self: baml.iter.Range) -> baml.iter.Iterator throws never { + { : baml.iter.Range + self : baml.iter.Range + } +} +function baml.iter.Range.next(self: baml.iter.Range) -> int | baml.iter.Done throws never { + { : int | baml.iter.Done + if (self.i < self.max : bool) : int | baml.iter.Done + { : int + let cur = self.i : int + self.i Add= self.step : int + cur : int + } + else + { : baml.iter.Done + Done { } : baml.iter.Done + } + } +} +class baml.iter.Repeat { + value: T + count: int +} +function baml.iter.Repeat.new(value: T, count: int = ...) -> baml.iter.Repeat throws never { + { : baml.iter.Repeat + Repeat { value: value, count: count } : baml.iter.Repeat + } +} +function baml.iter.Repeat.iter(self: baml.iter.Repeat) -> baml.iter.Iterator throws never { + { : baml.iter.Repeat + self : baml.iter.Repeat + } +} +function baml.iter.Repeat.next(self: baml.iter.Repeat) -> T | baml.iter.Done throws never { + { : T | baml.iter.Done + if (self.count < 0 : bool) : T | baml.iter.Done + { : T + self.value : T + } + else + if (self.count > 0 : bool) : T | baml.iter.Done + { : T + self.count Sub= 1 : int + self.value : T + } + else + { : baml.iter.Done + Done { } : baml.iter.Done + } + } +} +class baml.iter.Map { + source: baml.iter.Iterator + func: (T) -> R throws E2 +} +function baml.iter.Map.iter(self: baml.iter.Map) -> baml.iter.Iterator throws never { + { : baml.iter.Map + self : baml.iter.Map + } +} +function baml.iter.Map.next(self: baml.iter.Map) -> R | baml.iter.Done throws E | E2 { + { : baml.iter.Done | R + match (self.source.next() : T | baml.iter.Done) : baml.iter.Done | R + Done => + Done { } : baml.iter.Done + x: T => + self.func(x) : R | baml.iter.Done + } +} +class baml.iter.Filter { + source: baml.iter.Iterator + predicate: (T) -> bool throws E2 +} +function baml.iter.Filter.iter(self: baml.iter.Filter) -> baml.iter.Iterator throws never { + { : baml.iter.Filter + self : baml.iter.Filter + } +} +function baml.iter.Filter.next(self: baml.iter.Filter) -> T | baml.iter.Done throws E | E2 { + { : baml.iter.Done + while true + { : void + match (self.source.next() : T | baml.iter.Done) : void + Done => + { : never + return Done { } : baml.iter.Done + } + x: T => + { : void + if (self.predicate(x) : bool) : void + { : never + return x : T + } + } + } + Done { } : baml.iter.Done + } +} +class baml.iter.FilterMap { + source: baml.iter.Iterator + func: (T) -> R | null throws E2 +} +function baml.iter.FilterMap.iter(self: baml.iter.FilterMap) -> baml.iter.Iterator throws never { + { : baml.iter.FilterMap + self : baml.iter.FilterMap + } +} +function baml.iter.FilterMap.next(self: baml.iter.FilterMap) -> R | baml.iter.Done throws E | E2 { + { : baml.iter.Done + while true + { : void + match (self.source.next() : T | baml.iter.Done) : void + Done => + { : never + return Done { } : baml.iter.Done + } + x: T => + { : void + match (self.func(x) : R | null) : void + null => + { : void + } + y: R => + { : never + return y : R + } + } + } + Done { } : baml.iter.Done + } +} +class baml.iter.FlatMap { + source: baml.iter.Iterator + func: (T) -> baml.iter.Iterable throws E2 + inner: baml.iter.Iterator | baml.iter.Done +} +function baml.iter.FlatMap.iter(self: baml.iter.FlatMap) -> baml.iter.Iterator throws never { + { : baml.iter.FlatMap + self : baml.iter.FlatMap + } +} +function baml.iter.FlatMap.next(self: baml.iter.FlatMap) -> R | baml.iter.Done throws E | E2 | E3 { + { : baml.iter.Done + while true + { : void + match (self.inner : baml.iter.Iterator | baml.iter.Done) : void + cur: Iterator => + { : void + match (cur.next() : R | baml.iter.Done) : void + Done => + { : void + self.inner = Done { } : baml.iter.Done + } + y: R => + { : never + return y : R + } + } + Done => + { : void + match (self.source.next() : T | baml.iter.Done) : void + Done => + { : never + return Done { } : baml.iter.Done + } + x: T => + { : void + let it = self.func(x).iter() : baml.iter.Iterator + self.inner = it : baml.iter.Iterator + } + } + } + Done { } : baml.iter.Done + } +} +class baml.iter.Flatten { + source: baml.iter.Iterator + inner: baml.iter.Iterator | baml.iter.Done +} +function baml.iter.Flatten.iter(self: baml.iter.Flatten) -> baml.iter.Iterator throws never { + { : baml.iter.Flatten + self : baml.iter.Flatten + } +} +function baml.iter.Flatten.next(self: baml.iter.Flatten) -> R | baml.iter.Done throws E | E3 { + { : baml.iter.Done + while true + { : void + match (self.inner : baml.iter.Iterator | baml.iter.Done) : void + cur: Iterator => + { : void + match (cur.next() : R | baml.iter.Done) : void + Done => + { : void + self.inner = Done { } : baml.iter.Done + } + y: R => + { : never + return y : R + } + } + Done => + { : void + match (self.source.next() : I | baml.iter.Done) : void + Done => + { : never + return Done { } : baml.iter.Done + } + x: I => + { : void + let it = x.iter() : baml.iter.Iterator + self.inner = it : baml.iter.Iterator + } + } + } + Done { } : baml.iter.Done + } +} +class baml.iter.Peekable { + source: baml.iter.Iterator + buffer: T | baml.iter.Done + has_buffer: bool +} +function baml.iter.Peekable.peek(self: baml.iter.Peekable) -> T | baml.iter.Done throws E { + { : T | baml.iter.Done + if (self.has_buffer : bool) : void + { : never + return self.buffer : T | baml.iter.Done + } + let v = self.source.next() : T | baml.iter.Done + self.buffer = v : T | baml.iter.Done + self.has_buffer = true : true + v : T | baml.iter.Done + } +} +function baml.iter.Peekable.iter(self: baml.iter.Peekable) -> baml.iter.Iterator throws never { + { : baml.iter.Peekable + self : baml.iter.Peekable + } +} +function baml.iter.Peekable.next(self: baml.iter.Peekable) -> T | baml.iter.Done throws E { + { : T | baml.iter.Done + if (self.has_buffer : bool) : void + { : never + let v = self.buffer : T | baml.iter.Done + self.buffer = Done { } : baml.iter.Done + self.has_buffer = false : false + return v : T | baml.iter.Done + } + self.source.next() : T | baml.iter.Done + } +} +class baml.iter.StepBy { + source: baml.iter.Iterator + n: int + first: bool +} +function baml.iter.StepBy.iter(self: baml.iter.StepBy) -> baml.iter.Iterator throws never { + { : baml.iter.StepBy + self : baml.iter.StepBy + } +} +function baml.iter.StepBy.next(self: baml.iter.StepBy) -> T | baml.iter.Done throws E { + { : T | baml.iter.Done + if (self.first : bool) : void + { : never + self.first = false : false + return self.source.next() : T | baml.iter.Done + } + { : void + let i = 0 : 0 -> int + while i < self.n - 1 + { : void + match (self.source.next() : T | baml.iter.Done) : void + Done => + { : never + return Done { } : baml.iter.Done + } + x: T => + { : void + } + } + } + self.source.next() : T | baml.iter.Done + } +} +class baml.iter.Chain { + first: baml.iter.Iterator + other: baml.iter.Iterator + first_done: bool +} +function baml.iter.Chain.iter(self: baml.iter.Chain) -> baml.iter.Iterator throws never { + { : baml.iter.Chain + self : baml.iter.Chain + } +} +function baml.iter.Chain.next(self: baml.iter.Chain) -> T | baml.iter.Done throws E | E2 { + { : T | baml.iter.Done + if (Not self.first_done : bool) : void + { : void + match (self.first.next() : T | baml.iter.Done) : void + Done => + { : void + self.first_done = true : true + } + x: T => + { : never + return x : T + } + } + self.other.next() : T | baml.iter.Done + } +} +function baml.iter.iter(self: unknown) -> baml.iter.Iterator throws never { + { : baml.iter.ArrayIterator + ArrayIterator.new(self) : baml.iter.ArrayIterator + } +} +function baml.iter.iter(self: unknown) -> baml.iter.Iterator throws never { + { : baml.iter.Iterator + self.chars().iter() : baml.iter.Iterator + } +} +class baml.iter.Done$stream { +} +class baml.iter.ArrayIterator$stream { + arr: T[] + idx: int | null +} +class baml.iter.Range$stream { + i: int | null + max: int | null + step: int | null +} +class baml.iter.Repeat$stream { + value: T | null + count: int | null +} +class baml.iter.Map$stream { + source: baml.iter.Iterator | null + func: unknown +} +class baml.iter.Filter$stream { + source: baml.iter.Iterator | null + predicate: unknown +} +class baml.iter.FilterMap$stream { + source: baml.iter.Iterator | null + func: unknown +} +class baml.iter.FlatMap$stream { + source: baml.iter.Iterator | null + func: unknown + inner: baml.iter.Iterator | baml.iter.Done$stream | null +} +class baml.iter.Flatten$stream { + source: baml.iter.Iterator | null + inner: baml.iter.Iterator | baml.iter.Done$stream | null +} +class baml.iter.Peekable$stream { + source: baml.iter.Iterator | null + buffer: T | baml.iter.Done$stream | null + has_buffer: bool | null +} +class baml.iter.StepBy$stream { + source: baml.iter.Iterator | null + n: int | null + first: bool | null +} +class baml.iter.Chain$stream { + first: baml.iter.Iterator | null + other: baml.iter.Iterator | null + first_done: bool | null +} + +--- /baml/ns_json/json.baml --- +type baml.json.json = null | bool | int | float | string | baml.json.json[] | map +class baml.json.JsonParseError { + message: string +} +class baml.json.JsonDecodeError { + message: string + path: string +} +class baml.json.JsonSerializationError { + message: string + path: string + reason: string +} +function baml.json.from(value: T) -> baml.json.json throws baml.json.JsonSerializationError { + { : baml.json.json + root._to_json_shim(value) : baml.json.json + } +} +function baml.json.to(j: baml.json.json) -> T throws baml.json.JsonDecodeError { + { : T + root._from_json_shim(j) : T + } +} +class baml.json.JsonPathError { + message: string + selector: string +} +function baml.json._path_field(current: baml.json.json, key: string, selector: string) -> baml.json.json throws baml.json.JsonPathError { + { : baml.json.json | null + match (current : baml.json.json) : baml.json.json | null + m: map => + { : baml.json.json | null + if (Not m.has(key) : bool) : void + { : never + throw JsonPathError { message: "missing field '" + key + "'", selector: selector } : baml.json.JsonPathError + } + m.get(key) : baml.json.json | null + } + _ => + { : never + throw JsonPathError { message: "field access '." + key + "' on a non-object", selector: selector } : baml.json.JsonPathError + } + } +} +function baml.json._path_index(current: baml.json.json, idx: int, selector: string) -> baml.json.json throws baml.json.JsonPathError { + { : baml.json.json | null + match (current : baml.json.json) : baml.json.json | null + arr: baml.json.json[] => + { : baml.json.json | null + if (idx < 0 || idx >= arr.length() : bool) : void + { : never + throw JsonPathError { message: "index [" + idx.to_string() + "] out of bounds (..." + arr.length().to_string() + ")", selector: selector } : baml.json.JsonPathError + } + arr.at(idx) : baml.json.json | null + } + _ => + { : never + throw JsonPathError { message: "index [" + idx.to_string() + "] on a non-array", selector: selector } : baml.json.JsonPathError + } + } +} +function baml.json.path(j: baml.json.json, selector: string) -> T throws baml.json.JsonPathError { + { : T + if (Not selector.starts_with(".") || selector.starts_with("[") : bool) : void + { : never + throw JsonPathError { message: "selector must sta..." + selector + "'", selector: selector } : baml.json.JsonPathError + } + let current: baml.json.json = j : baml.json.json -> int | float | string | bool | null | baml.json.json[] | map + let i = 0 : 0 -> int + while i < selector.length() + { : void + let marker = selector.substring(i, i + 1) : string + if (marker == "." : bool) : void + { : never + i Add= 1 : int + let start = i : int + while i < selector.length() && selector.substring(i, i + 1) != "." && selector.substring(i, i + 1) != "[" + { : void + i Add= 1 : int + } + if (i > start : bool) : void + { : void + current = _path_field(current, selector.substring(start, i), selector) : baml.json.json + } + continue + } + if (marker != "[" : bool) : void + { : never + throw JsonPathError { message: "expected '.' or '..." + i.to_string(), selector: selector } : baml.json.JsonPathError + } + i Add= 1 : int + if (i >= selector.length() : bool) : void + { : never + throw JsonPathError { message: "unterminated '[' ...", selector: selector } : baml.json.JsonPathError + } + let first = selector.substring(i, i + 1) : string + if (first == "\"" || first == "'" : bool) : void + { : never + let quote = first : string + i Add= 1 : int + let key = "" : "" -> string + let closed = false : false -> bool + while i < selector.length() + { : void + let ch = selector.substring(i, i + 1) : string + if (ch == "\\" : bool) : void + { : never + if (i + 1 >= selector.length() : bool) : void + { : never + throw JsonPathError { message: "unterminated esca...", selector: selector } : baml.json.JsonPathError + } + key = key + selector.substring(i + 1, i + 2) : string + i Add= 2 : int + continue + } + if (ch == quote : bool) : void + { : never + closed = true : true + i Add= 1 : int + break + } + key = key + ch : string + i Add= 1 : int + } + if (Not closed || i >= selector.length() || selector.substring(i, i + 1) != "]" : bool) : void + { : never + throw JsonPathError { message: "unterminated quot...", selector: selector } : baml.json.JsonPathError + } + i Add= 1 : int + current = _path_field(current, key, selector) : baml.json.json + continue + } + let start = i : int + while i < selector.length() && selector.substring(i, i + 1) != "]" + { : void + i Add= 1 : int + } + if (i >= selector.length() : bool) : void + { : never + throw JsonPathError { message: "unterminated '[' ...", selector: selector } : baml.json.JsonPathError + } + let token = selector.substring(start, i) : string + i Add= 1 : int + let idx = : int + catch (int.parse(token) : int) : int + catch (_) + root.errors.ParseError => + { : never + throw JsonPathError { message: "bad bracket token '[" + token + "]'", selector: selector } : baml.json.JsonPathError + } + current = _path_index(current, idx, selector) : baml.json.json + } + catch (to(current) : T) : T + catch (_) + JsonDecodeError => + { : never + throw JsonPathError { message: "leaf does not coe...", selector: selector } : baml.json.JsonPathError + } + } +} +function baml.json.path_or(j: baml.json.json, selector: string, default: T) -> T throws never { + { : T + catch (path(j, selector) : T) : T + catch (_) + JsonPathError => + default : T + } +} +function baml.json.serialize(v: T) -> string throws baml.json.JsonSerializationError { + { : string + stringify(to_json(v)) : string + } +} +function baml.json.deserialize(s: string) -> T throws baml.json.JsonParseError | baml.json.JsonDecodeError { + { : T + from_json(parse(s)) : T + } +} +type baml.json.json$stream = null | bool | int | float | string | baml.json.json$stream[] | map +class baml.json.JsonParseError$stream { + message: string | null +} +class baml.json.JsonDecodeError$stream { + message: string | null + path: string | null +} +class baml.json.JsonSerializationError$stream { + message: string | null + path: string | null + reason: string | null +} +class baml.json.JsonPathError$stream { + message: string | null + selector: string | null +} + +--- /baml/ns_media/media.baml --- +class baml.media.Pdf { + _data: $rust_type +} +class baml.media.Audio { + _data: $rust_type +} +class baml.media.Video { + _data: $rust_type +} +class baml.media.Image { + _data: $rust_type +} +class baml.media.Pdf$stream { + _data: $rust_type +} +class baml.media.Audio$stream { + _data: $rust_type +} +class baml.media.Video$stream { + _data: $rust_type +} +class baml.media.Image$stream { + _data: $rust_type +} + +--- /baml/ns_net/net.baml --- +function baml.net._timeout_nanos(timeout: baml.time.Duration | null) -> bigint throws never { + { : 0n | bigint + match (timeout : baml.time.Duration | null) : 0n | bigint + null => + 0n : 0n + t: root.time.Duration => + t.to_nanoseconds() : bigint + } +} +class baml.net.TcpStream { + _handle: $rust_type +} +function baml.net.TcpStream.connect(addr: string, timeout: baml.time.Duration | null = null) -> baml.net.TcpStream throws baml.errors.Io | baml.errors.Timeout { + { : baml.net.TcpStream + TcpStream._connect(addr, _timeout_nanos(timeout)) : baml.net.TcpStream + } +} +function baml.net.TcpStream.read(self: baml.net.TcpStream, timeout: baml.time.Duration | null = null) -> uint8array throws baml.errors.Io | baml.errors.Timeout { + { : uint8array + self._read(_timeout_nanos(timeout)) : uint8array + } +} +function baml.net.TcpStream.write(self: baml.net.TcpStream, data: uint8array, timeout: baml.time.Duration | null = null) -> null throws baml.errors.Io | baml.errors.Timeout { + { : null + self._write(data, _timeout_nanos(timeout)) : null + } +} +class baml.net.TcpListener { + _handle: $rust_type +} +class baml.net.UdpSocket { + _handle: $rust_type +} +function baml.net.UdpSocket.send_to(self: baml.net.UdpSocket, data: uint8array, addr: string, timeout: baml.time.Duration | null = null) -> int throws baml.errors.Io | baml.errors.Timeout { + { : int + self._send_to(data, addr, _timeout_nanos(timeout)) : int + } +} +function baml.net.UdpSocket.recv_from(self: baml.net.UdpSocket, timeout: baml.time.Duration | null = null) -> baml.net.Datagram throws baml.errors.Io | baml.errors.Timeout { + { : baml.net.Datagram + self._recv_from(_timeout_nanos(timeout)) : baml.net.Datagram + } +} +class baml.net.Datagram { + data: uint8array + addr: string +} +class baml.net.TcpStream$stream { + _handle: $rust_type +} +class baml.net.TcpListener$stream { + _handle: $rust_type +} +class baml.net.UdpSocket$stream { + _handle: $rust_type +} +class baml.net.Datagram$stream { + data: uint8array + addr: string | null +} + +--- /baml/ns_ops/comparison.baml --- +function baml.ops.Equals.neq(self: baml.ops.Equals, other: Self) -> bool throws never { + { : bool + Not self.eq(other) : bool + } +} +function baml.ops.Compare.le(self: baml.ops.Compare, other: Self) -> bool throws never { + { : bool + self.lt(other) || self.eq(other) : bool + } +} +function baml.ops.Compare.gt(self: baml.ops.Compare, other: Self) -> bool throws never { + { : bool + Not self.le(other) : bool + } +} +function baml.ops.Compare.ge(self: baml.ops.Compare, other: Self) -> bool throws never { + { : bool + Not self.lt(other) : bool + } +} +function baml.ops.lt(self: unknown, other: !error) -> bool throws never { + { : bool + Not self && other : bool + } +} +function baml.ops.gt(self: unknown, other: !error) -> bool throws never { + { : bool + self && Not other : bool + } +} +function baml.ops.eq(self: unknown, other: !error) -> bool throws never { + { : true + true : true + } +} +function baml.ops.neq(self: unknown, other: !error) -> bool throws never { + { : false + false : false + } +} +function baml.ops.eq(self: unknown, other: !error) -> bool throws never { + { : bool + baml.ops.equals_equals(self, other) : bool + } +} +function baml.ops.eq(self: unknown, other: !error) -> bool throws never { + { : bool + baml.ops.equals_equals(self, other) : bool + } +} + +--- /baml/ns_ops/math.baml --- + +--- /baml/ns_panics/panics.baml --- +class baml.panics.DivisionByZero { + dividend: int +} +class baml.panics.IndexOutOfBounds { + index: int + length: int +} +class baml.panics.InvalidFieldAccess { + field_index: int + field_count: int +} +class baml.panics.MapKeyNotFound { + key: string +} +class baml.panics.StackOverflow { + message: string +} +class baml.panics.AssertionFailed { + message: string +} +class baml.panics.Unreachable { + message: string +} +class baml.panics.Cancelled { + message: string +} +class baml.panics.UserPanic { + message: string +} +class baml.panics.Exit { + code: int +} +class baml.panics.AllocFailure { + message: string +} +class baml.panics.HostUnavailable { + resource: string + message: string +} +class baml.panics.NegativeBitShift { + message: string +} +class baml.panics.SdkPanic { + message: string +} +class baml.panics.HostContractViolation { + message: string + class_name: string | null + language: string | null +} +class baml.panics.IntegerOverflow { + message: string +} +type baml.panics.Panic = baml.panics.DivisionByZero | baml.panics.IndexOutOfBounds | baml.panics.InvalidFieldAccess | baml.panics.MapKeyNotFound | baml.panics.StackOverflow | baml.panics.AssertionFailed | baml.panics.Unreachable | baml.panics.Cancelled | baml.panics.UserPanic | baml.panics.Exit | baml.panics.AllocFailure | baml.panics.HostUnavailable | baml.panics.NegativeBitShift | baml.panics.SdkPanic | baml.panics.HostContractViolation | baml.panics.IntegerOverflow +class baml.panics.DivisionByZero$stream { + dividend: int | null +} +class baml.panics.IndexOutOfBounds$stream { + index: int | null + length: int | null +} +class baml.panics.InvalidFieldAccess$stream { + field_index: int | null + field_count: int | null +} +class baml.panics.MapKeyNotFound$stream { + key: string | null +} +class baml.panics.StackOverflow$stream { + message: string | null +} +class baml.panics.AssertionFailed$stream { + message: string | null +} +class baml.panics.Unreachable$stream { + message: string | null +} +class baml.panics.Cancelled$stream { + message: string | null +} +class baml.panics.UserPanic$stream { + message: string | null +} +class baml.panics.Exit$stream { + code: int | null +} +class baml.panics.AllocFailure$stream { + message: string | null +} +class baml.panics.HostUnavailable$stream { + resource: string | null + message: string | null +} +class baml.panics.NegativeBitShift$stream { + message: string | null +} +class baml.panics.SdkPanic$stream { + message: string | null +} +class baml.panics.HostContractViolation$stream { + message: string | null + class_name: string | null + language: string | null +} +class baml.panics.IntegerOverflow$stream { + message: string | null +} +type baml.panics.Panic$stream = baml.panics.DivisionByZero$stream | baml.panics.IndexOutOfBounds$stream | baml.panics.InvalidFieldAccess$stream | baml.panics.MapKeyNotFound$stream | baml.panics.StackOverflow$stream | baml.panics.AssertionFailed$stream | baml.panics.Unreachable$stream | baml.panics.Cancelled$stream | baml.panics.UserPanic$stream | baml.panics.Exit$stream | baml.panics.AllocFailure$stream | baml.panics.HostUnavailable$stream | baml.panics.NegativeBitShift$stream | baml.panics.SdkPanic$stream | baml.panics.HostContractViolation$stream | baml.panics.IntegerOverflow$stream + +--- /baml/ns_prompt/prompt.baml --- +class baml.prompt.OutputFormat { + _data: $rust_type +} +class baml.prompt.Role { + name: string + metadata: map +} +class baml.prompt.ContextClient { + name: string + provider: string + default_role: string + allowed_roles: string[] +} +class baml.prompt.Context { + client: baml.prompt.ContextClient + tags: map + output_format: string + _output_format: baml.prompt.OutputFormat +} +function baml.prompt.make_role(name: string) -> baml.prompt.Role throws never { + { : baml.prompt.Role + Role { name: name, metadata: map { } } : baml.prompt.Role + } +} +class baml.prompt.OutputFormat$stream { + _data: $rust_type +} +class baml.prompt.Role$stream { + name: string | null + metadata: map +} +class baml.prompt.ContextClient$stream { + name: string | null + provider: string | null + default_role: string | null + allowed_roles: string[] +} +class baml.prompt.Context$stream { + client: baml.prompt.ContextClient$stream | null + tags: map + output_format: string | null + _output_format: baml.prompt.OutputFormat$stream | null +} + +--- /baml/ns_prompt/sys_llm_types.baml --- +class baml.prompt.MediaUrlHandler { + image: string | null + audio: string | null + video: string | null + pdf: string | null +} +class baml.prompt.PrimitiveClientOptions { + model: string | null + base_url: string | null + allowed_role_metadata: unknown | null + finish_reason_allow_list: string[] | null + finish_reason_deny_list: string[] | null + supports_streaming: bool | null + default_role: string | null + allowed_roles: string[] | null + remap_roles: map | null + api_key: string | null + provider_options: baml.prompt.AnthropicOptions | baml.prompt.AzureOpenAiOptions | baml.prompt.BedrockOptions | baml.prompt.GoogleAiOptions | baml.prompt.VertexAiOptions | null + media_url_handler: baml.prompt.MediaUrlHandler | null + headers: map + query_params: map + request_body: map +} +class baml.prompt.AzureOpenAiOptions { + resource_name: string | null + deployment_id: string | null + api_version: string + max_tokens: int | null +} +class baml.prompt.AnthropicOptions { + max_tokens: int | null +} +class baml.prompt.GoogleAiOptions { + enterprise: bool | null + credentials: string | null + credentials_content: string | null + location: string | null + project_id: string | null +} +class baml.prompt.VertexAiOptions { + credentials: string | null + credentials_content: string | null + location: string | null + project_id: string | null +} +class baml.prompt.BedrockOptions { + region: string | null + endpoint_url: string | null + access_key_id: string | null + secret_access_key: string | null + session_token: string | null + profile: string | null + stop_sequences: string[] | null + max_tokens: int | null + temperature: float | null + top_p: float | null +} +class baml.prompt.MediaUrlHandler$stream { + image: string | null + audio: string | null + video: string | null + pdf: string | null +} +class baml.prompt.PrimitiveClientOptions$stream { + model: string | null + base_url: string | null + allowed_role_metadata: unknown | null + finish_reason_allow_list: string[] | null + finish_reason_deny_list: string[] | null + supports_streaming: bool | null + default_role: string | null + allowed_roles: string[] | null + remap_roles: map | null + api_key: string | null + provider_options: baml.prompt.AnthropicOptions$stream | baml.prompt.AzureOpenAiOptions$stream | baml.prompt.BedrockOptions$stream | baml.prompt.GoogleAiOptions$stream | baml.prompt.VertexAiOptions$stream | null + media_url_handler: baml.prompt.MediaUrlHandler$stream | null + headers: map + query_params: map + request_body: map +} +class baml.prompt.AzureOpenAiOptions$stream { + resource_name: string | null + deployment_id: string | null + api_version: string | null + max_tokens: int | null +} +class baml.prompt.AnthropicOptions$stream { + max_tokens: int | null +} +class baml.prompt.GoogleAiOptions$stream { + enterprise: bool | null + credentials: string | null + credentials_content: string | null + location: string | null + project_id: string | null +} +class baml.prompt.VertexAiOptions$stream { + credentials: string | null + credentials_content: string | null + location: string | null + project_id: string | null +} +class baml.prompt.BedrockOptions$stream { + region: string | null + endpoint_url: string | null + access_key_id: string | null + secret_access_key: string | null + session_token: string | null + profile: string | null + stop_sequences: string[] | null + max_tokens: int | null + temperature: float | null + top_p: float | null +} + +--- /baml/ns_random/random.baml --- +function baml.random.Rng.random_int(self: baml.random.Rng) -> int throws never { + { : int + let bytes = self.random(8) : uint8array + let magnitude = bytes[0] & 63 << 56 | bytes[1] << 48 | bytes[2] << 40 | bytes[3] << 32 | bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7] : int + if (bytes[0] & 64 == 0 : bool) : int + { : int + magnitude : int + } + else + { : int + 0 - magnitude - 1 : int + } + } +} +class baml.random.SystemRandom { +} +function baml.random.SystemRandom.get() -> baml.random.SystemRandom throws never { + { : baml.random.SystemRandom + SystemRandom { } : baml.random.SystemRandom + } +} +class baml.random.Xoshiro256PlusPlus { + _state: $rust_type +} +function baml.random.Xoshiro256PlusPlus.new(seed: uint8array = SystemRandom.get().random(32)) -> baml.random.Xoshiro256PlusPlus throws never { + { : baml.random.Xoshiro256PlusPlus + Xoshiro256PlusPlus._new(seed) : baml.random.Xoshiro256PlusPlus + } +} +class baml.random.ChaCha20 { + _state: $rust_type +} +function baml.random.ChaCha20.new(seed: uint8array = SystemRandom.get().random(32)) -> baml.random.ChaCha20 throws never { + { : baml.random.ChaCha20 + ChaCha20._new(seed) : baml.random.ChaCha20 + } +} +class baml.random.SystemRandom$stream { +} +class baml.random.Xoshiro256PlusPlus$stream { + _state: $rust_type +} +class baml.random.ChaCha20$stream { + _state: $rust_type +} + +--- /baml/ns_sap/sap.baml --- +class baml.sap.ParseCache { + _data: $rust_type +} +class baml.sap.NoYield { +} +function baml.sap.__new_parse_cache() -> baml.sap.ParseCache throws never { + { : baml.sap.ParseCache + let cache: ParseCache = ParseCache.new(reflect.type_of(), reflect.type_of()) : baml.sap.ParseCache + cache : baml.sap.ParseCache + } +} +function baml.sap.parse(text: string) -> T throws baml.errors.LlmClient { + { : T + let cache = __new_parse_cache() : baml.sap.ParseCache + __parse_final(text, cache) : T + } +} +function baml.sap.parse_type(t: type, text: string) -> unknown throws baml.errors.LlmClient { + { : unknown + let cache: ParseCache = ParseCache.new(t, t) : baml.sap.ParseCache + __parse_final(text, cache) : unknown + } +} +class baml.sap.ParseCache$stream { + _data: $rust_type +} +class baml.sap.NoYield$stream { +} + +--- /baml/ns_spawn/spawn.baml --- +class baml.spawn.SpawnParams { + body: () -> T throws E + name: string | null + group: baml.spawn.TaskGroup | null + cancel: baml.spawn.CancelToken | null + detach: bool +} +class baml.spawn.TaskGroup { + _handle: $rust_type +} +class baml.spawn.CancelToken { + _handle: $rust_type +} +function baml.spawn.options(group: baml.spawn.TaskGroup | null = null, cancel: baml.spawn.CancelToken | null = null, detach: bool | null = null) -> (baml.spawn.SpawnParams) -> baml.spawn.SpawnParams throws never throws never { + { : (params: baml.spawn.SpawnParams) -> baml.spawn.SpawnParams throws never + (params: SpawnParams) -> SpawnParams { ... } : (params: baml.spawn.SpawnParams) -> baml.spawn.SpawnParams throws never + { + SpawnParams { body: params.body, name: params.name, group: group ?? params.group, cancel: cancel ?? params.cancel, detach: detach ?? params.detach } + } + } +} +lambda baml.spawn.options { +} +class baml.spawn.SpawnParams$stream { + body: unknown + name: string | null + group: baml.spawn.TaskGroup$stream | null + cancel: baml.spawn.CancelToken$stream | null + detach: bool | null +} +class baml.spawn.TaskGroup$stream { + _handle: $rust_type +} +class baml.spawn.CancelToken$stream { + _handle: $rust_type +} + +--- /baml/ns_sys/sys.baml --- +class baml.sys.ProcessOptions { + cwd: string | null + env: map | null + timeout_ms: int | null + stdin: string | null + keep_stdin_open: bool | null +} +class baml.sys.ShellOutput { + stdout: uint8array + stderr: uint8array + exit_code: int +} +function baml.sys.ShellOutput.ok(self: baml.sys.ShellOutput) -> bool throws never { + { : bool + self.exit_code == 0 : bool + } +} +class baml.sys.ProcessExit { + exit_code: int + signal: string | null +} +function baml.sys.ProcessExit.ok(self: baml.sys.ProcessExit) -> bool throws never { + { : bool + self.exit_code == 0 : bool + } +} +class baml.sys.ProcessLineStream { + _handle: $rust_type +} +function baml.sys.ProcessLineStream.iter(self: baml.sys.ProcessLineStream) -> baml.iter.Iterator throws never { + { : baml.sys.ProcessLineStream + self : baml.sys.ProcessLineStream + } +} +function baml.sys.ProcessLineStream.next(self: baml.sys.ProcessLineStream) -> string | baml.iter.Done throws baml.errors.Io | baml.errors.Timeout { + { : string | baml.iter.Done + match (self._next() : string | null) : string | baml.iter.Done + line: string => + line : string + null => + root.iter.Done { } : baml.iter.Done + } +} +class baml.sys.Process { + stdout: baml.sys.ProcessLineStream + _handle: $rust_type +} +class baml.sys.ProcessOptions$stream { + cwd: string | null + env: map | null + timeout_ms: int | null + stdin: string | null + keep_stdin_open: bool | null +} +class baml.sys.ShellOutput$stream { + stdout: uint8array + stderr: uint8array + exit_code: int | null +} +class baml.sys.ProcessExit$stream { + exit_code: int | null + signal: string | null +} +class baml.sys.ProcessLineStream$stream { + _handle: $rust_type +} +class baml.sys.Process$stream { + stdout: baml.sys.ProcessLineStream$stream | null + _handle: $rust_type +} + +--- /baml/ns_time/duration.baml --- +class baml.time.Duration { + _nanoseconds: bigint +} +function baml.time.Duration.abs(self: baml.time.Duration) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds.abs() } : baml.time.Duration + } +} +function baml.time.Duration.from_nanoseconds(ns: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (ns) { value: bigint => value, value: int => 0n + value } } : baml.time.Duration + } +} +function baml.time.Duration.from_microseconds(us: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (us) { value: bigint => value, value: int => 0n + value } * 1000n } : baml.time.Duration + } +} +function baml.time.Duration.from_milliseconds(ms: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (ms) { value: bigint => value, value: int => 0n + value } * 1000000n } : baml.time.Duration + } +} +function baml.time.Duration.from_seconds(s: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (s) { value: bigint => value, value: int => 0n + value } * 1000000000n } : baml.time.Duration + } +} +function baml.time.Duration.from_minutes(m: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (m) { value: bigint => value, value: int => 0n + value } * 60000000000n } : baml.time.Duration + } +} +function baml.time.Duration.from_hours(h: int | bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: match (h) { value: bigint => value, value: int => 0n + value } * 3600000000000n } : baml.time.Duration + } +} +function baml.time.Duration.to_nanoseconds(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds : bigint + } +} +function baml.time.Duration.to_microseconds(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds / 1000 : bigint + } +} +function baml.time.Duration.to_milliseconds(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds / 1000000 : bigint + } +} +function baml.time.Duration.to_seconds(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds / 1000000000 : bigint + } +} +function baml.time.Duration.to_minutes(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds / 60000000000 : bigint + } +} +function baml.time.Duration.to_hours(self: baml.time.Duration) -> bigint throws never { + { : bigint + self._nanoseconds / 3600000000000 : bigint + } +} +function baml.time.Duration.add(self: baml.time.Duration, other: baml.time.Duration) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds + other._nanoseconds } : baml.time.Duration + } +} +function baml.time.Duration.sub(self: baml.time.Duration, other: baml.time.Duration) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.Duration + } +} +function baml.time.Duration.mul(self: baml.time.Duration, other: int) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds * other } : baml.time.Duration + } +} +function baml.time.Duration.mul(self: baml.time.Duration, other: bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds * other } : baml.time.Duration + } +} +function baml.time.Duration.div(self: baml.time.Duration, other: int) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds / other } : baml.time.Duration + } +} +function baml.time.Duration.div(self: baml.time.Duration, other: bigint) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds / other } : baml.time.Duration + } +} +function baml.time.Duration.rem(self: baml.time.Duration, other: baml.time.Duration) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds % other._nanoseconds } : baml.time.Duration + } +} +function baml.time.Duration.neg(self: baml.time.Duration) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: Neg self._nanoseconds } : baml.time.Duration + } +} +class baml.time.Duration$stream { + _nanoseconds: bigint | null +} + +--- /baml/ns_time/instant.baml --- +class baml.time.Instant { + _nanoseconds: bigint +} +function baml.time.Instant.elapsed(self: baml.time.Instant) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: Instant.now()._nanoseconds - self._nanoseconds } : baml.time.Duration + } +} +function baml.time.Instant.max(self: baml.time.Instant, other: baml.time.Instant) -> baml.time.Instant throws never { + { : baml.time.Instant + if (other._nanoseconds > self._nanoseconds : bool) : baml.time.Instant + { : baml.time.Instant + other : baml.time.Instant + } + else + { : baml.time.Instant + self : baml.time.Instant + } + } +} +function baml.time.Instant.min(self: baml.time.Instant, other: baml.time.Instant) -> baml.time.Instant throws never { + { : baml.time.Instant + if (other._nanoseconds < self._nanoseconds : bool) : baml.time.Instant + { : baml.time.Instant + other : baml.time.Instant + } + else + { : baml.time.Instant + self : baml.time.Instant + } + } +} +function baml.time.Instant.abs_diff(self: baml.time.Instant, other: baml.time.Instant) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds - other._nanoseconds.abs() } : baml.time.Duration + } +} +function baml.time.Instant.from_timestamp_nanoseconds(ns: bigint) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: ns } : baml.time.Instant + } +} +function baml.time.Instant.from_timestamp_microseconds(us: bigint) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: us * 1000 } : baml.time.Instant + } +} +function baml.time.Instant.from_timestamp_milliseconds(ms: bigint) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: ms * 1000000 } : baml.time.Instant + } +} +function baml.time.Instant.from_timestamp_seconds(s: bigint) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: s * 1000000000 } : baml.time.Instant + } +} +function baml.time.Instant.to_timestamp_nanoseconds(self: baml.time.Instant) -> bigint throws never { + { : bigint + self._nanoseconds : bigint + } +} +function baml.time.Instant.to_timestamp_microseconds(self: baml.time.Instant) -> bigint throws never { + { : bigint + self._nanoseconds / 1000 : bigint + } +} +function baml.time.Instant.to_timestamp_milliseconds(self: baml.time.Instant) -> bigint throws never { + { : bigint + self._nanoseconds / 1000000 : bigint + } +} +function baml.time.Instant.to_timestamp_seconds(self: baml.time.Instant) -> bigint throws never { + { : bigint + self._nanoseconds / 1000000000 : bigint + } +} +function baml.time.Instant.epoch() -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: 0n } : baml.time.Instant + } +} +function baml.time.Instant.to_string(self: baml.time.Instant) -> string throws never { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + root.sys.panic("Instant.to_string: " + message) : never + } + } +} +function baml.time.Instant.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.time.Instant + match (j : baml.json.json) : baml.time.Instant + string => + { : baml.time.Instant + catch (Instant.parse(j) : baml.time.Instant) : baml.time.Instant + catch (_) + root.errors.ParseError { message: message } => + { : never + throw baml.json.JsonDecodeError { message: message, path: "" } : baml.json.JsonDecodeError + } + } + _ => + { : never + throw baml.json.JsonDecodeError { message: "Expected timestam...", path: "" } : baml.json.JsonDecodeError + } + } +} +function baml.time.Instant.to_json(self: baml.time.Instant) -> baml.json.json throws baml.json.JsonSerializationError { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + throw baml.json.JsonSerializationError { message: message, path: "" } : baml.json.JsonSerializationError + } + } +} +function baml.time.Instant.add(self: baml.time.Instant, other: baml.time.Duration) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: self._nanoseconds + other._nanoseconds } : baml.time.Instant + } +} +function baml.time.Instant.sub(self: baml.time.Instant, other: baml.time.Duration) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.Instant + } +} +function baml.time.Instant.sub(self: baml.time.Instant, other: baml.time.Instant) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.Duration + } +} +class baml.time.Instant$stream { + _nanoseconds: bigint | null +} + +--- /baml/ns_time/plaindate.baml --- +class baml.time.PlainDate { + _days: int +} +function baml.time.PlainDate.to_plain_datetime(self: baml.time.PlainDate, time: baml.time.PlainTime | null = null) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + self._to_plain_datetime(time) : baml.time.PlainDateTime + } +} +function baml.time.PlainDate.to_string(self: baml.time.PlainDate) -> string throws never { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + root.sys.panic("PlainDate.to_stri..." + message) : never + } + } +} +function baml.time.PlainDate.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.time.PlainDate + match (j : baml.json.json) : baml.time.PlainDate + string => + { : baml.time.PlainDate + catch (PlainDate.parse(j) : baml.time.PlainDate) : baml.time.PlainDate + catch (_) + root.errors.ParseError { message: message } => + { : never + throw baml.json.JsonDecodeError { message: message, path: "" } : baml.json.JsonDecodeError + } + } + _ => + { : never + throw baml.json.JsonDecodeError { message: "Expected ISO 8601...", path: "" } : baml.json.JsonDecodeError + } + } +} +function baml.time.PlainDate.to_json(self: baml.time.PlainDate) -> baml.json.json throws baml.json.JsonSerializationError { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + throw baml.json.JsonSerializationError { message: message, path: "" } : baml.json.JsonSerializationError + } + } +} +class baml.time.PlainDate$stream { + _days: int | null +} + +--- /baml/ns_time/plaindatetime.baml --- +class baml.time.PlainDateTime { + _nanoseconds: bigint +} +function baml.time.PlainDateTime.from_components(year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0, millisecond: int = 0, microsecond: int = 0, nanosecond: int = 0) -> baml.time.PlainDateTime throws baml.errors.InvalidArgument { + { : baml.time.PlainDateTime + PlainDateTime._from_components(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond) : baml.time.PlainDateTime + } +} +function baml.time.PlainDateTime.to_zoned(self: baml.time.PlainDateTime, timezone: baml.time.TimeZoneOffset | string, disambiguation: baml.time.Disambiguation = "compatible") -> baml.time.ZonedDateTime throws baml.time.UnknownTimezoneError | baml.time.AmbiguousTimeError | baml.errors.Io { + { : baml.time.ZonedDateTime + match (timezone : baml.time.TimeZoneOffset | string) : baml.time.ZonedDateTime + TimeZoneOffset => + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: self._nanoseconds - timezone._nanoseconds, _offset_ns: timezone._nanoseconds, _iana: null } : baml.time.ZonedDateTime + } + string => + { : baml.time.ZonedDateTime + if (disambiguation == "reject" : bool) : baml.time.ZonedDateTime + { : baml.time.ZonedDateTime + match (_tz_to_instant(timezone, self._nanoseconds, "earlier") : bigint | null) : baml.time.ZonedDateTime + null => + throw UnknownTimezoneError { timezone: timezone } : never + earlier => + { : baml.time.ZonedDateTime + match (_tz_to_instant(timezone, self._nanoseconds, "later") : bigint | null) : baml.time.ZonedDateTime + null => + throw UnknownTimezoneError { timezone: timezone } : never + later => + { : baml.time.ZonedDateTime + if (earlier == later : bool) : baml.time.ZonedDateTime + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: earlier ?? 0n, _offset_ns: null, _iana: timezone } : baml.time.ZonedDateTime + } + else + { : never + throw AmbiguousTimeError { message: "wall-clock time i..." + timezone } : baml.time.AmbiguousTimeError + } + } + } + } + else + { : baml.time.ZonedDateTime + match (_tz_to_instant(timezone, self._nanoseconds, disambiguation) : bigint | null) : baml.time.ZonedDateTime + null => + throw UnknownTimezoneError { timezone: timezone } : never + resolved => + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: resolved ?? 0n, _offset_ns: null, _iana: timezone } : baml.time.ZonedDateTime + } + } + } + } +} +function baml.time.PlainDateTime.max(self: baml.time.PlainDateTime, other: baml.time.PlainDateTime) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + if (other._nanoseconds > self._nanoseconds : bool) : baml.time.PlainDateTime + { : baml.time.PlainDateTime + other : baml.time.PlainDateTime + } + else + { : baml.time.PlainDateTime + self : baml.time.PlainDateTime + } + } +} +function baml.time.PlainDateTime.min(self: baml.time.PlainDateTime, other: baml.time.PlainDateTime) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + if (other._nanoseconds < self._nanoseconds : bool) : baml.time.PlainDateTime + { : baml.time.PlainDateTime + other : baml.time.PlainDateTime + } + else + { : baml.time.PlainDateTime + self : baml.time.PlainDateTime + } + } +} +function baml.time.PlainDateTime.to_string(self: baml.time.PlainDateTime) -> string throws never { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + root.sys.panic("PlainDateTime.to_..." + message) : never + } + } +} +function baml.time.PlainDateTime.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.time.PlainDateTime + match (j : baml.json.json) : baml.time.PlainDateTime + string => + { : baml.time.PlainDateTime + catch (PlainDateTime.parse(j) : baml.time.PlainDateTime) : baml.time.PlainDateTime + catch (_) + root.errors.ParseError { message: message } => + { : never + throw baml.json.JsonDecodeError { message: message, path: "" } : baml.json.JsonDecodeError + } + } + _ => + { : never + throw baml.json.JsonDecodeError { message: "Expected zoneless...", path: "" } : baml.json.JsonDecodeError + } + } +} +function baml.time.PlainDateTime.to_json(self: baml.time.PlainDateTime) -> baml.json.json throws baml.json.JsonSerializationError { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + throw baml.json.JsonSerializationError { message: message, path: "" } : baml.json.JsonSerializationError + } + } +} +function baml.time.PlainDateTime.add(self: baml.time.PlainDateTime, other: baml.time.Duration) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + PlainDateTime { _nanoseconds: self._nanoseconds + other._nanoseconds } : baml.time.PlainDateTime + } +} +function baml.time.PlainDateTime.sub(self: baml.time.PlainDateTime, other: baml.time.Duration) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + PlainDateTime { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.PlainDateTime + } +} +function baml.time.PlainDateTime.sub(self: baml.time.PlainDateTime, other: baml.time.PlainDateTime) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.Duration + } +} +class baml.time.PlainDateTime$stream { + _nanoseconds: bigint | null +} + +--- /baml/ns_time/plaintime.baml --- +class baml.time.PlainTime { + _nanoseconds: int +} +function baml.time.PlainTime.from_components(hour: int, minute: int = 0, second: int = 0, millisecond: int = 0, microsecond: int = 0, nanosecond: int = 0) -> baml.time.PlainTime throws baml.errors.InvalidArgument { + { : baml.time.PlainTime + PlainTime._from_components(hour, minute, second, millisecond, microsecond, nanosecond) : baml.time.PlainTime + } +} +function baml.time.PlainTime.to_plain_datetime(self: baml.time.PlainTime, date: baml.time.PlainDate) -> baml.time.PlainDateTime throws never { + { : baml.time.PlainDateTime + date.to_plain_datetime(time = self) : baml.time.PlainDateTime + } +} +function baml.time.PlainTime.hour(self: baml.time.PlainTime) -> int throws never { + { : int + self._nanoseconds / 3600000000000 : int + } +} +function baml.time.PlainTime.minute(self: baml.time.PlainTime) -> int throws never { + { : int + self._nanoseconds / 60000000000 % 60 : int + } +} +function baml.time.PlainTime.second(self: baml.time.PlainTime) -> int throws never { + { : int + self._nanoseconds / 1000000000 % 60 : int + } +} +function baml.time.PlainTime.millisecond(self: baml.time.PlainTime) -> int throws never { + { : int + self._nanoseconds / 1000000 % 1000 : int + } +} +function baml.time.PlainTime.to_string(self: baml.time.PlainTime) -> string throws never { + { : string + self._to_string_impl() : string + } +} +function baml.time.PlainTime.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.time.PlainTime + match (j : baml.json.json) : baml.time.PlainTime + string => + { : baml.time.PlainTime + catch (PlainTime.parse(j) : baml.time.PlainTime) : baml.time.PlainTime + catch (_) + root.errors.ParseError { message: message } => + { : never + throw baml.json.JsonDecodeError { message: message, path: "" } : baml.json.JsonDecodeError + } + } + _ => + { : never + throw baml.json.JsonDecodeError { message: "Expected ISO 8601...", path: "" } : baml.json.JsonDecodeError + } + } +} +function baml.time.PlainTime.to_json(self: baml.time.PlainTime) -> baml.json.json throws baml.json.JsonSerializationError { + { : baml.json.json + baml.json.from(self.to_string()) : baml.json.json + } +} +function baml.time.PlainTime.add(self: baml.time.PlainTime, other: baml.time.Duration) -> baml.time.PlainTime throws never { + { : baml.time.PlainTime + PlainTime { _nanoseconds: _wrap_into_day(self._nanoseconds + other._nanoseconds) } : baml.time.PlainTime + } +} +function baml.time.PlainTime.sub(self: baml.time.PlainTime, other: baml.time.Duration) -> baml.time.PlainTime throws never { + { : baml.time.PlainTime + PlainTime { _nanoseconds: _wrap_into_day(self._nanoseconds - other._nanoseconds) } : baml.time.PlainTime + } +} +function baml.time.PlainTime.sub(self: baml.time.PlainTime, other: baml.time.PlainTime) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: 0n + self._nanoseconds - other._nanoseconds } : baml.time.Duration + } +} +function baml.time._wrap_into_day(total_ns: bigint) -> int throws never { + { : int + let day_ns = 86400000000000n : 86400000000000n -> bigint + let wrapped = total_ns % day_ns + day_ns % day_ns : bigint + catch ({ 0 stmts + tail } : int) : int + catch (e) + root.errors.InvalidArgument => + baml.sys.panic("unreachable: nano...") : never + } +} +class baml.time.PlainTime$stream { + _nanoseconds: int | null +} + +--- /baml/ns_time/timezone.baml --- +type baml.time.Disambiguation = "compatible" | "earlier" | "later" | "reject" +class baml.time.UnknownTimezoneError { + timezone: string +} +class baml.time.AmbiguousTimeError { + message: string +} +class baml.time.TimeZoneOffset { + _nanoseconds: int +} +function baml.time.TimeZoneOffset.utc() -> baml.time.TimeZoneOffset throws never { + { : baml.time.TimeZoneOffset + TimeZoneOffset { _nanoseconds: 0 } : baml.time.TimeZoneOffset + } +} +function baml.time.TimeZoneOffset.new(hours: int, minutes: int) -> baml.time.TimeZoneOffset throws baml.errors.InvalidArgument { + { : baml.time.TimeZoneOffset + if (hours > 0 && minutes < 0 || hours < 0 && minutes > 0 : bool) : void + { : never + throw root.errors.InvalidArgument { message: "TimeZoneOffset.ne..." } : baml.errors.InvalidArgument + } + let nanoseconds = hours * 60 + minutes * 60 * 1000000000 : int + if (nanoseconds > 86400000000000 || nanoseconds < Neg 86400000000000 : bool) : void + { : never + throw root.errors.InvalidArgument { message: "TimeZoneOffset ou..." } : baml.errors.InvalidArgument + } + TimeZoneOffset { _nanoseconds: nanoseconds } : baml.time.TimeZoneOffset + } +} +function baml.time.TimeZoneOffset.from_timezone(timezone: string, at: baml.time.Instant) -> baml.time.TimeZoneOffset throws baml.time.UnknownTimezoneError | baml.errors.Io { + { : baml.time.TimeZoneOffset + match (_tz_offset_at(timezone, at._nanoseconds) : int | null) : baml.time.TimeZoneOffset + null => + throw UnknownTimezoneError { timezone: timezone } : never + offset => + TimeZoneOffset { _nanoseconds: offset ?? 0 } : baml.time.TimeZoneOffset + } +} +function baml.time.TimeZoneOffset.local() -> baml.time.TimeZoneOffset throws baml.time.UnknownTimezoneError | baml.errors.Io { + { : baml.time.TimeZoneOffset + TimeZoneOffset.from_timezone(system_timezone(), Instant.now()) : baml.time.TimeZoneOffset + } +} +function baml.time.TimeZoneOffset.to_duration(self: baml.time.TimeZoneOffset) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: 0n + self._nanoseconds } : baml.time.Duration + } +} +function baml.time.TimeZoneOffset.hours(self: baml.time.TimeZoneOffset) -> int throws never { + { : int + self._nanoseconds / 3600000000000 : int + } +} +function baml.time.TimeZoneOffset.minutes(self: baml.time.TimeZoneOffset) -> int throws never { + { : int + self._nanoseconds / 60000000000 % 60 : int + } +} +type baml.time.Disambiguation$stream = "compatible" | "earlier" | "later" | "reject" +class baml.time.UnknownTimezoneError$stream { + timezone: string | null +} +class baml.time.AmbiguousTimeError$stream { + message: string | null +} +class baml.time.TimeZoneOffset$stream { + _nanoseconds: int | null +} + +--- /baml/ns_time/zoneddatetime.baml --- +class baml.time.ZonedDateTime { + _nanoseconds: bigint + _offset_ns: int | null + _iana: string | null +} +function baml.time.ZonedDateTime.now() -> baml.time.ZonedDateTime throws baml.errors.Io { + { : baml.time.ZonedDateTime + ZonedDateTime.from_instant(Instant.now(), system_timezone()) : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime.now_in(timezone: baml.time.TimeZoneOffset | string) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + ZonedDateTime.from_instant(Instant.now(), timezone) : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime.from_instant(instant: baml.time.Instant, timezone: baml.time.TimeZoneOffset | string) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + match (timezone : baml.time.TimeZoneOffset | string) : baml.time.ZonedDateTime + TimeZoneOffset => + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: instant._nanoseconds, _offset_ns: timezone._nanoseconds, _iana: null } : baml.time.ZonedDateTime + } + string => + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: instant._nanoseconds, _offset_ns: null, _iana: timezone } : baml.time.ZonedDateTime + } + } +} +function baml.time.ZonedDateTime.to_instant(self: baml.time.ZonedDateTime) -> baml.time.Instant throws never { + { : baml.time.Instant + Instant { _nanoseconds: self._nanoseconds } : baml.time.Instant + } +} +function baml.time.ZonedDateTime.from_components(timezone: baml.time.TimeZoneOffset | string, year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0, millisecond: int = 0, microsecond: int = 0, nanosecond: int = 0, disambiguation: baml.time.Disambiguation = "compatible") -> baml.time.ZonedDateTime throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.time.AmbiguousTimeError | baml.errors.Io { + { : baml.time.ZonedDateTime + PlainDateTime.from_components(year, month, day, hour = hour, minute = minute, second = second, millisecond = millisecond, microsecond = microsecond, nanosecond = nanosecond).to_zoned(timezone, disambiguation = disambiguation) : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime._to_string_impl(self: baml.time.ZonedDateTime) -> string throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : string + _format_zoned(self._nanoseconds, self.timezone_offset()._nanoseconds, self._iana) : string + } +} +function baml.time.ZonedDateTime.max(self: baml.time.ZonedDateTime, other: baml.time.ZonedDateTime) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + if (other._nanoseconds > self._nanoseconds : bool) : baml.time.ZonedDateTime + { : baml.time.ZonedDateTime + other : baml.time.ZonedDateTime + } + else + { : baml.time.ZonedDateTime + self : baml.time.ZonedDateTime + } + } +} +function baml.time.ZonedDateTime.min(self: baml.time.ZonedDateTime, other: baml.time.ZonedDateTime) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + if (other._nanoseconds < self._nanoseconds : bool) : baml.time.ZonedDateTime + { : baml.time.ZonedDateTime + other : baml.time.ZonedDateTime + } + else + { : baml.time.ZonedDateTime + self : baml.time.ZonedDateTime + } + } +} +function baml.time.ZonedDateTime.with_timezone(self: baml.time.ZonedDateTime, timezone: baml.time.TimeZoneOffset | string) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + ZonedDateTime.from_instant(self.to_instant(), timezone) : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime.timezone(self: baml.time.ZonedDateTime) -> baml.time.TimeZoneOffset | string throws never { + { : baml.time.TimeZoneOffset | string + match (self._iana : string | null) : baml.time.TimeZoneOffset | string + null => + TimeZoneOffset { _nanoseconds: self._offset_ns ?? 0 } : baml.time.TimeZoneOffset + iana => + iana ?? "" : string + } +} +function baml.time.ZonedDateTime.timezone_offset(self: baml.time.ZonedDateTime) -> baml.time.TimeZoneOffset throws baml.time.UnknownTimezoneError | baml.errors.Io { + { : baml.time.TimeZoneOffset + match (self._iana : string | null) : baml.time.TimeZoneOffset + null => + TimeZoneOffset { _nanoseconds: self._offset_ns ?? 0 } : baml.time.TimeZoneOffset + iana => + match (_tz_offset_at(iana ?? "", self._nanoseconds) : int | null) : baml.time.TimeZoneOffset + null => + throw UnknownTimezoneError { timezone: iana ?? "" } : never + offset => + TimeZoneOffset { _nanoseconds: offset ?? 0 } : baml.time.TimeZoneOffset + } +} +function baml.time.ZonedDateTime.to_plain(self: baml.time.ZonedDateTime) -> baml.time.PlainDateTime throws baml.time.UnknownTimezoneError | baml.errors.Io { + { : baml.time.PlainDateTime + PlainDateTime { _nanoseconds: self._nanoseconds + self.timezone_offset()._nanoseconds } : baml.time.PlainDateTime + } +} +function baml.time.ZonedDateTime.year(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().year() : int + } +} +function baml.time.ZonedDateTime.month(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().month() : int + } +} +function baml.time.ZonedDateTime.day(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().day() : int + } +} +function baml.time.ZonedDateTime.hour(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().hour() : int + } +} +function baml.time.ZonedDateTime.minute(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().minute() : int + } +} +function baml.time.ZonedDateTime.second(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().second() : int + } +} +function baml.time.ZonedDateTime.millisecond(self: baml.time.ZonedDateTime) -> int throws baml.errors.InvalidArgument | baml.time.UnknownTimezoneError | baml.errors.Io { + { : int + self.to_plain().millisecond() : int + } +} +function baml.time.ZonedDateTime.to_string(self: baml.time.ZonedDateTime) -> string throws never { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + _ => + { : never + root.sys.panic("ZonedDateTime.to_...") : never + } + } +} +function baml.time.ZonedDateTime.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.time.ZonedDateTime + match (j : baml.json.json) : baml.time.ZonedDateTime + string => + { : baml.time.ZonedDateTime + catch (ZonedDateTime.parse(j) : baml.time.ZonedDateTime) : baml.time.ZonedDateTime + catch (_) + root.errors.ParseError { message: message } => + { : never + throw baml.json.JsonDecodeError { message: message, path: "" } : baml.json.JsonDecodeError + } + } + _ => + { : never + throw baml.json.JsonDecodeError { message: "Expected RFC 3339...", path: "" } : baml.json.JsonDecodeError + } + } +} +function baml.time.ZonedDateTime.to_json(self: baml.time.ZonedDateTime) -> baml.json.json throws baml.json.JsonSerializationError { + { : string + catch (self._to_string_impl() : string) : string + catch (_) + root.errors.InvalidArgument { message: message } => + { : never + throw baml.json.JsonSerializationError { message: message, path: "" } : baml.json.JsonSerializationError + } + UnknownTimezoneError { timezone: timezone } => + { : never + throw baml.json.JsonSerializationError { message: "unknown timezone: " + timezone, path: "" } : baml.json.JsonSerializationError + } + root.errors.Io { message: message } => + { : never + throw baml.json.JsonSerializationError { message: message, path: "" } : baml.json.JsonSerializationError + } + } +} +function baml.time.ZonedDateTime.add(self: baml.time.ZonedDateTime, other: baml.time.Duration) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: self._nanoseconds + other._nanoseconds, _offset_ns: self._offset_ns, _iana: self._iana } : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime.sub(self: baml.time.ZonedDateTime, other: baml.time.Duration) -> baml.time.ZonedDateTime throws never { + { : baml.time.ZonedDateTime + ZonedDateTime { _nanoseconds: self._nanoseconds - other._nanoseconds, _offset_ns: self._offset_ns, _iana: self._iana } : baml.time.ZonedDateTime + } +} +function baml.time.ZonedDateTime.sub(self: baml.time.ZonedDateTime, other: baml.time.ZonedDateTime) -> baml.time.Duration throws never { + { : baml.time.Duration + Duration { _nanoseconds: self._nanoseconds - other._nanoseconds } : baml.time.Duration + } +} +class baml.time.ZonedDateTime$stream { + _nanoseconds: bigint | null + _offset_ns: int | null + _iana: string | null +} + +--- /baml/ns_toml/toml.baml --- +type baml.toml.Item = baml.toml.Table | baml.toml.Item[] | bool | int | float | string | baml.time.ZonedDateTime | baml.time.PlainDateTime | baml.time.PlainDate | baml.time.PlainTime +class baml.toml.Table { + items: map +} +function baml.toml.Table.to_json(self: baml.toml.Table) -> baml.json.json throws baml.json.JsonSerializationError { + { : baml.json.json + baml.json.from(self.items) : baml.json.json + } +} +function baml.toml.Table.from_json(j: baml.json.json) -> !error throws baml.json.JsonDecodeError { + { : baml.toml.Table + table_from_json(j) : baml.toml.Table + } +} +function baml.toml.table_from_json(j: baml.json.json) -> baml.toml.Table throws baml.json.JsonDecodeError { + { : baml.toml.Table + match (j : baml.json.json) : baml.toml.Table + map => + { : baml.toml.Table + let items: map = map { } : map + for key in j.keys() + { : void + items[key] = match (j[key]) { null => { 1 stmts }, item => item_from_json(item) } : baml.toml.Item + } + Table { items: items } : baml.toml.Table + } + _ => + throw baml.json.JsonDecodeError { message: "expected map", path: "" } : never + } +} +function baml.toml.item_to_json(item: baml.toml.Item) -> baml.json.json throws baml.json.JsonSerializationError { + { : bool | int | float | string | baml.json.json | baml.json.json[] + match (item : baml.toml.Item) : bool | int | float | string | baml.json.json | baml.json.json[] + bool | int | float | string => + item : bool | int | float | string + Table => + item.to_json() : baml.json.json + Item[] => + item.map(item_to_json) : baml.json.json[] + baml.time.ZonedDateTime => + item.to_json() : baml.json.json + baml.time.PlainDateTime => + item.to_json() : baml.json.json + baml.time.PlainDate => + item.to_json() : baml.json.json + baml.time.PlainTime => + item.to_json() : baml.json.json + } +} +function baml.toml.item_from_json(json: baml.json.json) -> baml.toml.Item throws baml.json.JsonDecodeError { + { : bool | int | float | string | baml.toml.Table | baml.toml.Item[] + match (json : baml.json.json) : bool | int | float | string | baml.toml.Table | baml.toml.Item[] + bool | int | float | string => + json : bool | int | float | string + null => + throw baml.json.JsonDecodeError { message: "TOML does not sup...", path: "" } : never + map => + Table.from_json(json) : baml.toml.Table + baml.json.json[] => + json.map(item_from_json) : baml.toml.Item[] + } +} +class baml.toml.TomlParseError { + message: string +} +type baml.toml.Item$stream = baml.toml.Table$stream | baml.toml.Item$stream[] | bool | int | float | string | baml.time.ZonedDateTime$stream | baml.time.PlainDateTime$stream | baml.time.PlainDate$stream | baml.time.PlainTime$stream +class baml.toml.Table$stream { + items: map +} +class baml.toml.TomlParseError$stream { + message: string | null +} + +--- /baml/ns_ws/ws.baml --- +class baml.ws.WsStream { + _handle: $rust_type +} +function baml.ws.connect(url: string, headers: map, timeout: baml.time.Duration = root.time.Duration.from_seconds(30)) -> baml.ws.WsStream throws baml.errors.Io | baml.errors.Timeout { + { : baml.ws.WsStream + _connect(url, headers, timeout.to_nanoseconds()) : baml.ws.WsStream + } +} +class baml.ws.WsStream$stream { + _handle: $rust_type +} + +--- /baml/ns_yaml/yaml.baml --- +class baml.yaml.YamlParseError { + message: string +} +function baml.yaml.deserialize(s: string) -> T throws baml.yaml.YamlParseError | baml.json.JsonDecodeError { + { : T + baml.json.from_json(parse(s)) : T + } +} +class baml.yaml.YamlParseError$stream { + message: string | null +} + +--- /baml/null.baml --- +class baml.Null { +} +class baml.Null$stream { +} + +--- /baml/string.baml --- +class baml.String { +} +function baml.String.from(value: T) -> string throws never { + { : string + root._to_string_shim(value) : string + } +} +class baml.String$stream { +} + +--- /baml/type_class.baml --- +class baml.TypeValue { +} +function baml.TypeValue.to_string(self: baml.TypeValue) -> string throws never { + { : string + self._to_string_impl() : string + } +} +class baml.TypeValue$stream { +} + +--- /baml/uint8array.baml --- +class baml.Uint8Array { +} +function baml.Uint8Array.to_string(self: baml.Uint8Array) -> string throws never { + { : string + self._to_string_impl() : string + } +} +class baml.Uint8Array$stream { +} diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index 286f72d33d2..87551a5d21a 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -2853,6 +2853,56 @@ function baml.id.new() -> string { function baml.id.set(id: string) -> string { } +function baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { + load_const b"" + call baml.deep_copy + store_var buf + + L0: + call baml.Int.max_value + store_var _4 + load_var2 1 4 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _3 + load_var _3 + store_var _5 + load_var _5 + narrow_bind uint8array, slot=5 + pop_jump_if_false L1 + jump L2 + + L1: + load_var buf + return + + L2: + load_var2 2 5 + call baml.Uint8Array.concat + store_var buf + jump L0 +} + +function baml.io.Read.read_to_string(self: baml.io.Read) -> string { + load_var self + load_type baml.io.Read + load_const "read_to_end" + virtual_call nargs=1 ntypeargs=0 + store_var buf + load_var buf + call baml.String.from_utf8 + jump L0 + load_var _ + throw_if_panic + load_const "invalid utf-8" + init_instance baml.errors.ParseError .message + throw + + L0: + return +} + function baml.io.eprint(s: string) -> null { } diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index c7303011b89..9b0560a8e3e 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -167,6 +167,8 @@ namespace baml.id: function new function set namespace baml.io: + type Read + type Write function eprint function eprintln function input diff --git a/baml_language/crates/baml_tests/src/type_spec/snapshots/baml_tests__type_spec__sweep__s15_sweep_baml_src.snap b/baml_language/crates/baml_tests/src/type_spec/snapshots/baml_tests__type_spec__sweep__s15_sweep_baml_src.snap index dfee729a950..9b4de883218 100644 --- a/baml_language/crates/baml_tests/src/type_spec/snapshots/baml_tests__type_spec__sweep__s15_sweep_baml_src.snap +++ b/baml_language/crates/baml_tests/src/type_spec/snapshots/baml_tests__type_spec__sweep__s15_sweep_baml_src.snap @@ -2,8 +2,6 @@ source: crates/baml_tests/src/type_spec/sweep.rs expression: report --- -files: 143 -typed nodes: 85350 hir_ty error-channel entries: 0 panics: 0 diff --git a/baml_language/crates/baml_tests/src/type_spec/sweep.rs b/baml_language/crates/baml_tests/src/type_spec/sweep.rs index 8bdb62ed29c..afcc634295f 100644 --- a/baml_language/crates/baml_tests/src/type_spec/sweep.rs +++ b/baml_language/crates/baml_tests/src/type_spec/sweep.rs @@ -7,7 +7,7 @@ use std::path::{Path, PathBuf}; -use super::harness::{NodeKind, collect_hir_ty_error_channel, collect_hir_ty_nodes}; +use super::harness::collect_hir_ty_error_channel; pub(crate) fn baml_src_dir() -> PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")).join("baml_src") @@ -61,17 +61,14 @@ fn s15_sweep_baml_src() { }) .collect(); - let mut typed_nodes = 0usize; let mut channel_entries: Vec = Vec::new(); let mut panics: Vec = Vec::new(); for (rel, content, file) in &loaded { - let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - let hir = collect_hir_ty_nodes(&db, *file, content); - let channel = collect_hir_ty_error_channel(&db, *file); - (hir, channel) + let channel = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + collect_hir_ty_error_channel(&db, *file) })); - let (hir, channel) = match outcome { + let channel = match channel { Ok(parts) => parts, Err(payload) => { let msg = payload @@ -84,10 +81,6 @@ fn s15_sweep_baml_src() { } }; - typed_nodes += hir - .iter() - .filter(|node| node.kind != NodeKind::BindingName) - .count(); for (&(start, end), rendered) in &channel.mismatches { for entry in rendered { channel_entries.push(format!( @@ -107,8 +100,6 @@ fn s15_sweep_baml_src() { let mut report = String::new(); use std::fmt::Write as _; - let _ = writeln!(report, "files: {}", loaded.len()); - let _ = writeln!(report, "typed nodes: {typed_nodes}"); let _ = writeln!( report, "hir_ty error-channel entries: {}", diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/bytecode_display.baml b/baml_language/crates/baml_tests/tests/bytecode_format/bytecode_display.baml deleted file mode 100644 index 66e3236407d..00000000000 --- a/baml_language/crates/baml_tests/tests/bytecode_format/bytecode_display.baml +++ /dev/null @@ -1,106 +0,0 @@ -// User scoring system — exercises most bytecode instructions. - -class User { - name string - age int - role Role - - function promote(self, bonus: int) -> Report { - self.age += 1; - let base = score(self, bonus); - let new_score = base.score + bonus; - Report { - score: new_score, - label: base.label, - breakdown: base.breakdown - } - } -} - -class Report { - score int - label string - breakdown map -} - -class ErrorInfo { - code int - message string -} - -enum Role { - Admin - Editor - Viewer - Guest -} - -type Input = User | ErrorInfo - -// Exercises: load_var, load_field, store_var, bin_op (+, *, %), cmp_op (>, <, >=), -// pop_jump_if_false, jump, unary_op (-), alloc_array, store_array_element, -// load_array_element, alloc_map, alloc_instance, store_field, return, -// discriminant, jump_table, type_tag, instanceof, copy, pop -function score(input: Input, threshold: int) -> Report { - let name = match (input) { - let u: User => u.name, - let e: ErrorInfo => e.message - }; - - let age = match (input) { - let u: User => u.age, - let e: ErrorInfo => -e.code - }; - - let role_mult = match (input) { - let u: User => match (u.role) { - Role.Admin => threshold, - Role.Editor => threshold, - Role.Viewer => threshold, - Role.Guest => threshold - }, - let e: ErrorInfo => threshold - }; - - let base = age * 2 + role_mult; - let capped = if (base > role_mult) { - role_mult - } else { - base - }; - let total = capped + role_mult; - - let suffix = match (total > threshold) { - true => " [HIGH]", - false => " [LOW]" - }; - let label = name + suffix; - - let scores = [base, capped, total]; - scores[0] = total; - let top = scores[0]; - - let breakdown = { "base": base, "role": role_mult }; - - Report { - score: top, - label: label, - breakdown: breakdown - } -} - -// Exercises: match on int literals (binary search), string concatenation, -// catch-all, load_const with various types -function http_status(code: int) -> string { - let prefix = "HTTP "; - let label = match (code) { - 200 => "OK", - 201 => "Created", - 204 => "No Content", - 400 => "Bad Request", - 404 => "Not Found", - 500 => "Internal Server Error", - _ => "Unknown" - }; - prefix + label -} diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/main.rs b/baml_language/crates/baml_tests/tests/bytecode_format/main.rs deleted file mode 100644 index f72ba300d65..00000000000 --- a/baml_language/crates/baml_tests/tests/bytecode_format/main.rs +++ /dev/null @@ -1,47 +0,0 @@ -//! Tests for bytecode display formats (textual, expanded, expanded unoptimized). - -use baml_tests::engine::{OptLevel, compile_source_with_opt}; -use bex_vm::debug::{BytecodeFormat, display_program}; -use bex_vm_types::{Function, Object}; - -fn compile_display_functions(source: &str, opt: OptLevel) -> Vec<(String, Function)> { - let program = compile_source_with_opt(source, opt); - let mut functions: Vec<(String, Function)> = program - .function_indices - .iter() - .filter(|(name, _)| !name.starts_with("baml.")) - .filter_map(|(name, idx)| match program.objects.get(*idx) { - Some(Object::Function(f)) => Some((name.clone(), (**f).clone())), - _ => None, - }) - .collect(); - functions.sort_by(|(a, _), (b, _)| a.cmp(b)); - functions -} - -#[test] -fn bytecode_display_formats() { - // Normalize CRLF → LF so line numbers are consistent across platforms. - let source = include_str!("bytecode_display.baml").replace("\r\n", "\n"); - - let optimized = compile_display_functions(&source, OptLevel::One); - let optimized_refs: Vec<(String, &Function)> = optimized - .iter() - .map(|(name, function)| (name.clone(), function)) - .collect(); - let textual = display_program(&optimized_refs, BytecodeFormat::Textual); - let expanded = display_program(&optimized_refs, BytecodeFormat::Expanded); - - let unoptimized = compile_display_functions(&source, OptLevel::Zero); - let unoptimized_refs: Vec<(String, &Function)> = unoptimized - .iter() - .map(|(name, function)| (name.clone(), function)) - .collect(); - let expanded_unoptimized = display_program(&unoptimized_refs, BytecodeFormat::Expanded); - - insta::with_settings!({omit_expression => true, snapshot_path => "snapshots"}, { - insta::assert_snapshot!("bytecode_display_textual", textual); - insta::assert_snapshot!("bytecode_display_expanded", expanded); - insta::assert_snapshot!("bytecode_display_expanded_unoptimized", expanded_unoptimized); - }); -} diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap deleted file mode 100644 index e7491434e43..00000000000 --- a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap +++ /dev/null @@ -1,33503 +0,0 @@ ---- -source: crates/baml_tests/tests/bytecode_format/main.rs ---- -function ai.Agent.Runner.run(self: ai.Agent<#0>, spec: ai.FunctionSpec<#0>) -> ai.RunResult<#0> { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - 6 load_var 5 - 7 make_cell - 8 store_var 5 - 9 load_var 20 - 10 make_cell - 11 store_var 20 - - 291 12 load_deref 1 - 13 load_field 1 (client) - 14 store_var_load_var 4 (_4) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +4 (to 21) - 18 load_deref 2 - 19 load_field 4 (default_client) - 20 store_var 4 (_4) - 21 load_var 4 (_4) - 22 store_var 3 (selected) - - 292 23 load_type 1 - 24 load_deref 2 - 25 call 906 ntypeargs=1 (ai.Journal.new) - 26 store_deref 5 - - 293 27 load_type 1 - 28 load_deref 1 - 29 load_deref 5 - 30 load_const 2 (0) - 31 call 956 ntypeargs=1 (ai.Agent._emit_from) - 32 store_var 6 (seen) - - 294 33 load_const 2 (0) - 34 store_var 7 (steps) - - 295 35 load_const 2 (0) - 36 load_const 2 (0) - 37 load_const 0 (null) - 38 load_const 0 (null) - 39 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 40 store_var 8 (total) - - 302 41 load_type 3 - 42 load_type 4 - 43 alloc_map 0 - 44 store_var 9 (fail_counts) - - 303 45 load_var 7 (steps) - 46 load_deref 1 - 47 load_field 0 (max_steps) - 48 cmp_int_op < - 49 pop_jump_if_false +2 (to 51) - 50 jump +4 (to 54) - - 373 51 load_var 7 (steps) - 52 init_instance 1 (ai.errors.StepBudgetExceeded .steps) - 53 throw - - 305 54 load_type 1 - 55 load_deref 1 - 56 load_var 3 (selected) - 57 load_deref 2 - 58 load_deref 5 - 59 load_var 8 (total) - 60 load_const 5 (2) - 61 call 955 ntypeargs=1 (ai.Agent._attempt_turn) - 62 store_var 10 (turn) - - 306 63 load_var 7 (steps) - 64 load_const 6 (1) - 65 add_int - 66 store_var 7 (steps) - - 307 67 load_type 1 - 68 load_deref 1 - 69 load_deref 5 - 70 load_var 6 (seen) - 71 call 956 ntypeargs=1 (ai.Agent._emit_from) - 72 store_var 6 (seen) - - 308 73 load_var 10 (turn) - 74 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 75 store_var 11 (calls) - - 309 76 load_var 11 (calls) - 77 container_len - 78 store_var 12 (_29) - 79 load_var 12 (_29) - 80 load_const 2 (0) - 81 cmp_int_op > - 82 pop_jump_if_false +2 (to 84) - 83 jump +78 (to 161) - - 344 84 load_var 10 (turn) - 85 call 925 ntypeargs=0 (ai.ModelTurn.terminal_text) - 86 store_var_load_var 33 (_98) - 87 load_const 0 (null) - 88 cmp_op == - 89 pop_jump_if_false +3 (to 92) - 90 load_const 7 ("") - 91 store_var 33 (_98) - 92 load_var 33 (_98) - 93 store_var 32 (candidate) - - 352 94 load_type 1 - 95 load_deref 1 - 96 load_var 10 (turn) - 97 call 952 ntypeargs=1 (ai.Agent._has_media_output) - 98 pop_jump_if_false +2 (to 100) - 99 jump +16 (to 115) - - 355 100 load_type 1 - 101 load_var 32 (candidate) - 102 call 445 ntypeargs=1 (baml.sap.parse) - 103 store_var 34 (value) - 104 jump +21 (to 125) - 105 load_var 36 (e) - 106 throw_if_panic - - 357 107 load_var 3 (selected) - 108 load_type 8 - 109 load_const 9 ("id") - 110 virtual_call nargs=1 ntypeargs=0 - 111 store_var 37 (_112) - 112 load_var2 37 32 - 113 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 114 throw - - 353 115 load_var 3 (selected) - 116 load_type 8 - 117 load_const 10 ("id") - 118 virtual_call nargs=1 ntypeargs=0 - 119 store_var 35 (_106) - 120 load_type 1 - 121 load_deref 1 - 122 load_var2 10 35 - 123 call 953 ntypeargs=1 (ai.Agent._media_value) - 124 store_var 34 (value) - - 361 125 load_type 1 - 126 load_var 34 (value) - 127 call 355 ntypeargs=1 (baml.json.to_json) - 128 jump +12 (to 140) - 129 load_var 38 (e) - 130 throw_if_panic - - 363 131 load_type 11 - 132 load_var 38 (e) - 133 call 138 ntypeargs=1 (baml.String.from) - 134 store_var 39 (_121) - 135 load_var2 38 39 - 136 load_type 3 - 137 alloc_array 1 - 138 init_instance 3 (baml.errors.UnknownError .data, .message) - 139 throw - - 367 140 call 351 ntypeargs=0 (baml.json.stringify) - 141 store_var 40 (_126) - - 366 142 load_deref 5 - - 367 143 load_var 40 (_126) - 144 init_instance 4 (ai.events.FinalProduced .value_json) - 145 load_type 12 - 146 alloc_array 1 - - 366 147 call 907 ntypeargs=0 (ai.Journal.append_all) - 148 pop 1 - - 369 149 load_type 1 - 150 load_deref 1 - 151 load_deref 5 - 152 load_var 6 (seen) - 153 call 956 ntypeargs=1 (ai.Agent._emit_from) - 154 store_var 6 (seen) - - 370 155 load_var 34 (value) - 156 load_deref 5 - 157 load_var 8 (total) - 158 load_type 1 - 159 init_instance 5 (ai.RunResult .value, .journal, .usage) - 160 return - - 310 161 load_deref 5 - 162 call 905 ntypeargs=0 (ai.Journal.entries) - 163 container_len - 164 store_var 13 (before) - - 312 165 load_type 13 - 166 load_type 14 - 167 load_type 15 - 168 load_var 11 (calls) - 169 load_type 1 - 170 load_var2 1 2 - 171 load_var 5 (j) - 172 make_closure 2266 captures=3 ntypeargs=1 - 173 call 16 ntypeargs=3 (baml.Array.map) - 174 store_var 14 (futures) - - 315 175 load_type 16 - 176 load_type 17 - 177 load_var 14 (futures) - 178 call 502 ntypeargs=2 (baml.future.all) - 179 await - 180 pop 1 - - 316 181 load_type 1 - 182 load_deref 1 - 183 load_deref 5 - 184 load_var 6 (seen) - 185 call 956 ntypeargs=1 (ai.Agent._emit_from) - 186 store_var 6 (seen) - - 320 187 load_deref 5 - 188 call 905 ntypeargs=0 (ai.Journal.entries) - 189 store_var 15 (entries) - - 321 190 load_var 13 (before) - 191 store_var 16 (i) - - 322 192 load_var 16 (i) - 193 store_var 17 (_48) - 194 load_var 15 (entries) - 195 container_len - 196 store_var 18 (_49) - 197 load_var2 17 18 - 198 cmp_int_op < - 199 pop_jump_if_false -154 (to 45) - - 323 200 load_type 12 - 201 load_var2 15 16 - 202 call 3 ntypeargs=1 (baml.Array.at) - 203 store_var 19 (_53) - 204 load_var 19 (_53) - 205 narrow_bind 18 19 - 206 pop_jump_if_false +57 (to 263) - 207 load_var 19 (_53) - 208 store_deref 20 - - 324 209 load_type 13 - 210 load_type 15 - 211 load_var 11 (calls) - 212 load_type 1 - 213 load_var 20 (f) - 214 make_closure 2267 captures=1 ntypeargs=1 - 215 call 19 ntypeargs=2 (baml.Array.find) - - 327 216 store_var 21 (_59) - 217 load_var 21 (_59) - 218 narrow_bind 19 21 - 219 pop_jump_if_false +44 (to 263) - 220 load_var 21 (_59) - 221 store_var 22 (known) - - 328 222 load_type 3 - 223 load_var 22 (known) - 224 load_field 1 (name) - 225 call 138 ntypeargs=1 (baml.String.from) - 226 store_var 24 (_63) - 227 load_type 3 - 228 load_deref 20 - 229 load_field 1 (message) - 230 call 138 ntypeargs=1 (baml.String.from) - 231 store_var 25 (_66) - 232 load_var 24 (_63) - 233 load_const 20 ("|") - 234 bin_op + - 235 load_var 25 (_66) - 236 bin_op + - 237 store_var 23 (key) - - 329 238 load_type 3 - 239 load_type 4 - 240 load_var2 9 23 - 241 call 38 ntypeargs=2 (baml.Map.get) - 242 store_var_load_var 27 (_71) - 243 load_const 0 (null) - 244 cmp_op == - 245 pop_jump_if_false +3 (to 248) - 246 load_const 2 (0) - 247 store_var 27 (_71) - 248 load_var 27 (_71) - 249 load_const 6 (1) - 250 add_int - 251 store_var 26 (n) - - 330 252 load_type 3 - 253 load_type 4 - 254 load_var2 9 23 - 255 load_var 26 (n) - 256 call 37 ntypeargs=2 (baml.Map.set) - 257 pop 1 - - 331 258 load_var 26 (n) - 259 load_const 21 (3) - 260 cmp_int_op >= - 261 pop_jump_if_false +2 (to 263) - 262 jump +6 (to 268) - - 341 263 load_var 16 (i) - 264 load_const 6 (1) - 265 add_int - 266 store_var 16 (i) - - 322 267 jump -75 (to 192) - - 333 268 load_var 22 (known) - 269 load_field 0 (id) - 270 store_var 28 (_85) - - 334 271 load_var 22 (known) - 272 load_field 1 (name) - 273 store_var 29 (_86) - - 335 274 load_type 4 - 275 load_var 26 (n) - 276 call 138 ntypeargs=1 (baml.String.from) - 277 store_var 30 (_90) - 278 load_type 3 - 279 load_deref 20 - 280 load_field 1 (message) - 281 call 138 ntypeargs=1 (baml.String.from) - 282 store_var 31 (_93) - - 332 283 load_var2 28 29 - - 335 284 load_const 22 ("the same tool call failed ") - 285 load_var 30 (_90) - 286 bin_op + - 287 load_const 23 (" times; stopping the run: ") - 288 bin_op + - 289 load_var 31 (_93) - 290 bin_op + - 291 load_const 0 (null) - 292 init_instance 6 (ai.errors.ToolFailedError .id, .name, .message, .cause) - 293 throw -} - -function ai.Agent._attempt_turn(self: ai.Agent<#0>, c: ai.Client, spec: ai.FunctionSpec<#0>, j: ai.Journal, total: ai.events.Usage, attempts_left: int) -> ai.ModelTurn { - 217 0 load_var 3 (spec) - 1 load_field 2 (prompt_template) - 2 store_var 8 (_9) - - 219 3 load_type 0 - 4 load_var 3 (spec) - 5 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 6 store_var 9 (_10) - - 220 7 load_type 0 - 8 load_var 3 (spec) - 9 call 915 ntypeargs=1 (ai.FunctionSpec.output_type) - 10 store_var 10 (_12) - - 215 11 load_var2 2 8 - - 216 12 load_var2 4 9 - 13 load_var 10 (_12) - 14 init_instance 0 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) - 15 load_type 1 - 16 load_const 2 ("invoke") - 17 virtual_call nargs=2 ntypeargs=0 - 18 store_var 7 (turn) - - 223 19 load_var 7 (turn) - 20 load_field 2 (usage) - 21 store_var 11 (_15) - 22 load_var 11 (_15) - 23 narrow_bind 3 11 - 24 pop_jump_if_false +57 (to 81) - 25 load_var 11 (_15) - 26 store_var 12 (u) - - 224 27 load_var 5 (total) - 28 copy 0 - 29 load_field 0 (input_tokens) - 30 load_var 12 (u) - 31 load_field 0 (input_tokens) - 32 bin_op + - 33 store_field 0 (input_tokens) - - 225 34 load_var 5 (total) - 35 copy 0 - 36 load_field 1 (output_tokens) - 37 load_var 12 (u) - 38 load_field 1 (output_tokens) - 39 bin_op + - 40 store_field 1 (output_tokens) - - 226 41 load_var 12 (u) - 42 load_field 2 (cached_input_tokens) - 43 store_var 13 (_20) - 44 load_var 13 (_20) - 45 narrow_bind 4 13 - 46 pop_jump_if_false +15 (to 61) - 47 load_var 13 (_20) - 48 store_var 14 (ci) - - 227 49 load_var 5 (total) - 50 load_field 2 (cached_input_tokens) - 51 store_var_load_var 15 (_23) - 52 load_const 5 (null) - 53 cmp_op == - 54 pop_jump_if_false +3 (to 57) - 55 load_const 4 (0) - 56 store_var 15 (_23) - 57 load_var2 5 15 - 58 load_var 14 (ci) - 59 bin_op + - 60 store_field 2 (cached_input_tokens) - - 229 61 load_var 12 (u) - 62 load_field 3 (reasoning_tokens) - 63 store_var 16 (_28) - 64 load_var 16 (_28) - 65 narrow_bind 4 16 - 66 pop_jump_if_false +15 (to 81) - 67 load_var 16 (_28) - 68 store_var 17 (rt) - - 230 69 load_var 5 (total) - 70 load_field 3 (reasoning_tokens) - 71 store_var_load_var 18 (_31) - 72 load_const 5 (null) - 73 cmp_op == - 74 pop_jump_if_false +3 (to 77) - 75 load_const 4 (0) - 76 store_var 18 (_31) - 77 load_var2 5 18 - 78 load_var 17 (rt) - 79 bin_op + - 80 store_field 3 (reasoning_tokens) - - 234 81 load_var 7 (turn) - 82 load_field 0 (content) - 83 store_var 20 (_37) - 84 load_var 2 (c) - 85 load_type 1 - 86 load_const 6 ("id") - 87 virtual_call nargs=1 ntypeargs=0 - 88 store_var 21 (_38) - 89 load_var2 20 21 - 90 init_instance 1 (ai.events.AssistantMessage .content, .client_id) - 91 load_type 7 - 92 alloc_array 1 - 93 store_var 19 (batch) - - 235 94 load_var 7 (turn) - 95 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 96 load_type 8 - 97 load_const 9 ("iter") - 98 virtual_call nargs=1 ntypeargs=0 - 99 store_var 22 (_40) - 100 load_var 22 (_40) - 101 load_type 10 - 102 load_const 11 ("next") - 103 virtual_call nargs=1 ntypeargs=0 - 104 store_var 23 (_41) - 105 load_var 23 (_41) - 106 is_type 12 - 107 pop_jump_if_false +2 (to 109) - 108 jump +14 (to 122) - 109 load_var 23 (_41) - 110 store_var 24 (u) - - 236 111 load_type 7 - 112 load_var2 19 24 - 113 load_field 0 (id) - 114 load_var 24 (u) - 115 load_field 1 (name) - 116 load_var 24 (u) - 117 load_field 2 (args) - 118 init_instance 2 (ai.events.ToolRequested .id, .name, .args) - 119 call 4 ntypeargs=1 (baml.Array.push) - 120 pop 1 - 121 jump -21 (to 100) - - 238 122 load_var 7 (turn) - 123 load_field 2 (usage) - 124 store_var 25 (_52) - 125 load_var 25 (_52) - 126 narrow_bind 3 25 - 127 pop_jump_if_false +5 (to 132) - - 239 128 load_type 7 - 129 load_var2 19 25 - 130 call 4 ntypeargs=1 (baml.Array.push) - 131 pop 1 - - 241 132 load_var 7 (turn) - 133 call 925 ntypeargs=0 (ai.ModelTurn.terminal_text) - 134 store_var_load_var 27 (_58) - 135 load_const 5 (null) - 136 cmp_op == - 137 pop_jump_if_false +3 (to 140) - 138 load_const 13 ("") - 139 store_var 27 (_58) - 140 load_var 27 (_58) - 141 store_var 26 (candidate) - - 242 142 load_var 7 (turn) - 143 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 144 container_len - 145 store_var 28 (_65) - 146 load_var 28 (_65) - 147 load_const 4 (0) - 148 cmp_int_op > - 149 jump_if_false +2 (to 151) - 150 jump +7 (to 157) - 151 pop 1 - - 243 152 load_var 7 (turn) - 153 load_field 1 (stop_reason) - 154 load_const 14 (ai.content.StopReason.MaxTokens) - 155 alloc_variant 774 (ai.content.StopReason) - 156 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 242 157 jump_if_false +2 (to 159) - 158 jump +7 (to 165) - 159 pop 1 - - 244 160 load_var 7 (turn) - 161 load_field 1 (stop_reason) - 162 load_const 15 (ai.content.StopReason.Refused) - 163 alloc_variant 774 (ai.content.StopReason) - 164 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 242 165 jump_if_false +2 (to 167) - 166 jump +6 (to 172) - 167 pop 1 - - 245 168 load_type 0 - 169 load_var2 1 7 - 170 load_var 26 (candidate) - 171 call 954 ntypeargs=1 (ai.Agent._parses) - - 246 172 pop_jump_if_false +2 (to 174) - 173 jump +34 (to 207) - - 259 174 load_var 6 (attempts_left) - 175 load_const 16 (1) - 176 cmp_int_op > - 177 pop_jump_if_false +2 (to 179) - 178 jump +12 (to 190) - - 268 179 load_var2 4 19 - 180 call 907 ntypeargs=0 (ai.Journal.append_all) - 181 pop 1 - - 269 182 load_var 2 (c) - 183 load_type 1 - 184 load_const 17 ("id") - 185 virtual_call nargs=1 ntypeargs=0 - 186 store_var 31 (_93) - 187 load_var2 31 26 - 188 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 189 throw - - 260 190 load_type 7 - 191 load_var 19 (batch) - - 261 192 load_const 18 ("The reply did not match the required schema. Answer again with only the corrected value.") - 193 init_instance 4 (ai.events.UserMessage .content) - - 260 194 call 4 ntypeargs=1 (baml.Array.push) - 195 pop 1 - - 265 196 load_var2 4 19 - 197 call 907 ntypeargs=0 (ai.Journal.append_all) - 198 pop 1 - - 266 199 load_type 0 - 200 load_var2 1 2 - 201 load_var2 3 4 - 202 load_var2 5 6 - 203 load_const 16 (1) - 204 sub_int - 205 call 955 ntypeargs=1 (ai.Agent._attempt_turn) - 206 jump +19 (to 225) - - 247 207 load_var2 4 19 - 208 call 907 ntypeargs=0 (ai.Journal.append_all) - 209 pop 1 - - 249 210 load_var 7 (turn) - 211 load_field 1 (stop_reason) - 212 discriminant - 213 load_const 14 (StopReason.MaxTokens) - 214 cmp_int_op == - 215 pop_jump_if_false +2 (to 217) - 216 jump +20 (to 236) - 217 load_var 7 (turn) - 218 load_field 1 (stop_reason) - 219 discriminant - 220 load_const 15 (StopReason.Refused) - 221 cmp_int_op == - 222 pop_jump_if_false +2 (to 224) - 223 jump +3 (to 226) - - 258 224 load_var 7 (turn) - 225 return - - 254 226 load_var 2 (c) - 227 load_type 1 - 228 load_const 19 ("id") - 229 virtual_call nargs=1 ntypeargs=0 - 230 store_var 30 (_81) - 231 load_var 30 (_81) - 232 load_const 20 ("the model declined to answer") - 233 load_const 5 (null) - 234 init_instance 5 (ai.errors.Refused .provider, .reason, .raw_body) - 235 throw - - 251 236 load_var 2 (c) - 237 load_type 1 - 238 load_const 21 ("id") - 239 virtual_call nargs=1 ntypeargs=0 - 240 store_var 29 (_78) - 241 load_var2 29 26 - 242 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) - 243 throw -} - -function ai.Agent._emit_from(self: ai.Agent<#0>, j: ai.Journal, seen: int) -> int { - 275 0 load_var 2 (j) - 1 call 905 ntypeargs=0 (ai.Journal.entries) - 2 store_var 4 (entries) - - 276 3 load_var 3 (seen) - 4 store_var 5 (i) - - 277 5 load_var 5 (i) - 6 store_var 6 (_7) - 7 load_var 4 (entries) - 8 container_len - 9 store_var 7 (_8) - 10 load_var2 6 7 - 11 cmp_int_op < - 12 pop_jump_if_false +2 (to 14) - 13 jump +4 (to 17) - - 283 14 load_var 4 (entries) - 15 container_len - 16 return - - 278 17 load_type 0 - 18 load_var2 4 5 - 19 call 3 ntypeargs=1 (baml.Array.at) - 20 store_var 8 (_12) - 21 load_var 8 (_12) - 22 narrow_bind 1 8 - 23 pop_jump_if_false +2 (to 25) - 24 jump +28 (to 52) - 25 load_var 8 (_12) - 26 narrow_bind 2 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +24 (to 52) - 29 load_var 8 (_12) - 30 narrow_bind 3 8 - 31 pop_jump_if_false +2 (to 33) - 32 jump +20 (to 52) - 33 load_var 8 (_12) - 34 narrow_bind 4 8 - 35 pop_jump_if_false +2 (to 37) - 36 jump +16 (to 52) - 37 load_var 8 (_12) - 38 narrow_bind 5 8 - 39 pop_jump_if_false +2 (to 41) - 40 jump +12 (to 52) - 41 load_var 8 (_12) - 42 narrow_bind 6 8 - 43 pop_jump_if_false +2 (to 45) - 44 jump +8 (to 52) - 45 load_var 8 (_12) - 46 narrow_bind 7 8 - 47 pop_jump_if_false +2 (to 49) - 48 jump +4 (to 52) - 49 load_var 8 (_12) - 50 narrow_bind 8 8 - 51 pop_jump_if_false +5 (to 56) - 52 load_var2 8 1 - - 279 53 load_field 3 (on_event) - 54 call_indirect - 55 pop 1 - - 281 56 load_var 5 (i) - 57 load_const 9 (1) - 58 add_int - 59 store_var 5 (i) - - 277 60 jump -55 (to 5) -} - -function ai.Agent._has_media_output(self: ai.Agent<#0>, turn: ai.ModelTurn) -> bool { - 104 0 load_type 0 - 1 call 985 ntypeargs=0 (ai.internal._media_shape) - 2 store_var 3 (shape) - - 105 3 load_var 3 (shape) - 4 load_const 1 (":") - 5 call 150 ntypeargs=0 (baml.String.split) - 6 store_var 6 (_8) - 7 load_type 2 - 8 load_var 6 (_8) - 9 load_const 3 (0) - 10 call 3 ntypeargs=1 (baml.Array.at) - 11 store_var_load_var 5 (_6) - 12 load_const 4 (null) - 13 cmp_op == - 14 pop_jump_if_false +3 (to 17) - 15 load_const 5 ("") - 16 store_var 5 (_6) - 17 load_var 5 (_6) - 18 store_var_load_var 4 (form) - - 106 19 load_const 6 ("") - 20 cmp_op == - 21 pop_jump_if_false +2 (to 23) - 22 jump +42 (to 64) - - 109 23 load_var 4 (form) - 24 load_const 7 ("mixed") - 25 cmp_op == - 26 jump_if_false +2 (to 28) - 27 jump +5 (to 32) - 28 pop 1 - 29 load_var 4 (form) - 30 load_const 8 ("mixedlist") - 31 cmp_op == - 32 pop_jump_if_false +2 (to 34) - 33 jump +23 (to 56) - - 112 34 load_var 3 (shape) - 35 load_const 9 (":") - 36 call 150 ntypeargs=0 (baml.String.split) - 37 store_var 10 (_24) - 38 load_type 2 - 39 load_var 10 (_24) - 40 load_const 10 (1) - 41 call 3 ntypeargs=1 (baml.Array.at) - 42 store_var_load_var 9 (_22) - 43 load_const 4 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 11 ("") - 47 store_var 9 (_22) - 48 load_var2 2 9 - 49 call 987 ntypeargs=0 (ai.internal._media_of_kind) - 50 container_len - 51 store_var 8 (_19) - 52 load_var 8 (_19) - 53 load_const 3 (0) - 54 cmp_int_op > - 55 jump +10 (to 65) - - 110 56 load_var 2 (turn) - 57 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - 58 container_len - 59 store_var 7 (_17) - 60 load_var 7 (_17) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 jump +2 (to 65) - - 107 64 load_const 12 (false) - 65 return -} - -function ai.Agent._media_value(self: ai.Agent<#0>, turn: ai.ModelTurn, provider: string) -> #0 { - 119 0 load_type 0 - 1 store_var 4 (t) - - 120 2 load_var 4 (t) - 3 call 985 ntypeargs=0 (ai.internal._media_shape) - 4 store_var 5 (shape) - - 121 5 load_var 5 (shape) - 6 load_const 1 (":") - 7 call 150 ntypeargs=0 (baml.String.split) - 8 store_var 8 (_10) - 9 load_type 2 - 10 load_var 8 (_10) - 11 load_const 3 (0) - 12 call 3 ntypeargs=1 (baml.Array.at) - 13 store_var_load_var 7 (_8) - 14 load_const 4 (null) - 15 cmp_op == - 16 pop_jump_if_false +3 (to 19) - 17 load_const 5 ("") - 18 store_var 7 (_8) - 19 load_var 7 (_8) - 20 store_var 6 (form) - - 122 21 load_var 5 (shape) - 22 load_const 6 (":") - 23 call 150 ntypeargs=0 (baml.String.split) - 24 store_var 11 (_16) - 25 load_type 2 - 26 load_var 11 (_16) - 27 load_const 7 (1) - 28 call 3 ntypeargs=1 (baml.Array.at) - 29 store_var_load_var 10 (_14) - 30 load_const 4 (null) - 31 cmp_op == - 32 pop_jump_if_false +3 (to 35) - 33 load_const 8 ("") - 34 store_var 10 (_14) - 35 load_var 10 (_14) - 36 store_var 9 (kind) - - 123 37 load_var 6 (form) - 38 load_const 9 ("mixedlist") - 39 cmp_op == - 40 pop_jump_if_false +2 (to 42) - 41 jump +201 (to 242) - 42 load_var 6 (form) - 43 load_const 10 ("mixed") - 44 cmp_op == - 45 pop_jump_if_false +2 (to 47) - 46 jump +129 (to 175) - 47 load_var 6 (form) - 48 load_const 11 ("list") - 49 cmp_op == - 50 pop_jump_if_false +2 (to 52) - 51 jump +116 (to 167) - - 152 52 load_var2 2 9 - 53 call 987 ntypeargs=0 (ai.internal._media_of_kind) - 54 store_var 22 (parts) - - 153 55 load_var2 2 9 - 56 load_var 3 (provider) - 57 call 991 ntypeargs=0 (ai.internal._media_reject_mixed) - 58 pop 1 - - 154 59 load_var 22 (parts) - 60 container_len - 61 store_var 23 (_57) - 62 load_var 23 (_57) - 63 load_const 7 (1) - 64 cmp_int_op != - 65 pop_jump_if_false +2 (to 67) - 66 jump +23 (to 89) - - 164 67 load_const 4 (null) - 68 store_var 35 (only) - - 165 69 load_var 22 (parts) - 70 load_type 12 - 71 load_const 13 ("iter") - 72 virtual_call nargs=1 ntypeargs=0 - 73 store_var 36 (_97) - 74 load_var 36 (_97) - 75 load_type 14 - 76 load_const 15 ("next") - 77 virtual_call nargs=1 ntypeargs=0 - 78 store_var 37 (_98) - 79 load_var 37 (_98) - 80 is_type 16 - 81 pop_jump_if_false +2 (to 83) - 82 jump +4 (to 86) - 83 load_var 37 (_98) - 84 store_var 35 (only) - 85 jump -11 (to 74) - - 168 86 load_var 35 (only) - 87 store_var 12 (payload) - - 123 88 jump +157 (to 245) - - 157 89 load_var 6 (form) - 90 load_const 17 ("one") - 91 cmp_op == - 92 pop_jump_if_false +2 (to 94) - 93 jump +42 (to 135) - - 160 94 load_type 2 - 95 load_var 9 (kind) - 96 call 138 ntypeargs=1 (baml.String.from) - 97 store_var 29 (_83) - 98 load_var 4 (t) - 99 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 100 store_var 31 (_87) - 101 load_type 2 - 102 load_var 31 (_87) - 103 call 138 ntypeargs=1 (baml.String.from) - 104 store_var 30 (_86) - 105 load_var 22 (parts) - 106 container_len - 107 store_var 33 (_90) - 108 load_type 18 - 109 load_var 33 (_90) - 110 call 138 ntypeargs=1 (baml.String.from) - 111 store_var 32 (_89) - 112 load_type 2 - 113 load_var 9 (kind) - 114 call 138 ntypeargs=1 (baml.String.from) - 115 store_var 34 (_92) - 116 load_const 19 ("Expected zero or one ") - 117 load_var 29 (_83) - 118 bin_op + - 119 load_const 20 (" output for ") - 120 bin_op + - 121 load_var 30 (_86) - 122 bin_op + - 123 load_const 21 (", got ") - 124 bin_op + - 125 load_var 32 (_89) - 126 bin_op + - 127 load_const 22 (". Use ") - 128 bin_op + - 129 load_var 34 (_92) - 130 bin_op + - 131 load_const 23 ("[] for multiple outputs.") - 132 bin_op + - 133 store_var 24 (_59) - - 157 134 jump +30 (to 164) - - 158 135 load_type 2 - 136 load_var 9 (kind) - 137 call 138 ntypeargs=1 (baml.String.from) - 138 store_var 25 (_67) - 139 load_var 22 (parts) - 140 container_len - 141 store_var 27 (_71) - 142 load_type 18 - 143 load_var 27 (_71) - 144 call 138 ntypeargs=1 (baml.String.from) - 145 store_var 26 (_70) - 146 load_type 2 - 147 load_var 9 (kind) - 148 call 138 ntypeargs=1 (baml.String.from) - 149 store_var 28 (_73) - 150 load_const 24 ("Expected exactly one ") - 151 load_var 25 (_67) - 152 bin_op + - 153 load_const 25 (" output, got ") - 154 bin_op + - 155 load_var 26 (_70) - 156 bin_op + - 157 load_const 26 (". Use ") - 158 bin_op + - 159 load_var 28 (_73) - 160 bin_op + - 161 load_const 27 ("[] for multiple outputs.") - 162 bin_op + - 163 store_var 24 (_59) - - 155 164 load_var2 3 24 - 165 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 166 throw - - 147 167 load_var2 2 9 - 168 load_var 3 (provider) - 169 call 991 ntypeargs=0 (ai.internal._media_reject_mixed) - 170 pop 1 - - 148 171 load_var2 2 9 - 172 call 987 ntypeargs=0 (ai.internal._media_of_kind) - - 149 173 store_var 12 (payload) - - 123 174 jump +71 (to 245) - - 129 175 load_var 2 (turn) - 176 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - 177 store_var 13 (items) - - 130 178 load_var 13 (items) - 179 container_len - 180 store_var 14 (_25) - 181 load_var 14 (_25) - 182 load_const 7 (1) - 183 cmp_int_op == - 184 pop_jump_if_false +2 (to 186) - 185 jump +35 (to 220) - - 136 186 load_var 13 (items) - 187 call 989 ntypeargs=0 (ai.internal._media_all_text) - 188 pop_jump_if_false +2 (to 190) - 189 jump +27 (to 216) - - 142 190 load_var 4 (t) - 191 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 192 store_var 19 (_42) - 193 load_type 2 - 194 load_var 19 (_42) - 195 call 138 ntypeargs=1 (baml.String.from) - 196 store_var 18 (_41) - 197 load_var 13 (items) - 198 container_len - 199 store_var 21 (_45) - 200 load_type 18 - 201 load_var 21 (_45) - 202 call 138 ntypeargs=1 (baml.String.from) - 203 store_var 20 (_44) - - 140 204 load_var 3 (provider) - - 142 205 load_const 28 ("Expected one text or image output for ") - 206 load_var 18 (_41) - 207 bin_op + - 208 load_const 29 (", got ") - 209 bin_op + - 210 load_var 20 (_44) - 211 bin_op + - 212 load_const 30 (" parts. Use (image | string)[] to preserve mixed outputs.") - 213 bin_op + - 214 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 215 throw - - 138 216 load_var 13 (items) - 217 call 990 ntypeargs=0 (ai.internal._media_join_text) - 218 store_var 12 (payload) - 219 jump +26 (to 245) - - 131 220 load_const 4 (null) - 221 store_var 15 (only) - - 132 222 load_var 13 (items) - 223 load_type 12 - 224 load_const 31 ("iter") - 225 virtual_call nargs=1 ntypeargs=0 - 226 store_var 16 (_28) - 227 load_var 16 (_28) - 228 load_type 14 - 229 load_const 32 ("next") - 230 virtual_call nargs=1 ntypeargs=0 - 231 store_var 17 (_29) - 232 load_var 17 (_29) - 233 is_type 16 - 234 pop_jump_if_false +2 (to 236) - 235 jump +4 (to 239) - 236 load_var 17 (_29) - 237 store_var 15 (only) - 238 jump -11 (to 227) - - 135 239 load_var 15 (only) - 240 store_var 12 (payload) - - 130 241 jump +4 (to 245) - - 125 242 load_var 2 (turn) - 243 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - - 126 244 store_var 12 (payload) - - 171 245 load_type 0 - 246 load_var 12 (payload) - 247 call 358 ntypeargs=1 (baml.json.from_json) - 248 jump +36 (to 284) - 249 load_var 38 (e) - 250 throw_if_panic - - 175 251 load_type 2 - 252 load_var 9 (kind) - 253 call 138 ntypeargs=1 (baml.String.from) - 254 store_var 39 (_111) - 255 load_var 4 (t) - 256 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 257 store_var 41 (_115) - 258 load_type 2 - 259 load_var 41 (_115) - 260 call 138 ntypeargs=1 (baml.String.from) - 261 store_var 40 (_114) - 262 load_type 33 - 263 load_var 38 (e) - 264 call 138 ntypeargs=1 (baml.String.from) - 265 store_var 43 (_118) - 266 load_type 2 - 267 load_var 43 (_118) - 268 call 138 ntypeargs=1 (baml.String.from) - 269 store_var 42 (_117) - - 173 270 load_var 3 (provider) - - 175 271 load_const 34 ("the ") - 272 load_var 39 (_111) - 273 bin_op + - 274 load_const 35 (" output did not fit ") - 275 bin_op + - 276 load_var 40 (_114) - 277 bin_op + - 278 load_const 36 (": ") - 279 bin_op + - 280 load_var 42 (_117) - 281 bin_op + - 282 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 283 throw - 284 return -} - -function ai.Agent._parses(self: ai.Agent<#0>, turn: ai.ModelTurn, candidate: string) -> bool { - 190 0 load_type 0 - 1 load_var2 1 2 - 2 call 952 ntypeargs=1 (ai.Agent._has_media_output) - 3 pop_jump_if_false +2 (to 5) - 4 jump +12 (to 16) - - 193 5 load_type 0 - 6 load_var 3 (candidate) - 7 call 445 ntypeargs=1 (baml.sap.parse) - 8 pop 1 - 9 jump +5 (to 14) - 10 load_var 4 (e) - 11 throw_if_panic - - 195 12 load_const 1 (false) - 13 jump +4 (to 17) - - 198 14 load_const 2 (true) - 15 jump +2 (to 17) - - 191 16 load_const 2 (true) - 17 return -} - -function ai.Agent._run_one_tool(self: ai.Agent<#0>, tb: ai.tools.Toolbox, call: ai.content.ToolUse, j: ai.Journal) -> void { - 56 0 load_var2 2 3 - 1 load_field 1 (name) - 2 call 923 ntypeargs=0 (ai.tools.Toolbox.get) - 3 store_var 5 (_7) - 4 load_var 5 (_7) - 5 narrow_bind 0 5 - 6 pop_jump_if_false +2 (to 8) - 7 jump +20 (to 27) - - 89 8 load_var 3 (call) - 9 load_field 0 (id) - 10 store_var 18 (_42) - - 90 11 load_type 1 - 12 load_var 3 (call) - 13 load_field 1 (name) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 19 (_44) - - 86 16 load_var2 4 18 - - 90 17 load_const 2 ("tool is not in the active toolbox: ") - 18 load_var 19 (_44) - 19 bin_op + - 20 init_instance 0 (ai.events.ToolFailed .id, .message) - 21 load_type 3 - 22 alloc_array 1 - - 86 23 call 907 ntypeargs=0 (ai.Journal.append_all) - 24 pop 1 - - 94 25 load_const 4 (null) - - 56 26 jump +81 (to 107) - 27 load_var 5 (_7) - 28 store_var 6 (t) - - 58 29 load_var2 6 3 - 30 load_field 2 (args) - 31 call 918 ntypeargs=0 (ai.tools.Tool.call) - 32 store_var 7 (outcome) - 33 jump +60 (to 93) - 34 load_var 8 (e) - 35 throw_if_panic - - 61 36 load_var 3 (call) - 37 load_field 0 (id) - 38 store_var 9 (_15) - 39 load_type 5 - 40 load_var 8 (e) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 10 (_16) - - 60 43 load_var2 4 9 - - 61 44 load_var 10 (_16) - 45 init_instance 1 (ai.events.ToolFailed .id, .message) - 46 load_type 3 - 47 alloc_array 1 - - 60 48 call 907 ntypeargs=0 (ai.Journal.append_all) - 49 pop 1 - - 64 50 load_var 6 (t) - 51 load_field 5 (on_error) - 52 store_var_load_var 11 (_20) - 53 load_const 4 (null) - 54 cmp_op == - 55 pop_jump_if_false +4 (to 59) - 56 load_var 1 (self) - 57 load_field 2 (tool_errors) - 58 store_var 11 (_20) - 59 load_var 11 (_20) - 60 load_const 6 (ai.tools.ErrorMode.Raise) - 61 alloc_variant 775 (ai.tools.ErrorMode) - 62 call 672 ntypeargs=0 (baml.ops.equals_equals) - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 76 65 load_const 4 (null) - 66 store_var 7 (outcome) - - 64 67 jump +26 (to 93) - - 65 68 load_var 8 (e) - 69 store_var 13 (_24) - 70 load_var 13 (_24) - 71 narrow_bind 7 13 - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 67 74 load_const 4 (null) - 75 store_var 12 (classified) - - 65 76 jump +3 (to 79) - 77 load_var 13 (_24) - 78 store_var 12 (classified) - - 70 79 load_var 3 (call) - 80 load_field 0 (id) - 81 store_var 14 (_27) - - 71 82 load_var 3 (call) - 83 load_field 1 (name) - 84 store_var 15 (_28) - - 72 85 load_type 5 - 86 load_var 8 (e) - 87 call 138 ntypeargs=1 (baml.String.from) - 88 store_var 16 (_29) - - 69 89 load_var2 14 15 - 90 load_var2 16 12 - - 73 91 init_instance 2 (ai.errors.ToolFailedError .id, .name, .message, .cause) - 92 throw - - 80 93 load_var 7 (outcome) - 94 store_var 17 (_32) - 95 load_var 17 (_32) - 96 narrow_bind 6 17 - 97 pop_jump_if_false +9 (to 106) - - 81 98 load_var2 4 3 - 99 load_field 0 (id) - - 80 100 load_var 17 (_32) - 101 init_instance 3 (ai.events.ToolCompleted .id, .output) - 102 load_type 3 - 103 alloc_array 1 - - 81 104 call 907 ntypeargs=0 (ai.Journal.append_all) - 105 pop 1 - - 83 106 load_const 4 (null) - 107 return -} - -function ai.Agent.new(max_steps: int, client: ai.Client | null, tool_errors: ai.tools.ErrorMode, on_event: ((ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced) -> null throws never) | null) -> ai.Agent<#0> { - 0 load_var 1 (max_steps) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 30 4 load_const 1 (12) - 5 store_var 1 (max_steps) - 6 load_var 2 (client) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 31 10 load_const 2 (null) - 11 store_var 2 (client) - 12 load_var 3 (tool_errors) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +4 (to 19) - - 32 16 load_const 3 (ai.tools.ErrorMode.Report) - 17 alloc_variant 775 (ai.tools.ErrorMode) - 18 store_var 3 (tool_errors) - 19 load_var 4 (on_event) - 20 load_const 0 () - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - - 33 23 load_const 2 (null) - 24 store_var 4 (on_event) - - 39 25 load_var 4 (on_event) - 26 store_var_load_var 5 (_10) - 27 load_const 2 (null) - 28 cmp_op == - 29 pop_jump_if_false +4 (to 33) - - 41 30 load_type 4 - 31 make_closure 2212 captures=0 ntypeargs=1 - 32 store_var 5 (_10) - - 35 33 load_var2 1 2 - 34 load_var2 3 5 - - 39 35 load_type 4 - 36 init_instance 0 (ai.Agent .max_steps, .client, .tool_errors, .on_event) - 37 return -} - -function ai.Context.output_format_with(self: ai.Context, prefix: string | null, or_splitter: string | null, enum_value_prefix: string | null, hoisted_class_prefix: string | null, always_hoist_enums: bool | null, quote_class_fields: bool | null, hoist_classes: string[] | null, map_style: string | null, render_null_as: string | null) -> string { -} - -function ai.FunctionSpec.arguments(self: ai.FunctionSpec<#0>) -> map { - 108 0 load_var 1 (self) - 1 load_field 1 (args) - 2 return -} - -function ai.FunctionSpec.name(self: ai.FunctionSpec<#0>) -> string { - 104 0 load_var 1 (self) - 1 load_field 0 (spec_name) - 2 return -} - -function ai.FunctionSpec.output_type(self: ai.FunctionSpec<#0>) -> type { - 112 0 load_type 0 - 1 store_var 2 (output_type) - - 113 2 load_var 2 (output_type) - 3 call 1006 ntypeargs=0 (ai.internal.validate_output_type) - 4 pop 1 - - 114 5 load_var 2 (output_type) - 6 return -} - -function ai.FunctionSpec.prompt(self: ai.FunctionSpec<#0>, output_format: string) -> ai.Prompt { - 0 load_var 2 (output_format) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 117 4 load_const 1 ("") - 5 store_var 2 (output_format) - - 118 6 load_var2 2 1 - 7 load_field 2 (prompt_template) - 8 call_indirect - 9 return -} - -function ai.FunctionSpec.tools(self: ai.FunctionSpec<#0>) -> ai.tools.Toolbox { - 122 0 load_var 1 (self) - 1 load_field 3 (toolbox) - 2 return -} - -function ai.Journal.append_all(self: ai.Journal, events: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[]) -> void { - 27 0 load_var 2 (events) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - - 28 14 load_type 5 - 15 load_var 1 (self) - 16 load_field 0 (log) - - 27 17 load_var 4 (_4) - - 28 18 call 4 ntypeargs=1 (baml.Array.push) - 19 pop 1 - 20 jump -15 (to 5) - - 26 21 load_const 6 (null) - 22 return -} - -function ai.Journal.entries(self: ai.Journal) -> (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[] { - 15 0 load_var 1 (self) - 1 load_field 0 (log) - 2 return -} - -function ai.Journal.new(spec: ai.FunctionSpec<#0>) -> ai.Journal { - 21 0 load_type 0 - 1 load_var 1 (spec) - 2 call 913 ntypeargs=1 (ai.FunctionSpec.name) - 3 store_var 2 (_4) - 4 load_type 0 - 5 load_var 1 (spec) - 6 call 914 ntypeargs=1 (ai.FunctionSpec.arguments) - 7 store_var 3 (_6) - 8 load_var2 2 3 - 9 init_instance 0 (ai.events.RunStarted .spec_name, .arguments) - 10 load_type 1 - 11 alloc_array 1 - 12 init_instance 1 (ai.Journal .log) - 13 return -} - -function ai.ModelTurn.media(self: ai.ModelTurn) -> (baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf)[] { - 34 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 35 3 load_var 1 (self) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +12 (to 29) - 18 load_var 4 (_5) - 19 store_var 5 (_9) - - 36 20 load_var 5 (_9) - 21 narrow_bind 6 5 - 22 pop_jump_if_false -13 (to 9) - - 37 23 load_type 0 - 24 load_var2 2 5 - - 36 25 load_field 0 (media) - - 37 26 call 4 ntypeargs=1 (baml.Array.push) - 27 pop 1 - 28 jump -19 (to 9) - - 40 29 load_var 2 (out) - 30 return -} - -function ai.ModelTurn.terminal_text(self: ai.ModelTurn) -> string | null { - 22 0 load_const 0 (null) - 1 store_var 2 (out) - - 23 2 load_var 1 (self) - 3 load_field 0 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_5) - 13 load_var 4 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +10 (to 26) - 17 load_var 4 (_5) - 18 store_var 5 (_9) - - 24 19 load_var 5 (_9) - 20 narrow_bind 6 5 - 21 pop_jump_if_false -13 (to 8) - 22 load_var 5 (_9) - 23 load_field 0 (text) - 24 store_var 2 (out) - 25 jump -17 (to 8) - - 28 26 load_var 2 (out) - 27 return -} - -function ai.ModelTurn.tool_uses(self: ai.ModelTurn) -> ai.content.ToolUse[] { - 45 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 46 3 load_var 1 (self) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +11 (to 28) - 18 load_var 4 (_5) - 19 store_var 5 (_9) - - 47 20 load_var 5 (_9) - 21 narrow_bind 6 5 - 22 pop_jump_if_false -13 (to 9) - - 48 23 load_type 0 - 24 load_var2 2 5 - 25 call 4 ntypeargs=1 (baml.Array.push) - 26 pop 1 - 27 jump -18 (to 9) - - 51 28 load_var 2 (out) - 29 return -} - -function ai.Prompt.baml.ToString.to_string(self: ai.Prompt) -> string { - 70 0 load_var 1 (self) - 1 call 909 ntypeargs=0 (ai.Prompt.text) - 2 return -} - -function ai.Prompt.messages(self: ai.Prompt) -> ai.PromptMessage[] { -} - -function ai.Prompt.text(self: ai.Prompt) -> string { -} - -function ai.clients.Backoff.delay_ms(self: ai.clients.Backoff, attempt: int, f: ai.errors.Failure) -> int { - 71 0 load_var 3 (f) - 1 store_var 4 (_5) - 2 load_var 4 (_5) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 73 6 load_const 1 (null) - - 71 7 jump +3 (to 10) - 8 load_var 4 (_5) - 9 load_field 1 (retry_after_ms) - - 75 10 store_var 5 (_7) - 11 load_var 5 (_7) - 12 narrow_bind 2 5 - 13 pop_jump_if_false +2 (to 15) - 14 jump +29 (to 43) - - 78 15 load_var 1 (self) - 16 load_field 0 (initial_ms) - 17 store_var 6 (d) - - 79 18 load_const 3 (1) - 19 store_var 7 (i) - - 80 20 load_var2 7 2 - 21 cmp_int_op < - 22 pop_jump_if_false +2 (to 24) - 23 jump +11 (to 34) - - 84 24 load_var2 6 1 - 25 load_field 2 (max_ms) - 26 cmp_int_op > - 27 pop_jump_if_false +2 (to 29) - 28 jump +3 (to 31) - - 87 29 load_var 6 (d) - - 84 30 jump +14 (to 44) - - 85 31 load_var 1 (self) - 32 load_field 2 (max_ms) - - 84 33 jump +11 (to 44) - - 81 34 load_var2 6 1 - 35 load_field 1 (multiplier) - 36 mul_int - 37 store_var 6 (d) - - 82 38 load_var 7 (i) - 39 load_const 3 (1) - 40 add_int - 41 store_var 7 (i) - - 80 42 jump -22 (to 20) - - 75 43 load_var 5 (_7) - 44 return -} - -function ai.clients.Backoff.new(initial_ms: int, multiplier: int, max_ms: int) -> ai.clients.Backoff { - 0 load_var 1 (initial_ms) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 64 4 load_const 1 (250) - 5 store_var 1 (initial_ms) - 6 load_var 2 (multiplier) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - 10 load_const 2 (2) - 11 store_var 2 (multiplier) - 12 load_var 3 (max_ms) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - 16 load_const 3 (10000) - 17 store_var 3 (max_ms) - - 65 18 load_var2 1 2 - 19 load_var 3 (max_ms) - 20 init_instance 0 (ai.clients.Backoff .initial_ms, .multiplier, .max_ms) - 21 return -} - -function ai.clients.Fallback._try(self: ai.clients.Fallback, input: ai.ModelTurnInput, index: int) -> ai.ModelTurn { - 195 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_var 3 (index) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 4 (_7) - 6 load_var 4 (_7) - 7 narrow_bind 0 4 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 212 10 load_const 1 ("Fallback needs at least one member") - 11 init_instance 0 (baml.errors.InvalidArgument .message) - 12 throw - - 195 13 load_var2 4 2 - 14 load_type 0 - 15 load_const 2 ("invoke") - 16 virtual_call nargs=2 ntypeargs=0 - 17 jump +43 (to 60) - - 197 18 load_var 5 (e) - 19 store_var 6 (_10) - 20 load_var 6 (_10) - 21 narrow_bind 3 6 - 22 pop_jump_if_false +2 (to 24) - 23 jump +5 (to 28) - 24 load_var 5 (e) - 25 throw_if_panic - - 208 26 load_var 5 (e) - 27 rethrow - - 197 28 load_var 6 (_10) - 29 store_var 7 (f) - - 200 30 load_var 3 (index) - 31 load_const 4 (1) - 32 add_int - 33 store_var 8 (_14) - 34 load_var 1 (self) - 35 load_field 0 (members) - 36 container_len - 37 store_var 9 (_15) - 38 load_var2 8 9 - 39 cmp_int_op < - 40 jump_if_false +11 (to 51) - 41 pop 1 - - 201 42 load_var 7 (f) - 43 load_type 3 - 44 load_const 5 ("retry_safety") - 45 virtual_call nargs=1 ntypeargs=0 - 46 store_var 10 (_17) - 47 load_var 10 (_17) - 48 load_const 6 (ai.errors.RetrySafety.Safe) - 49 alloc_variant 776 (ai.errors.RetrySafety) - 50 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 199 51 pop_jump_if_false +2 (to 53) - 52 jump +3 (to 55) - - 205 53 load_var 5 (e) - 54 rethrow - - 203 55 load_var2 1 2 - 56 load_var 3 (index) - 57 load_const 4 (1) - 58 add_int - 59 call 947 ntypeargs=0 (ai.clients.Fallback._try) - 60 return -} - -function ai.clients.Fallback.root.Client.id(self: ai.clients.Fallback) -> string { - 221 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_const 1 (0) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 3 (_5) - 6 load_var 3 (_5) - 7 narrow_bind 0 3 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 224 10 load_const 2 ("fallback") - 11 store_var 2 (_0) - - 221 12 jump +6 (to 18) - 13 load_var 3 (_5) - 14 load_type 0 - 15 load_const 3 ("id") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 2 (_0) - 18 load_var 2 (_0) - 19 return -} - -function ai.clients.Fallback.root.Client.invoke(self: ai.clients.Fallback, input: ai.ModelTurnInput) -> ai.ModelTurn { - 229 0 load_var2 1 2 - 1 load_const 0 (0) - 2 call 947 ntypeargs=0 (ai.clients.Fallback._try) - 3 jump +6 (to 9) - 4 load_var 3 (e) - 5 throw_if_panic - - 230 6 load_var 3 (e) - 7 call 968 ntypeargs=0 (ai.errors.normalize) - 8 throw - 9 return -} - -function ai.clients.Retry._attempt(self: ai.clients.Retry, input: ai.ModelTurnInput, remaining: int) -> ai.ModelTurn { - 114 0 load_var 1 (self) - 1 load_field 0 (inner) - 2 load_var 2 (input) - 3 load_type 0 - 4 load_const 1 ("invoke") - 5 virtual_call nargs=2 ntypeargs=0 - 6 jump +57 (to 63) - 7 load_var 4 (e) - 8 store_var 5 (_6) - 9 load_var 5 (_6) - 10 narrow_bind 2 5 - 11 pop_jump_if_false +2 (to 13) - 12 jump +5 (to 17) - 13 load_var 4 (e) - 14 throw_if_panic - - 133 15 load_var 4 (e) - 16 rethrow - - 114 17 load_var 5 (_6) - 18 store_var 6 (f) - - 118 19 load_var 3 (remaining) - 20 load_const 3 (1) - 21 cmp_int_op > - 22 jump_if_false +11 (to 33) - 23 pop 1 - - 119 24 load_var 6 (f) - 25 load_type 2 - 26 load_const 4 ("retry_safety") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 7 (_11) - 29 load_var 7 (_11) - 30 load_const 5 (ai.errors.RetrySafety.Safe) - 31 alloc_variant 776 (ai.errors.RetrySafety) - 32 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 118 33 jump_if_false +5 (to 38) - 34 pop 1 - - 120 35 load_var2 6 1 - 36 load_field 2 (retry_if) - 37 call_indirect - - 117 38 pop_jump_if_false +2 (to 40) - 39 jump +3 (to 42) - - 130 40 load_var 4 (e) - 41 rethrow - - 124 42 load_var 1 (self) - 43 load_field 3 (backoff) - - 122 44 load_var 1 (self) - 45 load_field 1 (max_attempts) - 46 load_var 3 (remaining) - 47 sub_int - 48 load_const 3 (1) - 49 add_int - - 124 50 load_var 6 (f) - 51 call 939 ntypeargs=0 (ai.clients.Backoff.delay_ms) - 52 call 521 ntypeargs=0 (baml.time.Duration.from_milliseconds) - - 123 53 sys_op 275 (baml.sys.sleep) - 54 pop 1 - 55 jump +3 (to 58) - 56 load_var 8 (se) - 57 throw_if_panic - - 128 58 load_var2 1 2 - 59 load_var 3 (remaining) - 60 load_const 3 (1) - 61 sub_int - 62 call 941 ntypeargs=0 (ai.clients.Retry._attempt) - 63 return -} - -function ai.clients.Retry.new(inner: ai.Client, max_attempts: int, retry_if: ((ai.errors.Failure) -> bool throws never) | null, backoff: ai.clients.Backoff | null) -> ai.clients.Retry { - 0 load_var 2 (max_attempts) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 101 4 load_const 1 (3) - 5 store_var 2 (max_attempts) - 6 load_var 3 (retry_if) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 102 10 load_const 2 (null) - 11 store_var 3 (retry_if) - 12 load_var 4 (backoff) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 103 16 load_const 2 (null) - 17 store_var 4 (backoff) - - 108 18 load_var 3 (retry_if) - 19 store_var_load_var 6 (_9) - 20 load_const 2 (null) - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - 23 load_const 3 (ai.clients.default_retry_judgment) - 24 store_var 6 (_9) - 25 load_var 6 (_9) - 26 store_var 5 (_8) - - 109 27 load_var 4 (backoff) - 28 store_var_load_var 7 (_12) - 29 load_const 2 (null) - 30 cmp_op == - 31 pop_jump_if_false +6 (to 37) - 32 load_const 0 () - 33 load_const 0 () - 34 load_const 0 () - 35 call 938 ntypeargs=0 (ai.clients.Backoff.new) - 36 store_var 7 (_12) - - 105 37 load_var2 1 2 - 38 load_var2 5 7 - - 109 39 init_instance 0 (ai.clients.Retry .inner, .max_attempts, .retry_if, .backoff) - 40 return -} - -function ai.clients.Retry.root.Client.id(self: ai.clients.Retry) -> string { - 139 0 load_var 1 (self) - 1 load_field 0 (inner) - 2 load_type 0 - 3 load_const 1 ("id") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function ai.clients.Retry.root.Client.invoke(self: ai.clients.Retry, input: ai.ModelTurnInput) -> ai.ModelTurn { - 143 0 load_var2 1 2 - 1 load_var 1 (self) - 2 load_field 1 (max_attempts) - 3 call 941 ntypeargs=0 (ai.clients.Retry._attempt) - 4 jump +6 (to 10) - 5 load_var 3 (e) - 6 throw_if_panic - - 144 7 load_var 3 (e) - 8 call 968 ntypeargs=0 (ai.errors.normalize) - 9 throw - 10 return -} - -function ai.clients.RoundRobin.new(members: ai.Client[]) -> ai.clients.RoundRobin { - 159 0 load_var 1 (members) - 1 container_len - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 load_const 0 (0) - 5 cmp_int_op == - 6 pop_jump_if_false +2 (to 8) - 7 jump +5 (to 12) - - 162 8 load_var 1 (members) - 9 load_const 0 (0) - 10 init_instance 0 (ai.clients.RoundRobin .members, .counter) - 11 return - - 160 12 load_const 1 ("RoundRobin needs at least one member") - 13 init_instance 1 (baml.errors.InvalidArgument .message) - 14 throw -} - -function ai.clients.RoundRobin.root.Client.id(self: ai.clients.RoundRobin) -> string { - 167 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_const 1 (0) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 3 (_5) - 6 load_var 3 (_5) - 7 narrow_bind 0 3 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 170 10 load_const 2 ("round-robin") - 11 store_var 2 (_0) - - 167 12 jump +6 (to 18) - 13 load_var 3 (_5) - 14 load_type 0 - 15 load_const 3 ("id") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 2 (_0) - 18 load_var 2 (_0) - 19 return -} - -function ai.clients.RoundRobin.root.Client.invoke(self: ai.clients.RoundRobin, input: ai.ModelTurnInput) -> ai.ModelTurn { - 176 0 load_var 1 (self) - 1 load_field 1 (counter) - 2 store_var 5 (_5) - 3 load_var 1 (self) - 4 load_field 0 (members) - 5 container_len - 6 store_var 6 (_6) - - 177 7 load_var2 1 1 - 8 load_field 1 (counter) - 9 load_const 0 (1) - 10 bin_op + - 11 store_field 1 (counter) - - 178 12 load_type 1 - 13 load_var 1 (self) - 14 load_field 0 (members) - - 176 15 load_var2 5 6 - 16 mod_int - - 178 17 call 3 ntypeargs=1 (baml.Array.at) - 18 store_var 7 (_13) - 19 load_var 7 (_13) - 20 narrow_bind 1 7 - 21 pop_jump_if_false +2 (to 23) - 22 jump +4 (to 26) - - 181 23 load_const 2 ("RoundRobin needs at least one member") - 24 init_instance 0 (baml.errors.InvalidArgument .message) - 25 throw - - 178 26 load_var2 7 2 - 27 load_type 1 - 28 load_const 3 ("invoke") - 29 virtual_call nargs=2 ntypeargs=0 - 30 store_var 3 (_0) - 31 jump +6 (to 37) - - 175 32 load_var 4 (e) - 33 throw_if_panic - - 185 34 load_var 4 (e) - 35 call 968 ntypeargs=0 (ai.errors.normalize) - 36 throw - 37 load_var 3 (_0) - 38 return -} - -function ai.clients.default_retry_judgment(f: ai.errors.Failure) -> bool { - 51 0 load_var 1 (f) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +19 (to 24) - 6 load_var 1 (f) - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 narrow_bind 1 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +11 (to 22) - 12 load_var 1 (f) - 13 store_var 4 (_4) - 14 load_var 4 (_4) - 15 narrow_bind 2 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +3 (to 20) - - 55 18 load_const 3 (true) - - 51 19 jump +6 (to 25) - - 54 20 load_const 4 (false) - - 51 21 jump +4 (to 25) - - 53 22 load_const 4 (false) - - 51 23 jump +2 (to 25) - - 52 24 load_const 4 (false) - 25 return -} - -function ai.clients.resolve(selector: ai.Client | string | baml.env.Ref) -> ai.Client { - 30 0 load_var 1 (selector) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +55 (to 60) - 6 load_var 1 (selector) - 7 store_var 3 (_5) - 8 load_var 3 (_5) - 9 narrow_bind 1 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 44 12 load_var 1 (selector) - - 30 13 jump +49 (to 62) - 14 load_var 3 (_5) - 15 store_var 4 (named) - - 33 16 load_var 4 (named) - 17 call 228 ntypeargs=0 (baml.env.Ref.get) - 18 store_var 5 (_8) - 19 load_var 5 (_8) - 20 narrow_bind 0 5 - 21 pop_jump_if_false +2 (to 23) - 22 jump +35 (to 57) - - 39 23 load_type 2 - 24 load_var 4 (named) - 25 load_field 0 (name) - 26 call 138 ntypeargs=1 (baml.String.from) - 27 store_var 6 (_18) - 28 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 29 store_var 8 (_22) - 30 load_type 2 - 31 load_var 8 (_22) - 32 call 138 ntypeargs=1 (baml.String.from) - 33 store_var 7 (_21) - 34 load_type 2 - 35 load_var 4 (named) - 36 load_field 0 (name) - 37 call 138 ntypeargs=1 (baml.String.from) - 38 store_var 9 (_24) - - 36 39 load_const 3 ("ai.clients") - 40 load_const 4 (null) - - 39 41 load_const 5 ("client selector env.") - 42 load_var 6 (_18) - 43 bin_op + - 44 load_const 6 (" is not set: point it at a \"provider/model\" string (valid prefixes are ") - 45 bin_op + - 46 load_var 7 (_21) - 47 bin_op + - 48 load_const 7 ("), or give the client: position a value with a fallback — env.") - 49 bin_op + - 50 load_var 9 (_24) - 51 bin_op + - 52 load_const 8 (".get() ?? \"openai/gpt-4o-mini\"") - 53 bin_op + - 54 load_const 4 (null) - 55 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 56 throw - - 33 57 load_var 5 (_8) - - 34 58 call 1002 ntypeargs=0 (ai.internal._from_shorthand) - 59 jump +3 (to 62) - - 30 60 load_var 2 (_2) - - 31 61 call 1002 ntypeargs=0 (ai.internal._from_shorthand) - 62 return -} - -function ai.content.Media.kind(self: ai.content.Media) -> string { - 37 0 load_var 1 (self) - 1 load_field 0 (media) - 2 store_var 2 (_2) - 3 load_var 2 (_2) - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +19 (to 27) - 9 load_var 2 (_2) - 10 store_var 4 (_4) - 11 load_var 4 (_4) - 12 narrow_bind 1 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +11 (to 25) - 15 load_var 2 (_2) - 16 store_var 5 (_5) - 17 load_var 5 (_5) - 18 narrow_bind 2 5 - 19 pop_jump_if_false +2 (to 21) - 20 jump +3 (to 23) - - 41 21 load_const 3 ("pdf") - - 37 22 jump +6 (to 28) - - 40 23 load_const 4 ("video") - - 37 24 jump +4 (to 28) - - 39 25 load_const 5 ("audio") - - 37 26 jump +2 (to 28) - - 38 27 load_const 6 ("image") - 28 return -} - -function ai.content.Media.new(value: image | audio | video | pdf, provider_id: string | null, revised_prompt: string | null) -> ai.content.Media { - 0 load_var 2 (provider_id) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 54 4 load_const 1 (null) - 5 store_var 2 (provider_id) - 6 load_var 3 (revised_prompt) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 55 10 load_const 1 (null) - 11 store_var 3 (revised_prompt) - - 57 12 load_type 2 - 13 load_var 1 (value) - 14 call 355 ntypeargs=1 (baml.json.to_json) - 15 store_var 4 (envelope) - 16 jump +16 (to 32) - 17 load_var 5 (e) - 18 throw_if_panic - - 59 19 load_type 3 - 20 load_var 5 (e) - 21 call 138 ntypeargs=1 (baml.String.from) - 22 store_var 7 (_12) - 23 load_type 4 - 24 load_var 7 (_12) - 25 call 138 ntypeargs=1 (baml.String.from) - 26 store_var 6 (_11) - 27 load_const 5 ("media output could not be encoded: ") - 28 load_var 6 (_11) - 29 bin_op + - 30 init_instance 0 (baml.errors.InvalidArgument .message) - 31 throw - - 62 32 load_type 6 - 33 load_var 4 (envelope) - 34 call 358 ntypeargs=1 (baml.json.from_json) - 35 store_var 8 (part) - 36 jump +16 (to 52) - 37 load_var 9 (e) - 38 throw_if_panic - - 64 39 load_type 7 - 40 load_var 9 (e) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 11 (_22) - 43 load_type 4 - 44 load_var 11 (_22) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 10 (_21) - 47 load_const 8 ("media output could not be decoded: ") - 48 load_var 10 (_21) - 49 bin_op + - 50 init_instance 1 (baml.errors.InvalidArgument .message) - 51 throw - - 67 52 load_var2 8 2 - 53 load_var 3 (revised_prompt) - 54 init_instance 2 (ai.content.Media .media, .provider_id, .revised_prompt) - 55 return -} - -function ai.errors.InvalidRequest.Failure.retry_safety(self: ai.errors.InvalidRequest) -> ai.errors.RetrySafety { - 54 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.NetworkFailure.Failure.retry_safety(self: ai.errors.NetworkFailure) -> ai.errors.RetrySafety { - 42 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.ParseFailed.Failure.retry_safety(self: ai.errors.ParseFailed) -> ai.errors.RetrySafety { - 75 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.RateLimited.Failure.retry_safety(self: ai.errors.RateLimited) -> ai.errors.RetrySafety { - 31 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.Refused.Failure.retry_safety(self: ai.errors.Refused) -> ai.errors.RetrySafety { - 65 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.StepBudgetExceeded.Failure.retry_safety(self: ai.errors.StepBudgetExceeded) -> ai.errors.RetrySafety { - 88 0 load_const 0 (ai.errors.RetrySafety.Unsafe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.StreamingUnsupported.Failure.retry_safety(self: ai.errors.StreamingUnsupported) -> ai.errors.RetrySafety { - 117 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.ToolFailedError.Failure.retry_safety(self: ai.errors.ToolFailedError) -> ai.errors.RetrySafety { - 104 0 load_const 0 (ai.errors.RetrySafety.Unsafe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 return -} - -function ai.errors.classify_http(provider: string, status_code: int, body: string, headers: map | null) -> ai.errors.Failure { - 0 load_var 4 (headers) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 133 4 load_const 1 (null) - 5 store_var 4 (headers) - - 135 6 load_var 2 (status_code) - 7 load_const 2 (429) - 8 cmp_int_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +34 (to 44) - - 141 11 load_var 2 (status_code) - 12 load_const 3 (408) - 13 cmp_int_op == - 14 jump_if_false +2 (to 16) - 15 jump +5 (to 20) - 16 pop 1 - 17 load_var 2 (status_code) - 18 load_const 4 (500) - 19 cmp_int_op >= - 20 pop_jump_if_false +2 (to 22) - 21 jump +12 (to 33) - - 147 22 load_type 5 - 23 load_var 2 (status_code) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 store_var 7 (_14) - - 144 26 load_var2 1 2 - - 147 27 load_const 6 ("http ") - 28 load_var 7 (_14) - 29 bin_op + - 30 load_var 3 (body) - 31 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 141 32 jump +18 (to 50) - - 142 33 load_type 5 - 34 load_var 2 (status_code) - 35 call 138 ntypeargs=1 (baml.String.from) - 36 store_var 6 (_11) - 37 load_var 1 (provider) - 38 load_const 7 ("http ") - 39 load_var 6 (_11) - 40 bin_op + - 41 load_var 3 (body) - 42 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 141 43 jump +7 (to 50) - - 138 44 load_var 4 (headers) - 45 call 1005 ntypeargs=0 (ai.internal._retry_after_ms) - 46 store_var 5 (_7) - - 136 47 load_var2 1 5 - 48 load_var 3 (body) - 49 init_instance 2 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 50 return -} - -function ai.errors.normalize(error: unknown) -> ai.errors.Failure | baml.errors.UnknownError { - 18 0 load_var 1 (error) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +18 (to 23) - 6 load_var 1 (error) - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 narrow_bind 1 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +10 (to 21) - - 21 12 load_type 2 - 13 load_var 1 (error) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 4 (_7) - 16 load_var2 1 4 - 17 load_type 3 - 18 alloc_array 1 - 19 init_instance 0 (baml.errors.UnknownError .data, .message) - - 18 20 jump +4 (to 24) - 21 load_var 3 (_4) - 22 jump +2 (to 24) - 23 load_var 2 (_2) - 24 return -} - -function ai.internal._aws_resolve_region(region: string | null, profile: string | null) -> string | null { -} - -function ai.internal._aws_sign_request(request: baml.http.Request, service: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null) -> baml.http.Request { -} - -function ai.internal._configured(value: string) -> string | null { - 7 0 load_var 1 (value) - 1 call 144 ntypeargs=0 (baml.String.trim) - 2 load_const 0 ("") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 10 6 load_var 1 (value) - - 7 7 jump +2 (to 9) - - 8 8 load_const 1 (null) - 9 return -} - -function ai.internal._flush_orphaned_calls(out: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[], pending: string[]) -> void { - 127 0 load_var 2 (pending) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - - 128 14 load_type 5 - 15 load_var2 1 4 - - 127 16 load_const 6 ("No result provided") - 17 init_instance 0 (ai.events.ToolFailed .id, .message) - - 128 18 call 4 ntypeargs=1 (baml.Array.push) - 19 pop 1 - 20 jump -15 (to 5) - - 130 21 load_type 7 - 22 load_var 2 (pending) - 23 call 28 ntypeargs=1 (baml.Array.clear) - 24 pop 1 - - 126 25 load_const 8 (null) - 26 return -} - -function ai.internal._from_shorthand(shorthand: string) -> ai.Client { - 34 0 load_var 1 (shorthand) - 1 load_const 0 ("/") - 2 call 155 ntypeargs=0 (baml.String.index_of) - - 35 3 store_var 2 (_3) - 4 load_var 2 (_3) - 5 narrow_bind 1 2 - 6 pop_jump_if_false +2 (to 8) - 7 jump +23 (to 30) - - 67 8 load_type 2 - 9 load_var 1 (shorthand) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 14 (_62) - 12 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 13 store_var 16 (_65) - 14 load_type 2 - 15 load_var 16 (_65) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 15 (_64) - - 64 18 load_const 3 ("ai.clients") - 19 load_const 4 (null) - - 67 20 load_const 5 ("client \"") - 21 load_var 14 (_62) - 22 bin_op + - 23 load_const 6 ("\" is not a \"provider/model\" string (no \"/\"); valid prefixes are ") - 24 bin_op + - 25 load_var 15 (_64) - 26 bin_op + - 27 load_const 4 (null) - 28 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 29 throw - - 35 30 load_var 2 (_3) - 31 store_var 3 (index) - - 36 32 load_var 1 (shorthand) - 33 load_const 1 (0) - 34 load_var 3 (index) - 35 call 153 ntypeargs=0 (baml.String.slice) - 36 store_var 4 (prefix) - - 37 37 load_var 3 (index) - 38 load_const 7 (1) - 39 add_int - 40 store_var 6 (_8) - 41 load_var 1 (shorthand) - 42 call 139 ntypeargs=0 (baml.String.length) - 43 store_var 7 (_10) - 44 load_var2 1 6 - 45 load_var 7 (_10) - 46 call 153 ntypeargs=0 (baml.String.slice) - 47 store_var 5 (model) - - 38 48 load_var 4 (prefix) - 49 load_const 8 ("openai") - 50 cmp_op == - 51 pop_jump_if_false +2 (to 53) - 52 jump +223 (to 275) - 53 load_var 4 (prefix) - 54 load_const 9 ("openai-chat") - 55 cmp_op == - 56 pop_jump_if_false +2 (to 58) - 57 jump +204 (to 261) - 58 load_var 4 (prefix) - 59 load_const 10 ("openai-images") - 60 cmp_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +181 (to 243) - 63 load_var 4 (prefix) - 64 load_const 11 ("azure") - 65 cmp_op == - 66 pop_jump_if_false +2 (to 68) - 67 jump +159 (to 226) - 68 load_var 4 (prefix) - 69 load_const 12 ("ollama") - 70 cmp_op == - 71 pop_jump_if_false +2 (to 73) - 72 jump +141 (to 213) - 73 load_var 4 (prefix) - 74 load_const 13 ("openrouter") - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +123 (to 200) - 78 load_var 4 (prefix) - 79 load_const 14 ("anthropic") - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +103 (to 185) - 83 load_var 4 (prefix) - 84 load_const 15 ("google") - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +83 (to 170) - 88 load_var 4 (prefix) - 89 load_const 16 ("vertex") - 90 cmp_op == - 91 pop_jump_if_false +2 (to 93) - 92 jump +59 (to 151) - 93 load_var 4 (prefix) - 94 load_const 17 ("bedrock") - 95 cmp_op == - 96 pop_jump_if_false +2 (to 98) - 97 jump +34 (to 131) - 98 load_var 4 (prefix) - 99 load_const 18 ("ai-gateway-images") - 100 cmp_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +17 (to 119) - 103 load_var 4 (prefix) - 104 load_const 19 ("claude-code") - 105 cmp_op == - 106 pop_jump_if_false +2 (to 108) - 107 jump +3 (to 110) - - 51 108 load_const 4 (null) - - 38 109 jump +181 (to 290) - - 50 110 load_var 5 (model) - 111 load_const 20 () - 112 load_const 20 () - 113 load_const 20 () - 114 load_const 20 () - 115 load_const 20 () - 116 load_const 20 () - 117 call 1351 ntypeargs=0 (claude_code.ClaudeCodeClient.new) - 118 jump +172 (to 290) - - 49 119 load_var 5 (model) - 120 load_const 20 () - 121 load_const 20 () - 122 load_const 20 () - 123 load_const 20 () - 124 load_const 20 () - 125 load_const 20 () - 126 load_const 20 () - 127 load_const 20 () - 128 load_const 20 () - 129 call 1330 ntypeargs=0 (vercel.AiGatewayImageClient.new) - 130 jump +160 (to 290) - - 48 131 load_var 5 (model) - 132 load_const 20 () - 133 load_const 20 () - 134 load_const 20 () - 135 load_const 20 () - 136 load_const 20 () - 137 load_const 20 () - 138 load_const 20 () - 139 load_const 20 () - 140 load_const 20 () - 141 load_const 20 () - 142 load_const 20 () - 143 load_const 20 () - 144 load_const 20 () - 145 load_const 20 () - 146 load_const 20 () - 147 load_const 20 () - 148 load_const 20 () - 149 call 1271 ntypeargs=0 (aws.BedrockClient.new) - 150 jump +140 (to 290) - - 47 151 load_var 5 (model) - 152 load_const 20 () - 153 load_const 20 () - 154 load_const 20 () - 155 load_const 20 () - 156 load_const 20 () - 157 load_const 20 () - 158 load_const 20 () - 159 load_const 20 () - 160 load_const 20 () - 161 load_const 20 () - 162 load_const 20 () - 163 load_const 20 () - 164 load_const 20 () - 165 load_const 20 () - 166 load_const 20 () - 167 load_const 20 () - 168 call 1207 ntypeargs=0 (google.VertexClient.new) - 169 jump +121 (to 290) - - 46 170 load_var 5 (model) - 171 load_const 20 () - 172 load_const 20 () - 173 load_const 20 () - 174 load_const 20 () - 175 load_const 20 () - 176 load_const 20 () - 177 load_const 20 () - 178 load_const 20 () - 179 load_const 20 () - 180 load_const 20 () - 181 load_const 20 () - 182 load_const 20 () - 183 call 1201 ntypeargs=0 (google.GoogleClient.new) - 184 jump +106 (to 290) - - 45 185 load_var 5 (model) - 186 load_const 20 () - 187 load_const 20 () - 188 load_const 20 () - 189 load_const 20 () - 190 load_const 20 () - 191 load_const 20 () - 192 load_const 20 () - 193 load_const 20 () - 194 load_const 20 () - 195 load_const 20 () - 196 load_const 20 () - 197 load_const 20 () - 198 call 1162 ntypeargs=0 (anthropic.AnthropicClient.new) - 199 jump +91 (to 290) - - 44 200 load_var 5 (model) - 201 load_const 20 () - 202 load_const 20 () - 203 load_const 20 () - 204 load_const 20 () - 205 load_const 20 () - 206 load_const 20 () - 207 load_const 20 () - 208 load_const 20 () - 209 load_const 20 () - 210 load_const 20 () - 211 call 1084 ntypeargs=0 (openai.OpenRouterClient.new) - 212 jump +78 (to 290) - - 43 213 load_var 5 (model) - 214 load_const 20 () - 215 load_const 20 () - 216 load_const 20 () - 217 load_const 20 () - 218 load_const 20 () - 219 load_const 20 () - 220 load_const 20 () - 221 load_const 20 () - 222 load_const 20 () - 223 load_const 20 () - 224 call 1076 ntypeargs=0 (openai.OllamaClient.new) - 225 jump +65 (to 290) - - 42 226 load_var 5 (model) - 227 load_const 20 () - 228 load_const 20 () - 229 load_const 20 () - 230 load_const 20 () - 231 load_const 20 () - 232 load_const 20 () - 233 load_const 20 () - 234 load_const 20 () - 235 load_const 20 () - 236 load_const 20 () - 237 load_const 20 () - 238 load_const 20 () - 239 load_const 20 () - 240 load_const 20 () - 241 call 1067 ntypeargs=0 (openai.AzureClient.new) - 242 jump +48 (to 290) - - 41 243 load_var 5 (model) - 244 load_const 20 () - 245 load_const 20 () - 246 load_const 20 () - 247 load_const 20 () - 248 load_const 20 () - 249 load_const 20 () - 250 load_const 20 () - 251 load_const 20 () - 252 load_const 20 () - 253 load_const 20 () - 254 load_const 20 () - 255 load_const 20 () - 256 load_const 20 () - 257 load_const 20 () - 258 load_const 20 () - 259 call 1092 ntypeargs=0 (openai.ImageClient.new) - 260 jump +30 (to 290) - - 40 261 load_var 5 (model) - 262 load_const 20 () - 263 load_const 20 () - 264 load_const 20 () - 265 load_const 20 () - 266 load_const 20 () - 267 load_const 20 () - 268 load_const 20 () - 269 load_const 20 () - 270 load_const 20 () - 271 load_const 20 () - 272 load_const 20 () - 273 call 1051 ntypeargs=0 (openai.ChatClient.new) - 274 jump +16 (to 290) - - 39 275 load_var 5 (model) - 276 load_const 20 () - 277 load_const 20 () - 278 load_const 20 () - 279 load_const 20 () - 280 load_const 20 () - 281 load_const 20 () - 282 load_const 20 () - 283 load_const 20 () - 284 load_const 20 () - 285 load_const 20 () - 286 load_const 20 () - 287 load_const 20 () - 288 load_const 20 () - 289 call 1011 ntypeargs=0 (openai.ResponsesClient.new) - - 53 290 store_var 8 (_36) - 291 load_var 8 (_36) - 292 narrow_bind 21 8 - 293 pop_jump_if_false +2 (to 295) - 294 jump +41 (to 335) - - 59 295 load_type 2 - 296 load_var 4 (prefix) - 297 call 138 ntypeargs=1 (baml.String.from) - 298 store_var 9 (_47) - 299 load_type 2 - 300 load_var 1 (shorthand) - 301 call 138 ntypeargs=1 (baml.String.from) - 302 store_var 10 (_50) - 303 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 304 store_var 12 (_53) - 305 load_type 2 - 306 load_var 12 (_53) - 307 call 138 ntypeargs=1 (baml.String.from) - 308 store_var 11 (_52) - 309 load_type 2 - 310 load_var 5 (model) - 311 call 138 ntypeargs=1 (baml.String.from) - 312 store_var 13 (_55) - - 56 313 load_const 22 ("ai.clients") - 314 load_const 4 (null) - - 59 315 load_const 23 ("no builtin provider for prefix \"") - 316 load_var 9 (_47) - 317 bin_op + - 318 load_const 24 ("\" in client \"") - 319 bin_op + - 320 load_var 10 (_50) - 321 bin_op + - 322 load_const 25 ("\"; valid prefixes are ") - 323 bin_op + - 324 load_var 11 (_52) - 325 bin_op + - 326 load_const 26 (" (for any other OpenAI-compatible endpoint, build openai.GenericClient.new(base_url = ..., model = \"") - 327 bin_op + - 328 load_var 13 (_55) - 329 bin_op + - 330 load_const 27 ("\"))") - 331 bin_op + - 332 load_const 4 (null) - 333 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 334 throw - - 53 335 load_var 8 (_36) - 336 return -} - -function ai.internal._gcp_access_token(credentials_json: string | null, scope: string) -> string { -} - -function ai.internal._gcp_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._gcp_quota_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._header(headers: map, lower: string, canonical: string) -> string | null { - 8 0 load_type 0 - 1 load_type 0 - 2 load_var2 1 2 - 3 call 38 ntypeargs=2 (baml.Map.get) - 4 store_var_load_var 4 (_4) - 5 load_const 1 (null) - 6 cmp_op == - 7 pop_jump_if_false +6 (to 13) - 8 load_type 0 - 9 load_type 0 - 10 load_var2 1 3 - 11 call 38 ntypeargs=2 (baml.Map.get) - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 return -} - -function ai.internal._int_header(headers: map, lower: string, canonical: string) -> int | null { - 14 0 load_var2 1 2 - 1 load_var 3 (canonical) - 2 call 1003 ntypeargs=0 (ai.internal._header) - 3 store_var 4 (_5) - 4 load_var 4 (_5) - 5 narrow_bind 0 4 - 6 pop_jump_if_false +25 (to 31) - 7 load_var 4 (_5) - - 15 8 call 144 ntypeargs=0 (baml.String.trim) - 9 call 81 ntypeargs=0 (baml.Int.parse) - 10 store_var 5 (parsed) - 11 jump +9 (to 20) - 12 load_var 6 (e) - 13 is_type 1 - 14 pop_jump_if_false +2 (to 16) - 15 jump +3 (to 18) - 16 load_var 6 (e) - 17 rethrow - - 16 18 load_const 2 (null) - 19 store_var 5 (parsed) - - 18 20 load_var 5 (parsed) - 21 store_var 7 (_11) - 22 load_var 7 (_11) - 23 narrow_bind 3 7 - 24 pop_jump_if_false +7 (to 31) - 25 load_var 7 (_11) - 26 store_var_load_var 8 (value) - - 19 27 load_const 3 (0) - 28 cmp_int_op >= - 29 pop_jump_if_false +2 (to 31) - 30 jump +3 (to 33) - - 24 31 load_const 2 (null) - 32 jump +2 (to 34) - - 20 33 load_var 8 (value) - 34 return -} - -function ai.internal._media_all_text(items: baml.json.json[]) -> bool { - 103 0 load_var 1 (items) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 2 (_2) - 5 load_var 2 (_2) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_3) - 10 load_var 3 (_3) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +12 (to 25) - 14 load_var 3 (_3) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +3 (to 20) - - 104 18 load_const 6 (false) - 19 jump +2 (to 21) - 20 load_const 7 (true) - 21 unary_op ! - 22 pop_jump_if_false -17 (to 5) - - 105 23 load_const 6 (false) - 24 jump +2 (to 26) - - 108 25 load_const 7 (true) - 26 return -} - -function ai.internal._media_envelope(m: ai.content.Media) -> baml.json.json { - 57 0 load_type 0 - 1 load_var 1 (m) - 2 load_field 0 (media) - 3 call 355 ntypeargs=1 (baml.json.to_json) - 4 jump +12 (to 16) - 5 load_var 2 (e) - 6 throw_if_panic - - 59 7 load_type 1 - 8 load_var 2 (e) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 store_var 3 (_8) - 11 load_var2 2 3 - 12 load_type 2 - 13 alloc_array 1 - 14 init_instance 0 (baml.errors.UnknownError .data, .message) - 15 throw - 16 return -} - -function ai.internal._media_join_text(items: baml.json.json[]) -> baml.json.json { - 112 0 load_const 0 ("") - 1 store_var 2 (out) - - 113 2 load_var 1 (items) - 3 load_type 1 - 4 load_const 2 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_3) - 7 load_var 3 (_3) - 8 load_type 3 - 9 load_const 4 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_4) - 12 load_var 4 (_4) - 13 is_type 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +10 (to 25) - 16 load_var 4 (_4) - 17 store_var 5 (_8) - - 114 18 load_var 5 (_8) - 19 narrow_bind 6 5 - 20 pop_jump_if_false -13 (to 7) - - 115 21 load_var2 2 5 - - 114 22 bin_op + - 23 store_var 2 (out) - 24 jump -17 (to 7) - - 118 25 load_var 2 (out) - 26 return -} - -function ai.internal._media_mime_type(explicit: string | null, source_value: string, kind: string) -> string { - 6 0 load_var 1 (explicit) - 1 store_var 4 (_4) - 2 load_var 4 (_4) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +159 (to 164) - - 9 6 load_var 2 (source_value) - 7 call 142 ntypeargs=0 (baml.String.to_lower_case) - 8 store_var 5 (source) - - 10 9 load_var 5 (source) - 10 load_const 1 (".jpg") - 11 call 147 ntypeargs=0 (baml.String.includes) - 12 jump_if_false +2 (to 14) - 13 jump +5 (to 18) - 14 pop 1 - 15 load_var 5 (source) - 16 load_const 2 (".jpeg") - 17 call 147 ntypeargs=0 (baml.String.includes) - 18 pop_jump_if_false +2 (to 20) - 19 jump +143 (to 162) - - 12 20 load_var 5 (source) - 21 load_const 3 (".png") - 22 call 147 ntypeargs=0 (baml.String.includes) - 23 pop_jump_if_false +2 (to 25) - 24 jump +136 (to 160) - - 14 25 load_var 5 (source) - 26 load_const 4 (".webp") - 27 call 147 ntypeargs=0 (baml.String.includes) - 28 pop_jump_if_false +2 (to 30) - 29 jump +129 (to 158) - - 16 30 load_var 5 (source) - 31 load_const 5 (".gif") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 pop_jump_if_false +2 (to 35) - 34 jump +122 (to 156) - - 18 35 load_var 5 (source) - 36 load_const 6 (".svg") - 37 call 147 ntypeargs=0 (baml.String.includes) - 38 pop_jump_if_false +2 (to 40) - 39 jump +115 (to 154) - - 20 40 load_var 5 (source) - 41 load_const 7 (".wav") - 42 call 147 ntypeargs=0 (baml.String.includes) - 43 pop_jump_if_false +2 (to 45) - 44 jump +108 (to 152) - - 22 45 load_var 5 (source) - 46 load_const 8 (".mp3") - 47 call 147 ntypeargs=0 (baml.String.includes) - 48 pop_jump_if_false +2 (to 50) - 49 jump +101 (to 150) - - 24 50 load_var 5 (source) - 51 load_const 9 (".flac") - 52 call 147 ntypeargs=0 (baml.String.includes) - 53 pop_jump_if_false +2 (to 55) - 54 jump +94 (to 148) - - 26 55 load_var 5 (source) - 56 load_const 10 (".ogg") - 57 call 147 ntypeargs=0 (baml.String.includes) - 58 pop_jump_if_false +2 (to 60) - 59 jump +87 (to 146) - - 28 60 load_var 5 (source) - 61 load_const 11 (".webm") - 62 call 147 ntypeargs=0 (baml.String.includes) - 63 pop_jump_if_false +2 (to 65) - 64 jump +73 (to 137) - - 34 65 load_var 5 (source) - 66 load_const 12 (".mov") - 67 call 147 ntypeargs=0 (baml.String.includes) - 68 pop_jump_if_false +2 (to 70) - 69 jump +66 (to 135) - - 36 70 load_var 5 (source) - 71 load_const 13 (".mp4") - 72 call 147 ntypeargs=0 (baml.String.includes) - 73 pop_jump_if_false +2 (to 75) - 74 jump +52 (to 126) - - 44 75 load_var 5 (source) - 76 load_const 14 (".avi") - 77 call 147 ntypeargs=0 (baml.String.includes) - 78 pop_jump_if_false +2 (to 80) - 79 jump +45 (to 124) - - 46 80 load_var 5 (source) - 81 load_const 15 (".mkv") - 82 call 147 ntypeargs=0 (baml.String.includes) - 83 pop_jump_if_false +2 (to 85) - 84 jump +31 (to 115) - - 52 85 load_var 5 (source) - 86 load_const 16 (".pdf") - 87 call 147 ntypeargs=0 (baml.String.includes) - 88 pop_jump_if_false +2 (to 90) - 89 jump +24 (to 113) - - 54 90 load_var 3 (kind) - 91 load_const 17 ("audio") - 92 cmp_op == - 93 pop_jump_if_false +2 (to 95) - 94 jump +17 (to 111) - - 56 95 load_var 3 (kind) - 96 load_const 18 ("video") - 97 cmp_op == - 98 pop_jump_if_false +2 (to 100) - 99 jump +10 (to 109) - - 58 100 load_var 3 (kind) - 101 load_const 19 ("pdf") - 102 cmp_op == - 103 pop_jump_if_false +2 (to 105) - 104 jump +3 (to 107) - - 61 105 load_const 20 ("image/png") - - 58 106 jump +59 (to 165) - - 59 107 load_const 21 ("application/pdf") - - 58 108 jump +57 (to 165) - - 57 109 load_const 22 ("video/mp4") - - 56 110 jump +55 (to 165) - - 55 111 load_const 23 ("audio/mpeg") - - 54 112 jump +53 (to 165) - - 53 113 load_const 24 ("application/pdf") - - 52 114 jump +51 (to 165) - - 47 115 load_var 3 (kind) - 116 load_const 25 ("audio") - 117 cmp_op == - 118 pop_jump_if_false +2 (to 120) - 119 jump +3 (to 122) - - 50 120 load_const 26 ("video/x-matroska") - - 47 121 jump +44 (to 165) - - 48 122 load_const 27 ("audio/x-matroska") - - 47 123 jump +42 (to 165) - - 45 124 load_const 28 ("video/x-msvideo") - - 44 125 jump +40 (to 165) - - 39 126 load_var 3 (kind) - 127 load_const 29 ("audio") - 128 cmp_op == - 129 pop_jump_if_false +2 (to 131) - 130 jump +3 (to 133) - - 42 131 load_const 30 ("video/mp4") - - 39 132 jump +33 (to 165) - - 40 133 load_const 31 ("audio/mp4") - - 39 134 jump +31 (to 165) - - 35 135 load_const 32 ("video/quicktime") - - 34 136 jump +29 (to 165) - - 29 137 load_var 3 (kind) - 138 load_const 33 ("audio") - 139 cmp_op == - 140 pop_jump_if_false +2 (to 142) - 141 jump +3 (to 144) - - 32 142 load_const 34 ("video/webm") - - 29 143 jump +22 (to 165) - - 30 144 load_const 35 ("audio/webm") - - 29 145 jump +20 (to 165) - - 27 146 load_const 36 ("audio/ogg") - - 26 147 jump +18 (to 165) - - 25 148 load_const 37 ("audio/flac") - - 24 149 jump +16 (to 165) - - 23 150 load_const 38 ("audio/mpeg") - - 22 151 jump +14 (to 165) - - 21 152 load_const 39 ("audio/wav") - - 20 153 jump +12 (to 165) - - 19 154 load_const 40 ("image/svg+xml") - - 18 155 jump +10 (to 165) - - 17 156 load_const 41 ("image/gif") - - 16 157 jump +8 (to 165) - - 15 158 load_const 42 ("image/webp") - - 14 159 jump +6 (to 165) - - 13 160 load_const 43 ("image/png") - - 12 161 jump +4 (to 165) - - 11 162 load_const 44 ("image/jpeg") - - 10 163 jump +2 (to 165) - - 6 164 load_var 4 (_4) - 165 return -} - -function ai.internal._media_mixed_parts(turn: ai.ModelTurn) -> baml.json.json[] { - 81 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (items) - - 82 3 load_var 1 (turn) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +42 (to 59) - 18 load_var 4 (_5) - 19 store_var 5 (b) - - 83 20 load_var 5 (b) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +21 (to 46) - 26 load_var 5 (b) - 27 store_var 8 (_17) - 28 load_var 8 (_17) - 29 narrow_bind 7 8 - 30 pop_jump_if_false -21 (to 9) - 31 load_var 8 (_17) - 32 store_var 9 (m) - - 91 33 load_var 9 (m) - 34 call 903 ntypeargs=0 (ai.content.Media.kind) - 35 load_const 8 ("image") - 36 cmp_op == - 37 pop_jump_if_false -28 (to 9) - - 92 38 load_var 9 (m) - 39 call 986 ntypeargs=0 (ai.internal._media_envelope) - 40 store_var 10 (_22) - 41 load_type 0 - 42 load_var2 2 10 - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -36 (to 9) - - 83 46 load_var 6 (_9) - 47 store_var_load_var 7 (t) - - 85 48 load_field 0 (text) - 49 call 144 ntypeargs=0 (baml.String.trim) - 50 load_const 9 ("") - 51 cmp_op != - 52 pop_jump_if_false -43 (to 9) - - 86 53 load_type 0 - 54 load_var2 2 7 - 55 load_field 0 (text) - 56 call 4 ntypeargs=1 (baml.Array.push) - 57 pop 1 - 58 jump -49 (to 9) - - 99 59 load_var 2 (items) - 60 return -} - -function ai.internal._media_of_kind(turn: ai.ModelTurn, kind: string) -> baml.json.json[] { - 66 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 67 3 load_var 1 (turn) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +21 (to 38) - 18 load_var 5 (_6) - 19 store_var 6 (_10) - - 68 20 load_var 6 (_10) - 21 narrow_bind 6 6 - 22 pop_jump_if_false -13 (to 9) - 23 load_var 6 (_10) - 24 store_var 7 (m) - - 69 25 load_var 7 (m) - 26 call 903 ntypeargs=0 (ai.content.Media.kind) - 27 load_var 2 (kind) - 28 cmp_op == - 29 pop_jump_if_false -20 (to 9) - - 70 30 load_var 7 (m) - 31 call 986 ntypeargs=0 (ai.internal._media_envelope) - 32 store_var 8 (_15) - 33 load_type 0 - 34 load_var2 3 8 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -28 (to 9) - - 74 38 load_var 3 (out) - 39 return -} - -function ai.internal._media_reject_mixed(turn: ai.ModelTurn, kind: string, provider: string) -> void { - 124 0 load_const 0 (0) - 1 store_var 4 (unexpected) - - 125 2 load_var 1 (turn) - 3 load_field 0 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 5 (_6) - 8 load_var 5 (_6) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 6 (_7) - 13 load_var 6 (_7) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +35 (to 51) - 17 load_var 6 (_7) - 18 store_var 7 (b) - - 126 19 load_var 7 (b) - 20 store_var 8 (_11) - 21 load_var 8 (_11) - 22 narrow_bind 6 8 - 23 pop_jump_if_false +2 (to 25) - 24 jump +17 (to 41) - 25 load_var 7 (b) - 26 store_var 9 (_16) - 27 load_var 9 (_16) - 28 narrow_bind 7 9 - 29 pop_jump_if_false -21 (to 8) - 30 load_var 9 (_16) - 31 load_field 0 (text) - - 134 32 call 144 ntypeargs=0 (baml.String.trim) - 33 load_const 8 ("") - 34 cmp_op != - 35 pop_jump_if_false -27 (to 8) - - 135 36 load_var 4 (unexpected) - 37 load_const 9 (1) - 38 add_int - 39 store_var 4 (unexpected) - - 134 40 jump -32 (to 8) - - 126 41 load_var 8 (_11) - - 128 42 call 903 ntypeargs=0 (ai.content.Media.kind) - 43 load_var 2 (kind) - 44 cmp_op != - 45 pop_jump_if_false -37 (to 8) - - 129 46 load_var 4 (unexpected) - 47 load_const 9 (1) - 48 add_int - 49 store_var 4 (unexpected) - - 128 50 jump -42 (to 8) - - 142 51 load_var 4 (unexpected) - 52 load_const 0 (0) - 53 cmp_int_op > - 54 pop_jump_if_false +2 (to 56) - 55 jump +3 (to 58) - 56 load_const 10 (null) - 57 return - - 145 58 load_type 11 - 59 load_var 2 (kind) - 60 call 138 ntypeargs=1 (baml.String.from) - 61 store_var 10 (_31) - 62 load_type 12 - 63 load_var 4 (unexpected) - 64 call 138 ntypeargs=1 (baml.String.from) - 65 store_var 11 (_33) - 66 load_type 11 - 67 load_var 2 (kind) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 12 (_36) - - 143 70 load_var 3 (provider) - - 145 71 load_const 13 ("Expected only ") - 72 load_var 10 (_31) - 73 bin_op + - 74 load_const 14 (" output parts, got ") - 75 bin_op + - 76 load_var 11 (_33) - 77 bin_op + - 78 load_const 15 (" non-") - 79 bin_op + - 80 load_var 12 (_36) - 81 bin_op + - 82 load_const 16 (" part(s). Use a text/image union return type to preserve mixed outputs.") - 83 bin_op + - 84 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 85 throw -} - -function ai.internal._media_shape(t: type) -> string { - 18 0 load_var 1 (t) - 1 load_type 0 - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 pop_jump_if_false +2 (to 5) - 4 jump +91 (to 95) - - 21 5 load_var 1 (t) - 6 load_type 1 - 7 call 672 ntypeargs=0 (baml.ops.equals_equals) - 8 pop_jump_if_false +2 (to 10) - 9 jump +84 (to 93) - - 24 10 load_var 1 (t) - 11 load_type 2 - 12 call 672 ntypeargs=0 (baml.ops.equals_equals) - 13 pop_jump_if_false +2 (to 15) - 14 jump +77 (to 91) - - 27 15 load_var 1 (t) - 16 load_type 3 - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 pop_jump_if_false +2 (to 20) - 19 jump +70 (to 89) - - 30 20 load_var 1 (t) - 21 load_type 4 - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - 23 pop_jump_if_false +2 (to 25) - 24 jump +63 (to 87) - - 33 25 load_var 1 (t) - 26 load_type 5 - 27 call 672 ntypeargs=0 (baml.ops.equals_equals) - 28 pop_jump_if_false +2 (to 30) - 29 jump +56 (to 85) - - 36 30 load_var 1 (t) - 31 load_type 6 - 32 call 672 ntypeargs=0 (baml.ops.equals_equals) - 33 pop_jump_if_false +2 (to 35) - 34 jump +49 (to 83) - - 39 35 load_var 1 (t) - 36 load_type 7 - 37 call 672 ntypeargs=0 (baml.ops.equals_equals) - 38 pop_jump_if_false +2 (to 40) - 39 jump +42 (to 81) - - 42 40 load_var 1 (t) - 41 load_type 8 - 42 call 672 ntypeargs=0 (baml.ops.equals_equals) - 43 jump_if_false +2 (to 45) - 44 jump +5 (to 49) - 45 pop 1 - 46 load_var 1 (t) - 47 load_type 9 - 48 call 672 ntypeargs=0 (baml.ops.equals_equals) - 49 pop_jump_if_false +2 (to 51) - 50 jump +29 (to 79) - - 45 51 load_var 1 (t) - 52 load_type 10 - 53 call 672 ntypeargs=0 (baml.ops.equals_equals) - 54 jump_if_false +2 (to 56) - 55 jump +5 (to 60) - 56 pop 1 - 57 load_var 1 (t) - 58 load_type 11 - 59 call 672 ntypeargs=0 (baml.ops.equals_equals) - 60 pop_jump_if_false +2 (to 62) - 61 jump +16 (to 77) - - 48 62 load_var 1 (t) - 63 load_type 12 - 64 call 672 ntypeargs=0 (baml.ops.equals_equals) - 65 jump_if_false +2 (to 67) - 66 jump +5 (to 71) - 67 pop 1 - 68 load_var 1 (t) - 69 load_type 13 - 70 call 672 ntypeargs=0 (baml.ops.equals_equals) - 71 pop_jump_if_false +2 (to 73) - 72 jump +3 (to 75) - - 51 73 load_const 14 ("") - 74 jump +22 (to 96) - - 49 75 load_const 15 ("mixed:image") - 76 jump +20 (to 96) - - 46 77 load_const 16 ("mixedlist:image") - 78 jump +18 (to 96) - - 43 79 load_const 17 ("list:image") - 80 jump +16 (to 96) - - 40 81 load_const 18 ("opt:pdf") - 82 jump +14 (to 96) - - 37 83 load_const 19 ("opt:video") - 84 jump +12 (to 96) - - 34 85 load_const 20 ("opt:audio") - 86 jump +10 (to 96) - - 31 87 load_const 21 ("opt:image") - 88 jump +8 (to 96) - - 28 89 load_const 22 ("one:pdf") - 90 jump +6 (to 96) - - 25 91 load_const 23 ("one:video") - 92 jump +4 (to 96) - - 22 93 load_const 24 ("one:audio") - 94 jump +2 (to 96) - - 19 95 load_const 25 ("one:image") - 96 return -} - -function ai.internal._merge_json(base: baml.json.json, patch: baml.json.json) -> baml.json.json { - 49 0 load_var 2 (patch) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 82 6 load_var 2 (patch) - - 49 7 jump +95 (to 102) - 8 load_var 3 (_3) - 9 store_var 4 (patch_object) - - 51 10 load_type 1 - 11 load_type 2 - 12 alloc_map 0 - 13 store_var 5 (out) - - 52 14 load_var 1 (base) - 15 store_var 6 (_6) - 16 load_var 6 (_6) - 17 narrow_bind 0 6 - 18 pop_jump_if_false +34 (to 52) - 19 load_var 6 (_6) - 20 store_var 7 (base_object) - - 56 21 load_type 1 - 22 load_type 2 - 23 load_var 7 (base_object) - 24 call 35 ntypeargs=2 (baml.Map.keys) - 25 load_type 3 - 26 load_const 4 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 8 (_11) - 29 load_var 8 (_11) - 30 load_type 5 - 31 load_const 6 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 9 (_12) - 34 load_var 9 (_12) - 35 is_type 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +15 (to 52) - 38 load_var 9 (_12) - 39 store_var 10 (key) - - 57 40 load_type 1 - 41 load_type 2 - 42 load_var2 7 10 - 43 call 38 ntypeargs=2 (baml.Map.get) - 44 store_var 11 (_18) - 45 load_type 1 - 46 load_type 2 - 47 load_var2 5 10 - 48 load_var 11 (_18) - 49 call 37 ntypeargs=2 (baml.Map.set) - 50 pop 1 - 51 jump -22 (to 29) - - 65 52 load_type 1 - 53 load_type 2 - 54 load_var 4 (patch_object) - 55 call 35 ntypeargs=2 (baml.Map.keys) - 56 load_type 3 - 57 load_const 8 ("iter") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 12 (_27) - 60 load_var 12 (_27) - 61 load_type 5 - 62 load_const 9 ("next") - 63 virtual_call nargs=1 ntypeargs=0 - 64 store_var 13 (_28) - 65 load_var 13 (_28) - 66 is_type 7 - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - 69 load_var 13 (_28) - 70 store_var 14 (key) - - 66 71 load_type 1 - 72 load_type 2 - 73 load_var2 4 14 - 74 call 38 ntypeargs=2 (baml.Map.get) - 75 store_var 15 (value) - - 67 76 load_var 15 (value) - 77 load_const 10 (null) - 78 cmp_op == - 79 pop_jump_if_false +2 (to 81) - 80 jump +15 (to 95) - - 75 81 load_type 1 - 82 load_type 2 - 83 load_var2 5 14 - 84 call 38 ntypeargs=2 (baml.Map.get) - 85 load_var 15 (value) - 86 call 997 ntypeargs=0 (ai.internal._merge_json) - 87 store_var 16 (_43) - 88 load_type 1 - 89 load_type 2 - 90 load_var2 5 14 - 91 load_var 16 (_43) - 92 call 37 ntypeargs=2 (baml.Map.set) - 93 pop 1 - 94 jump -34 (to 60) - - 69 95 load_type 1 - 96 load_type 2 - 97 load_var2 5 14 - 98 call 39 ntypeargs=2 (baml.Map.delete) - 99 pop 1 - 100 jump -40 (to 60) - - 80 101 load_var 5 (out) - 102 return -} - -function ai.internal._proxy(conn: ai.mcp.McpConnection, name: string) -> (map) -> string throws unknown { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 12 6 load_var2 1 2 - 7 make_closure 4349 2 - 8 return -} - -function ai.internal._redact_after(text: string, marker: string) -> string { - 17 0 load_const 0 ("") - 1 store_var 3 (out) - - 18 2 load_var 1 (text) - 3 store_var 4 (rest) - - 19 4 load_const 1 (true) - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - - 31 7 load_var 3 (out) - 8 jump +10 (to 18) - - 20 9 load_var2 4 2 - 10 call 155 ntypeargs=0 (baml.String.index_of) - - 21 11 store_var 5 (_6) - 12 load_var 5 (_6) - 13 narrow_bind 2 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +4 (to 19) - - 28 16 load_var2 3 4 - 17 bin_op + - 18 return - - 21 19 load_var 5 (_6) - 20 store_var 7 (_9) - - 22 21 load_var 2 (marker) - 22 call 139 ntypeargs=0 (baml.String.length) - 23 load_var 7 (_9) - 24 add_int - 25 store_var 6 (head) - - 23 26 load_var 4 (rest) - 27 load_const 2 (0) - 28 load_var 6 (head) - 29 call 153 ntypeargs=0 (baml.String.slice) - 30 store_var 8 (_11) - 31 load_var2 3 8 - 32 bin_op + - 33 store_var 3 (out) - - 24 34 load_var 3 (out) - 35 load_const 3 ("REDACTED") - 36 bin_op + - 37 store_var 3 (out) - - 25 38 load_var 4 (rest) - 39 call 139 ntypeargs=0 (baml.String.length) - 40 store_var 10 (_15) - 41 load_var2 4 6 - 42 load_var 10 (_15) - 43 call 153 ntypeargs=0 (baml.String.slice) - 44 store_var 9 (tail) - - 26 45 load_var 9 (tail) - 46 call 996 ntypeargs=0 (ai.internal._redact_value_end) - 47 store_var 11 (_16) - 48 load_var 9 (tail) - 49 call 139 ntypeargs=0 (baml.String.length) - 50 store_var 12 (_18) - 51 load_var2 9 11 - 52 load_var 12 (_18) - 53 call 153 ntypeargs=0 (baml.String.slice) - 54 store_var 4 (rest) - 55 jump -51 (to 4) -} - -function ai.internal._redact_value_end(tail: string) -> int { - 35 0 load_var 1 (tail) - 1 call 139 ntypeargs=0 (baml.String.length) - 2 store_var 2 (cut) - - 36 3 load_const 0 ("&") - 4 load_const 1 (" ") - 5 load_const 2 ("\"") - 6 load_const 3 ("'") - 7 load_const 4 (")") - 8 load_const 5 (",") - 9 load_const 6 ("\n") - 10 load_const 7 ("\t") - 11 load_type 8 - 12 alloc_array 8 - 13 load_type 9 - 14 load_const 10 ("iter") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 3 (_4) - 17 load_var 3 (_4) - 18 load_type 11 - 19 load_const 12 ("next") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 4 (_5) - 22 load_var 4 (_5) - 23 is_type 13 - 24 pop_jump_if_false +2 (to 26) - 25 jump +15 (to 40) - - 37 26 load_var2 1 4 - 27 call 155 ntypeargs=0 (baml.String.index_of) - 28 store_var 5 (_11) - 29 load_var 5 (_11) - 30 narrow_bind 14 5 - 31 pop_jump_if_false -14 (to 17) - 32 load_var 5 (_11) - 33 store_var_load_var 6 (at) - - 38 34 load_var 2 (cut) - 35 cmp_int_op < - 36 pop_jump_if_false -19 (to 17) - - 39 37 load_var 6 (at) - 38 store_var 2 (cut) - - 38 39 jump -22 (to 17) - - 43 40 load_var 2 (cut) - 41 return -} - -function ai.internal._resolve_media_content(url: string | null, file: string | null, inline: string, mime: string, fetch_url: bool) -> ai.wire.ResolvedMedia { - 72 0 load_var 2 (file) - 1 store_var 6 (_6) - 2 load_var 6 (_6) - 3 narrow_bind 0 6 - 4 pop_jump_if_false +2 (to 6) - 5 jump +221 (to 226) - - 95 6 load_var 3 (inline) - 7 load_const 1 ("") - 8 cmp_op != - 9 pop_jump_if_false +2 (to 11) - 10 jump +212 (to 222) - - 98 11 load_var 1 (url) - 12 store_var 18 (_40) - 13 load_var 18 (_40) - 14 narrow_bind 0 18 - 15 pop_jump_if_false +2 (to 17) - 16 jump +4 (to 20) - - 161 17 load_const 2 ("media has no URL, file, or base64 content") - 18 init_instance 0 (baml.errors.InvalidArgument .message) - 19 throw - - 98 20 load_var 18 (_40) - 21 store_var 19 (media_url) - - 99 22 load_var 19 (media_url) - 23 load_const 3 ("data:") - 24 call 148 ntypeargs=0 (baml.String.starts_with) - 25 pop_jump_if_false +2 (to 27) - 26 jump +138 (to 164) - - 122 27 load_var 5 (fetch_url) - 28 unary_op ! - 29 jump_if_false +2 (to 31) - 30 jump +5 (to 35) - 31 pop 1 - 32 load_var 19 (media_url) - 33 load_const 4 ("gs://") - 34 call 148 ntypeargs=0 (baml.String.starts_with) - 35 pop_jump_if_false +2 (to 37) - 36 jump +123 (to 159) - - 127 37 load_const 5 (30) - 38 call 522 ntypeargs=0 (baml.time.Duration.from_seconds) - 39 store_var 31 (_69) - 40 load_var2 19 31 - 41 call 248 ntypeargs=0 (baml.http.fetch) - 42 store_var 29 (response) - 43 jump +26 (to 69) - 44 load_var 30 (e) - 45 throw_if_panic - - 131 46 load_type 6 - 47 load_var 19 (media_url) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 32 (_74) - 50 load_type 7 - 51 load_var 30 (e) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 34 (_78) - 54 load_type 6 - 55 load_var 34 (_78) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 33 (_77) - - 129 58 load_const 8 ("media") - - 131 59 load_const 9 ("media URL ") - 60 load_var 32 (_74) - 61 bin_op + - 62 load_const 10 (" could not be fetched: ") - 63 bin_op + - 64 load_var 33 (_77) - 65 bin_op + - 66 load_const 11 (null) - 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 68 throw - - 136 69 load_var 29 (response) - 70 call 240 ntypeargs=0 (baml.http.Response.ok) - 71 unary_op ! - 72 pop_jump_if_false +2 (to 74) - 73 jump +66 (to 139) - - 143 74 load_type 6 - 75 load_type 6 - 76 load_var 29 (response) - 77 load_field 1 (headers) - 78 load_const 12 ("content-type") - 79 call 38 ntypeargs=2 (baml.Map.get) - 80 store_var_load_var 38 (_94) - 81 load_const 11 (null) - 82 cmp_op == - 83 pop_jump_if_false +3 (to 86) - 84 load_var 4 (mime) - 85 store_var 38 (_94) - 86 load_var 38 (_94) - 87 store_var 37 (response_mime) - - 144 88 load_var 29 (response) - 89 sys_op 239 (baml.http.Response.bytes) - 90 jump +26 (to 116) - 91 load_var 39 (e) - 92 throw_if_panic - - 148 93 load_type 6 - 94 load_var 19 (media_url) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 40 (_106) - 97 load_type 13 - 98 load_var 39 (e) - 99 call 138 ntypeargs=1 (baml.String.from) - 100 store_var 42 (_110) - 101 load_type 6 - 102 load_var 42 (_110) - 103 call 138 ntypeargs=1 (baml.String.from) - 104 store_var 41 (_109) - - 146 105 load_const 14 ("media") - - 148 106 load_const 15 ("media URL ") - 107 load_var 40 (_106) - 108 bin_op + - 109 load_const 16 (" body could not be read: ") - 110 bin_op + - 111 load_var 41 (_109) - 112 bin_op + - 113 load_const 11 (null) - 114 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 115 throw - - 155 116 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 117 store_var 43 (_113) - - 158 118 load_var 37 (response_mime) - 119 load_const 17 (";") - 120 call 150 ntypeargs=0 (baml.String.split) - 121 store_var 46 (_118) - 122 load_type 6 - 123 load_var 46 (_118) - 124 load_const 18 (0) - 125 call 3 ntypeargs=1 (baml.Array.at) - 126 store_var_load_var 45 (_116) - 127 load_const 11 (null) - 128 cmp_op == - 129 pop_jump_if_false +3 (to 132) - 130 load_var 4 (mime) - 131 store_var 45 (_116) - 132 load_var 45 (_116) - 133 call 144 ntypeargs=0 (baml.String.trim) - 134 store_var 44 (_114) - - 153 135 load_const 11 (null) - 136 load_var2 43 44 - 137 init_instance 3 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 138 jump +154 (to 292) - - 139 139 load_type 6 - 140 load_var 19 (media_url) - 141 call 138 ntypeargs=1 (baml.String.from) - 142 store_var 35 (_87) - 143 load_type 19 - 144 load_var 29 (response) - 145 load_field 0 (status_code) - 146 call 138 ntypeargs=1 (baml.String.from) - 147 store_var 36 (_90) - - 137 148 load_const 20 ("media") - - 139 149 load_const 21 ("media URL ") - 150 load_var 35 (_87) - 151 bin_op + - 152 load_const 22 (" returned HTTP ") - 153 bin_op + - 154 load_var 36 (_90) - 155 bin_op + - 156 load_const 11 (null) - 157 init_instance 4 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 158 throw - - 123 159 load_var 19 (media_url) - 160 load_const 11 (null) - 161 load_var 4 (mime) - 162 init_instance 5 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 163 jump +129 (to 292) - - 100 164 load_var 19 (media_url) - 165 load_const 23 (";base64,") - 166 call 155 ntypeargs=0 (baml.String.index_of) - 167 store_var 20 (_44) - 168 load_var 20 (_44) - 169 narrow_bind 18 20 - 170 pop_jump_if_false +2 (to 172) - 171 jump +30 (to 201) - - 113 172 load_var 19 (media_url) - 173 call 139 ntypeargs=0 (baml.String.length) - 174 load_const 24 (48) - 175 cmp_int_op > - 176 pop_jump_if_false +2 (to 178) - 177 jump +4 (to 181) - - 116 178 load_var 19 (media_url) - 179 store_var 26 (preview) - - 113 180 jump +12 (to 192) - - 114 181 load_var 19 (media_url) - 182 load_const 18 (0) - 183 load_const 24 (48) - 184 call 153 ntypeargs=0 (baml.String.slice) - 185 store_var 27 (_56) - 186 load_type 6 - 187 load_var 27 (_56) - 188 call 138 ntypeargs=1 (baml.String.from) - 189 load_const 25 ("...") - 190 bin_op + - 191 store_var 26 (preview) - - 119 192 load_type 6 - 193 load_var 26 (preview) - 194 call 138 ntypeargs=1 (baml.String.from) - 195 store_var 28 (_60) - 196 load_const 26 ("media carries a data: URL with no ;base64, marker, which has no payload to send: ") - 197 load_var 28 (_60) - 198 bin_op + - 199 init_instance 6 (baml.errors.InvalidArgument .message) - 200 throw - - 100 201 load_var 20 (_44) - 202 store_var_load_var 21 (separator) - - 103 203 load_const 27 (8) - 204 add_int - 205 store_var 23 (_47) - 206 load_var 19 (media_url) - 207 call 139 ntypeargs=0 (baml.String.length) - 208 store_var 24 (_49) - 209 load_var2 19 23 - 210 load_var 24 (_49) - 211 call 153 ntypeargs=0 (baml.String.slice) - 212 store_var 22 (_46) - - 104 213 load_var 19 (media_url) - 214 load_const 28 (5) - 215 load_var 21 (separator) - 216 call 153 ntypeargs=0 (baml.String.slice) - 217 store_var 25 (_50) - - 101 218 load_const 11 (null) - 219 load_var2 22 25 - 220 init_instance 7 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 221 jump +71 (to 292) - - 96 222 load_const 11 (null) - 223 load_var2 3 4 - 224 init_instance 8 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 225 jump +67 (to 292) - - 72 226 load_var 6 (_6) - 227 store_var_load_var 7 (path) - - 77 228 load_const 29 ("r") - 229 sys_op 289 (baml.fs.open) - 230 store_var 8 (handle) - 231 jump +24 (to 255) - 232 load_var 9 (e) - 233 throw_if_panic - - 80 234 load_type 6 - 235 load_var 7 (path) - 236 call 138 ntypeargs=1 (baml.String.from) - 237 store_var 10 (_15) - 238 load_type 30 - 239 load_var 9 (e) - 240 call 138 ntypeargs=1 (baml.String.from) - 241 store_var 12 (_19) - 242 load_type 6 - 243 load_var 12 (_19) - 244 call 138 ntypeargs=1 (baml.String.from) - 245 store_var 11 (_18) - 246 load_const 31 ("media file ") - 247 load_var 10 (_15) - 248 bin_op + - 249 load_const 32 (" could not be opened: ") - 250 bin_op + - 251 load_var 11 (_18) - 252 bin_op + - 253 init_instance 9 (baml.errors.InvalidArgument .message) - 254 throw - - 84 255 load_var 8 (handle) - 256 sys_op 282 (baml.fs.File.bytes) - 257 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 258 store_var 13 (data) - 259 jump +27 (to 286) - 260 load_var 14 (e) - 261 throw_if_panic - - 86 262 load_var 8 (handle) - 263 sys_op 285 (baml.fs.File.close) - 264 pop 1 - - 88 265 load_type 6 - 266 load_var 7 (path) - 267 call 138 ntypeargs=1 (baml.String.from) - 268 store_var 15 (_30) - 269 load_type 30 - 270 load_var 14 (e) - 271 call 138 ntypeargs=1 (baml.String.from) - 272 store_var 17 (_34) - 273 load_type 6 - 274 load_var 17 (_34) - 275 call 138 ntypeargs=1 (baml.String.from) - 276 store_var 16 (_33) - 277 load_const 33 ("media file ") - 278 load_var 15 (_30) - 279 bin_op + - 280 load_const 34 (" could not be read: ") - 281 bin_op + - 282 load_var 16 (_33) - 283 bin_op + - 284 init_instance 10 (baml.errors.InvalidArgument .message) - 285 throw - - 92 286 load_var 8 (handle) - 287 sys_op 285 (baml.fs.File.close) - 288 pop 1 - - 93 289 load_const 11 (null) - 290 load_var2 13 4 - 291 init_instance 11 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 292 return -} - -function ai.internal._resolve_pending_call(pending: string[], id: string) -> void { - 135 0 load_type 0 - 1 load_var2 1 2 - 2 call 24 ntypeargs=1 (baml.Array.index_of) - 3 store_var 3 (_5) - 4 load_var 3 (_5) - 5 narrow_bind 1 3 - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - 8 load_const 2 (null) - 9 jump +6 (to 15) - - 136 10 load_type 0 - 11 load_var2 1 3 - 12 call 6 ntypeargs=1 (baml.Array.remove_at) - 13 pop 1 - - 135 14 load_const 2 (null) - 15 return -} - -function ai.internal._retry_after_ms(headers: map | null) -> int | null { - 33 0 load_var 1 (headers) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +20 (to 24) - 5 load_var 2 (_2) - 6 store_var_load_var 3 (h) - - 34 7 load_const 1 ("retry-after-ms") - 8 load_const 2 ("Retry-After-Ms") - 9 call 1004 ntypeargs=0 (ai.internal._int_header) - 10 store_var 4 (_6) - 11 load_var 4 (_6) - 12 narrow_bind 3 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +16 (to 30) - - 37 15 load_var 3 (h) - 16 load_const 4 ("retry-after") - 17 load_const 5 ("Retry-After") - 18 call 1004 ntypeargs=0 (ai.internal._int_header) - 19 store_var 5 (_10) - 20 load_var 5 (_10) - 21 narrow_bind 3 5 - 22 pop_jump_if_false +2 (to 24) - 23 jump +3 (to 26) - - 41 24 load_const 6 (null) - 25 jump +6 (to 31) - - 37 26 load_var 5 (_10) - 27 load_const 7 (1000) - 28 mul_int - - 38 29 jump +2 (to 31) - - 34 30 load_var 4 (_6) - 31 return -} - -function ai.internal._schema_for_signature(handler: baml.AnyFunction) -> map { - 6 0 load_var 1 (handler) - 1 call 774 ntypeargs=0 (baml.reflect.signature) - 2 store_var 2 (sig) - - 7 3 load_type 0 - 4 load_type 1 - 5 alloc_map 0 - 6 store_var 3 (props) - - 8 7 load_type 0 - 8 alloc_array 0 - 9 store_var 4 (required) - - 9 10 load_var 2 (sig) - 11 load_field 1 (args) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 5 (_6) - 16 load_var 5 (_6) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 6 (_7) - 21 load_var 6 (_7) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +22 (to 46) - 25 load_var 6 (_7) - 26 store_var 7 (a) - - 10 27 load_var 7 (a) - 28 load_field 0 (name) - 29 store_var 8 (_12) - 30 load_var 7 (a) - 31 load_field 1 (type) - 32 sys_op 365 (baml.json.schema) - 33 store_var 9 (_13) - 34 load_type 0 - 35 load_type 1 - 36 load_var2 3 8 - 37 load_var 9 (_13) - 38 call 37 ntypeargs=2 (baml.Map.set) - 39 pop 1 - - 11 40 load_type 0 - 41 load_var2 4 7 - 42 load_field 0 (name) - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -29 (to 16) - - 13 46 load_const 7 ("object") - 47 load_var2 3 4 - 48 load_const 8 (false) - 49 load_const 9 ("type") - 50 load_const 10 ("properties") - 51 load_const 11 ("required") - 52 load_const 12 ("additionalProperties") - 53 load_type 0 - 54 load_type 1 - 55 alloc_map 4 - 56 return -} - -function ai.internal._shorthand_prefixes() -> string { - 8 0 load_type 0 - 1 load_const 1 ("openai") - 2 load_const 2 ("openai-chat") - 3 load_const 3 ("openai-images") - 4 load_const 4 ("azure") - 5 load_const 5 ("ollama") - 6 load_const 6 ("openrouter") - 7 load_const 7 ("anthropic") - 8 load_const 8 ("google") - 9 load_const 9 ("vertex") - 10 load_const 10 ("bedrock") - 11 load_const 11 ("ai-gateway-images") - 12 load_const 12 ("claude-code") - 13 load_type 0 - 14 alloc_array 12 - 15 load_const 13 (", ") - 16 call 15 ntypeargs=1 (baml.Array.join) - 17 return -} - -function ai.internal._wire_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], keep_reasoning: bool) -> (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[] { - 94 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 95 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_5) - 13 load_var 5 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +46 (to 62) - 17 load_var 5 (_5) - 18 store_var 6 (block) - - 96 19 load_var 6 (block) - 20 store_var 7 (_9) - 21 load_var 7 (_9) - 22 narrow_bind 6 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +26 (to 50) - 25 load_var 6 (block) - 26 store_var 9 (_17) - 27 load_var 9 (_17) - 28 narrow_bind 7 9 - 29 pop_jump_if_false +2 (to 31) - 30 jump +11 (to 41) - 31 load_var 6 (block) - 32 store_var 11 (_22) - 33 load_var 11 (_22) - 34 narrow_bind 8 11 - 35 pop_jump_if_false -27 (to 8) - - 110 36 load_type 0 - 37 load_var2 3 11 - 38 call 4 ntypeargs=1 (baml.Array.push) - 39 pop 1 - 40 jump -32 (to 8) - - 96 41 load_var 9 (_17) - 42 store_var 10 (reasoning) - - 104 43 load_var 2 (keep_reasoning) - 44 pop_jump_if_false -36 (to 8) - - 105 45 load_type 0 - 46 load_var2 3 10 - 47 call 4 ntypeargs=1 (baml.Array.push) - 48 pop 1 - 49 jump -41 (to 8) - - 96 50 load_var 7 (_9) - 51 store_var_load_var 8 (text) - - 98 52 load_field 0 (text) - 53 call 144 ntypeargs=0 (baml.String.trim) - 54 load_const 9 ("") - 55 cmp_op != - 56 pop_jump_if_false -48 (to 8) - - 99 57 load_type 0 - 58 load_var2 3 8 - 59 call 4 ntypeargs=1 (baml.Array.push) - 60 pop 1 - 61 jump -53 (to 8) - - 119 62 load_var 3 (out) - 63 return -} - -function ai.internal.assemble_prompt(parts: string[], values: unknown[]) -> ai.Prompt { -} - -function ai.internal.build_output_format(return_type: type) -> ai.OutputFormat { -} - -function ai.internal.get_return_type(function_name: string) -> type { -} - -function ai.internal.make_role(name: string) -> ai.Role { - 46 0 load_var 1 (name) - 1 load_type 0 - 2 load_type 1 - 3 alloc_map 0 - 4 init_instance 0 (ai.Role .name, .metadata) - 5 return -} - -function ai.internal.render_output_format(return_type: type) -> string { -} - -function ai.internal.validate_output_type(return_type: type) -> void { - 10 0 load_var 1 (return_type) - 1 call 215 ntypeargs=0 (baml.TypeValue._validate_renderable) - 2 pop 1 - - 11 3 load_var 1 (return_type) - 4 call 207 ntypeargs=0 (baml.TypeValue.as_enum) - 5 store_var 2 (_4) - 6 load_var 2 (_4) - 7 narrow_bind 0 2 - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 25 10 load_const 1 (null) - - 11 11 jump +11 (to 22) - 12 load_var 2 (_4) - - 13 13 call 795 ntypeargs=0 (baml.reflect.enum.Type.values) - 14 container_len - 15 store_var 3 (_7) - 16 load_var 3 (_7) - 17 load_const 2 (0) - 18 cmp_int_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +3 (to 23) - 21 load_const 1 (null) - 22 return - - 14 23 load_var 1 (return_type) - 24 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 25 store_var 5 (_11) - 26 load_const 3 ("empty enum `") - 27 load_var 5 (_11) - 28 bin_op + - 29 load_const 4 ("` cannot be rendered as an LLM output schema") - 30 bin_op + - 31 store_var_load_var 4 (message) - - 17 32 load_const 5 ("E0159") - 33 load_const 1 (null) - - 20 34 load_var 4 (message) - 35 init_instance 0 (baml.reflect.Diagnostic .code, .span, .message) - 36 load_type 6 - 37 alloc_array 1 - 38 init_instance 1 (baml.reflect.errors.CompilationError .message, .diagnostics) - 39 throw -} - -function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, params: map) -> baml.json.json { - 86 0 load_var 1 (self) - 1 load_field 2 (next_id) - 2 store_var 4 (id) - - 87 3 load_var 1 (self) - 4 copy 0 - 5 load_field 2 (next_id) - 6 load_const 0 (1) - 7 bin_op + - 8 store_field 2 (next_id) - - 88 9 load_var2 4 2 - 10 load_var 3 (params) - 11 call 1364 ntypeargs=0 (ai.mcp.rpc_line) - 12 store_var 5 (_6) - 13 load_var2 1 5 - 14 call 1366 ntypeargs=0 (ai.mcp.McpConnection._send) - 15 pop 1 - - 89 16 load_const 1 (true) - 17 pop_jump_if_false +2 (to 19) - 18 jump +19 (to 37) - - 132 19 load_type 2 - 20 load_var 1 (self) - 21 load_field 0 (server_name) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 22 (_66) - - 133 24 load_type 2 - 25 load_var 2 (method) - 26 call 138 ntypeargs=1 (baml.String.from) - 27 store_var 23 (_70) - - 132 28 load_const 3 ("mcp/") - 29 load_var 22 (_66) - 30 bin_op + - - 133 31 load_const 4 ("no response for ") - 32 load_var 23 (_70) - 33 bin_op + - 34 load_const 5 (null) - 35 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 36 throw - - 90 37 load_var 1 (self) - 38 load_field 1 (p) - 39 load_field 0 (stdout) - 40 load_type 6 - 41 load_const 7 ("next") - 42 virtual_call nargs=1 ntypeargs=0 - 43 store_var 6 (next) - 44 jump +25 (to 69) - 45 load_var 7 (e) - 46 throw_if_panic - - 93 47 load_type 2 - 48 load_var 1 (self) - 49 load_field 0 (server_name) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 8 (_13) - - 94 52 load_type 8 - 53 load_var 7 (e) - 54 call 138 ntypeargs=1 (baml.String.from) - 55 store_var 10 (_18) - 56 load_type 2 - 57 load_var 10 (_18) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 9 (_17) - - 93 60 load_const 9 ("mcp/") - 61 load_var 8 (_13) - 62 bin_op + - - 94 63 load_const 10 ("reading from the MCP server failed: ") - 64 load_var 9 (_17) - 65 bin_op + - 66 load_const 5 (null) - 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 68 throw - - 99 69 load_var 6 (next) - 70 store_var 11 (_21) - 71 load_var 11 (_21) - 72 narrow_bind 0 11 - 73 pop_jump_if_false +2 (to 75) - 74 jump +19 (to 93) - - 123 75 load_type 2 - 76 load_var 1 (self) - 77 load_field 0 (server_name) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 20 (_58) - - 124 80 load_type 2 - 81 load_var 2 (method) - 82 call 138 ntypeargs=1 (baml.String.from) - 83 store_var 21 (_62) - - 123 84 load_const 11 ("mcp/") - 85 load_var 20 (_58) - 86 bin_op + - - 124 87 load_const 12 ("the MCP server stream ended before answering ") - 88 load_var 21 (_62) - 89 bin_op + - 90 load_const 5 (null) - 91 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 92 throw - - 99 93 load_var 11 (_21) - - 101 94 call 144 ntypeargs=0 (baml.String.trim) - 95 store_var 12 (trimmed) - - 102 96 load_var 12 (trimmed) - 97 call 139 ntypeargs=0 (baml.String.length) - 98 load_const 13 (0) - 99 cmp_int_op > - 100 pop_jump_if_false -84 (to 16) - - 104 101 load_var 12 (trimmed) - 102 call 350 ntypeargs=0 (baml.json.parse) - 103 store_var 13 (msg) - 104 jump +5 (to 109) - 105 load_var 14 (e) - 106 throw_if_panic - - 105 107 load_const 5 (null) - 108 store_var 13 (msg) - - 107 109 load_type 14 - 110 load_var 13 (msg) - 111 load_const 15 (".id") - 112 load_const 0 (1) - 113 unary_op - - 114 call 364 ntypeargs=1 (baml.json.path_or) - 115 load_var 4 (id) - 116 cmp_int_op == - 117 pop_jump_if_false -101 (to 16) - - 108 118 load_type 16 - 119 load_var 13 (msg) - 120 load_const 17 (".error") - 121 load_const 5 (null) - 122 call 364 ntypeargs=1 (baml.json.path_or) - 123 store_var 15 (err) - - 109 124 load_var 15 (err) - 125 load_const 5 (null) - 126 call 672 ntypeargs=0 (baml.ops.equals_equals) - 127 unary_op ! - 128 pop_jump_if_false +2 (to 130) - 129 jump +7 (to 136) - - 117 130 load_type 16 - 131 load_var 13 (msg) - 132 load_const 18 (".result") - 133 load_const 5 (null) - 134 call 364 ntypeargs=1 (baml.json.path_or) - 135 return - - 111 136 load_type 2 - 137 load_var 1 (self) - 138 load_field 0 (server_name) - 139 call 138 ntypeargs=1 (baml.String.from) - 140 store_var 16 (_43) - - 112 141 load_type 19 - 142 load_var 15 (err) - 143 load_const 20 (".code") - 144 load_const 5 (null) - 145 call 364 ntypeargs=1 (baml.json.path_or) - 146 store_var 17 (_46) - - 113 147 load_type 2 - 148 load_var 15 (err) - 149 load_const 21 (".message") - 150 load_const 22 ("MCP error") - 151 call 364 ntypeargs=1 (baml.json.path_or) - 152 store_var 18 (_49) - - 114 153 load_var 15 (err) - 154 call 351 ntypeargs=0 (baml.json.stringify) - 155 store_var 19 (_52) - - 111 156 load_const 23 ("mcp/") - 157 load_var 16 (_43) - 158 bin_op + - 159 load_var2 17 18 - 160 load_var 19 (_52) - 161 init_instance 3 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 162 throw -} - -function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> void { - 71 0 load_type 0 - 1 load_var 2 (line) - 2 load_const 1 ("\n") - 3 load_type 0 - 4 alloc_array 2 - 5 load_const 2 ("") - 6 call 15 ntypeargs=1 (baml.Array.join) - 7 store_var 3 (framed) - - 72 8 load_var 1 (self) - 9 load_field 1 (p) - 10 load_var 3 (framed) - 11 sys_op 267 (baml.sys.Process.write_stdin) - 12 pop 1 - 13 jump +25 (to 38) - 14 load_var 4 (e) - 15 throw_if_panic - - 75 16 load_type 0 - 17 load_var 1 (self) - 18 load_field 0 (server_name) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 5 (_12) - - 76 21 load_type 3 - 22 load_var 4 (e) - 23 call 138 ntypeargs=1 (baml.String.from) - 24 store_var 7 (_17) - 25 load_type 0 - 26 load_var 7 (_17) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 6 (_16) - - 75 29 load_const 4 ("mcp/") - 30 load_var 5 (_12) - 31 bin_op + - - 76 32 load_const 5 ("writing to the MCP server failed: ") - 33 load_var 6 (_16) - 34 bin_op + - 35 load_const 6 (null) - 36 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 37 throw - - 67 38 load_const 6 (null) - 39 return -} - -function ai.mcp.McpConnection.call_tool(self: ai.mcp.McpConnection, name: string, args: map) -> string { - 170 0 load_var 1 (self) - 1 load_const 0 ("tools/call") - - 169 2 load_var2 2 3 - 3 load_const 1 ("name") - 4 load_const 2 ("arguments") - 5 load_type 3 - 6 load_type 4 - 7 alloc_map 2 - - 170 8 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 9 store_var 4 (result) - - 171 10 load_type 3 - 11 alloc_array 0 - 12 store_var 5 (texts) - - 172 13 load_type 5 - 14 load_var 4 (result) - 15 load_const 6 (".content") - 16 load_type 7 - 17 alloc_array 0 - 18 call 364 ntypeargs=1 (baml.json.path_or) - 19 load_type 8 - 20 load_const 9 ("iter") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 6 (_12) - 23 load_var 6 (_12) - 24 load_type 10 - 25 load_const 11 ("next") - 26 virtual_call nargs=1 ntypeargs=0 - 27 store_var 7 (_13) - 28 load_var 7 (_13) - 29 is_type 12 - 30 pop_jump_if_false +2 (to 32) - 31 jump +22 (to 53) - 32 load_var 7 (_13) - 33 store_var 8 (item) - - 173 34 load_type 3 - 35 load_var 8 (item) - 36 load_const 13 (".type") - 37 load_const 14 ("") - 38 call 364 ntypeargs=1 (baml.json.path_or) - 39 load_const 15 ("text") - 40 cmp_op == - 41 pop_jump_if_false -18 (to 23) - - 174 42 load_type 3 - 43 load_var 8 (item) - 44 load_const 16 (".text") - 45 load_const 17 ("") - 46 call 364 ntypeargs=1 (baml.json.path_or) - 47 store_var 9 (_22) - 48 load_type 3 - 49 load_var2 5 9 - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -29 (to 23) - - 177 53 load_type 3 - 54 load_var 5 (texts) - 55 load_const 18 ("\n") - 56 call 15 ntypeargs=1 (baml.Array.join) - 57 store_var 10 (joined) - - 178 58 load_type 19 - 59 load_var 4 (result) - 60 load_const 20 (".isError") - 61 load_const 21 (false) - 62 call 364 ntypeargs=1 (baml.json.path_or) - 63 pop_jump_if_false +2 (to 65) - 64 jump +3 (to 67) - - 181 65 load_var 10 (joined) - 66 return - - 179 67 load_type 3 - 68 load_var 2 (name) - 69 call 138 ntypeargs=1 (baml.String.from) - 70 store_var 11 (_35) - 71 load_type 3 - 72 load_var 10 (joined) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 12 (_37) - 75 load_const 22 ("mcp tool ") - 76 load_var 11 (_35) - 77 bin_op + - 78 load_const 23 (" failed: ") - 79 bin_op + - 80 load_var 12 (_37) - 81 bin_op + - 82 init_instance 0 (baml.errors.InvalidArgument .message) - 83 throw -} - -function ai.mcp.McpConnection.close(self: ai.mcp.McpConnection) -> void { - 185 0 load_var 1 (self) - 1 load_field 1 (p) - 2 sys_op 271 (baml.sys.Process.close) - 3 pop 1 - - 184 4 load_const 0 (null) - 5 return -} - -function ai.mcp.McpConnection.connect(name: string, command: string, args: string[], timeout_ms: int) -> ai.mcp.McpConnection { - 0 load_var 4 (timeout_ms) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 35 4 load_const 1 (30000) - 5 store_var 4 (timeout_ms) - - 37 6 load_var2 2 3 - - 40 7 load_const 2 (null) - 8 load_const 2 (null) - 9 load_var 4 (timeout_ms) - 10 load_const 2 (null) - 11 load_const 3 (true) - 12 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) - 13 sys_op 273 (baml.sys.start_process) - 14 store_var 5 (p) - 15 jump +24 (to 39) - - 37 16 load_var 6 (e) - 17 throw_if_panic - - 50 18 load_type 4 - 19 load_var 1 (name) - 20 call 138 ntypeargs=1 (baml.String.from) - 21 store_var 7 (_11) - - 51 22 load_type 5 - 23 load_var 6 (e) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 store_var 9 (_15) - 26 load_type 4 - 27 load_var 9 (_15) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 8 (_14) - - 50 30 load_const 6 ("mcp/") - 31 load_var 7 (_11) - 32 bin_op + - - 51 33 load_const 7 ("the MCP server could not start: ") - 34 load_var 8 (_14) - 35 bin_op + - 36 load_const 2 (null) - 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 38 throw - - 56 39 load_var2 1 5 - 40 load_const 8 (1) - 41 init_instance 2 (ai.mcp.McpConnection .server_name, .p, .next_id) - 42 store_var 10 (conn) - - 62 43 load_var 10 (conn) - 44 load_const 9 ("initialize") - - 57 45 load_const 10 ("2025-06-18") - - 59 46 load_type 4 - 47 load_type 11 - 48 alloc_map 0 - - 60 49 load_const 12 ("baml-mcp") - 50 load_const 13 ("0.1") - 51 load_const 14 ("name") - 52 load_const 15 ("version") - 53 load_type 4 - 54 load_type 4 - 55 alloc_map 2 - 56 load_const 16 ("protocolVersion") - 57 load_const 17 ("capabilities") - 58 load_const 18 ("clientInfo") - 59 load_type 4 - 60 load_type 11 - 61 alloc_map 3 - - 62 62 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 63 pop 1 - - 63 64 load_const 2 (null) - 65 load_const 19 ("notifications/initialized") - 66 load_const 2 (null) - 67 call 1364 ntypeargs=0 (ai.mcp.rpc_line) - 68 store_var 11 (_26) - 69 load_var2 10 11 - 70 call 1366 ntypeargs=0 (ai.mcp.McpConnection._send) - 71 pop 1 - - 64 72 load_var 10 (conn) - 73 return -} - -function ai.mcp.McpConnection.tools(self: ai.mcp.McpConnection) -> ai.tools.Tool[] { - 142 0 load_var 1 (self) - 1 load_const 0 ("tools/list") - 2 load_type 1 - 3 load_type 2 - 4 alloc_map 0 - 5 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 6 store_var 2 (result) - - 143 7 load_type 3 - 8 alloc_array 0 - 9 store_var 3 (out) - - 144 10 load_type 4 - 11 load_var 2 (result) - 12 load_const 5 (".tools") - 13 load_type 6 - 14 alloc_array 0 - 15 call 364 ntypeargs=1 (baml.json.path_or) - 16 load_type 7 - 17 load_const 8 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 4 (_9) - 20 load_var 4 (_9) - 21 load_type 9 - 22 load_const 10 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 5 (_10) - 25 load_var 5 (_10) - 26 is_type 11 - 27 pop_jump_if_false +2 (to 29) - 28 jump +49 (to 77) - 29 load_var 5 (_10) - 30 store_var 6 (t) - - 145 31 load_type 1 - 32 load_var 6 (t) - 33 load_const 12 (".name") - 34 load_const 13 ("") - 35 call 364 ntypeargs=1 (baml.json.path_or) - 36 store_var 7 (tool_name) - - 147 37 load_type 6 - 38 load_var 6 (t) - 39 load_const 14 (".inputSchema") - 40 load_type 1 - 41 load_type 6 - 42 alloc_map 0 - 43 call 364 ntypeargs=1 (baml.json.path_or) - 44 store_var 10 (_19) - - 146 45 load_type 15 - 46 load_var 10 (_19) - 47 call 358 ntypeargs=1 (baml.json.from_json) - 48 store_var 8 (schema) - 49 jump +7 (to 56) - 50 load_var 9 (e) - 51 throw_if_panic - - 150 52 load_type 1 - 53 load_type 2 - 54 alloc_map 0 - 55 store_var 8 (schema) - - 157 56 load_type 1 - 57 load_var 6 (t) - 58 load_const 16 (".description") - 59 load_const 17 ("") - 60 call 364 ntypeargs=1 (baml.json.path_or) - 61 store_var 12 (_28) - - 158 62 load_var 8 (schema) - 63 store_var 13 (_31) - - 159 64 load_var2 1 7 - 65 call 1371 ntypeargs=0 (ai.internal._proxy) - 66 store_var 14 (_32) - - 156 67 load_var2 7 12 - 68 load_var2 13 14 - 69 load_const 18 () - - 155 70 call 920 ntypeargs=0 (ai.tools.raw_tool) - 71 store_var 11 (_26) - - 154 72 load_type 3 - 73 load_var2 3 11 - 74 call 4 ntypeargs=1 (baml.Array.push) - 75 pop 1 - 76 jump -56 (to 20) - - 163 77 load_var 3 (out) - 78 return -} - -function ai.mcp.rpc_line(id: int | null, method: string, params: map | null) -> string { - 14 0 load_const 0 ("2.0") - 1 load_var 2 (method) - 2 load_const 1 ("jsonrpc") - 3 load_const 2 ("method") - 4 load_type 3 - 5 load_type 4 - 6 alloc_map 2 - 7 store_var 4 (m) - - 15 8 load_var 1 (id) - 9 store_var 5 (_5) - 10 load_var 5 (_5) - 11 narrow_bind 5 5 - 12 pop_jump_if_false +8 (to 20) - - 16 13 load_type 3 - 14 load_type 4 - 15 load_var 4 (m) - 16 load_const 6 ("id") - - 15 17 load_var 5 (_5) - - 16 18 call 37 ntypeargs=2 (baml.Map.set) - 19 pop 1 - - 18 20 load_var 3 (params) - 21 store_var 6 (_11) - 22 load_var 6 (_11) - 23 narrow_bind 7 6 - 24 pop_jump_if_false +8 (to 32) - - 19 25 load_type 3 - 26 load_type 4 - 27 load_var 4 (m) - 28 load_const 8 ("params") - - 18 29 load_var 6 (_11) - - 19 30 call 37 ntypeargs=2 (baml.Map.set) - 31 pop 1 - - 21 32 load_type 7 - 33 load_var 4 (m) - 34 call 355 ntypeargs=1 (baml.json.to_json) - 35 call 351 ntypeargs=0 (baml.json.stringify) - 36 return -} - -function ai.prompt(body: ((string) -> ai.Role throws never, ai.Context) -> baml.TaggedString throws never) -> (ai.Context) -> ai.Prompt throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 84 3 load_var 1 (body) - 4 make_closure 2112 1 - 5 return -} - -function ai.stream.Stream.final(self: ai.stream.Stream<#0, #1>) -> #1 { - 374 0 load_var 1 (self) - 1 load_field 3 (_finished) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +9 (to 13) - - 384 5 load_var 1 (self) - 6 load_field 2 (_text) - 7 load_var 1 (self) - 8 load_field 1 (_cache) - 9 load_type 0 - 10 load_type 1 - 11 sys_op 443 (baml.sap.__parse_final) - 12 return - - 375 13 load_var 1 (self) - 14 load_field 0 (_next_text) - 15 call_indirect - 16 store_var 2 (_4) - 17 load_var 2 (_4) - 18 load_const 2 (null) - 19 cmp_op == - 20 pop_jump_if_false +2 (to 22) - 21 jump +7 (to 28) - - 380 22 load_var2 1 1 - 23 load_field 2 (_text) - - 375 24 load_var 2 (_4) - 25 bin_op + - 26 store_field 2 (_text) - 27 jump -27 (to 0) - - 377 28 load_var 1 (self) - 29 load_const 3 (true) - 30 store_field 3 (_finished) - - 375 31 jump -31 (to 0) -} - -function ai.stream.Stream.next(self: ai.stream.Stream<#0, #1>) -> #0 | ai.stream.Done { - 348 0 load_const 0 (true) - 1 pop_jump_if_false +2 (to 3) - 2 jump +4 (to 6) - - 369 3 load_const 1 ("unreachable") - 4 call 277 ntypeargs=0 (baml.sys.panic) - 5 jump +39 (to 44) - - 349 6 load_var 1 (self) - 7 load_field 3 (_finished) - 8 pop_jump_if_false +2 (to 10) - 9 jump +34 (to 43) - - 352 10 load_var 1 (self) - 11 load_field 0 (_next_text) - 12 call_indirect - 13 store_var 2 (_3) - 14 load_var 2 (_3) - 15 load_const 2 (null) - 16 cmp_op == - 17 pop_jump_if_false +2 (to 19) - 18 jump +20 (to 38) - - 358 19 load_var2 1 1 - 20 load_field 2 (_text) - - 352 21 load_var 2 (_3) - 22 bin_op + - 23 store_field 2 (_text) - - 359 24 load_var 1 (self) - 25 load_field 2 (_text) - 26 load_var 1 (self) - 27 load_field 1 (_cache) - 28 load_type 3 - 29 load_type 4 - 30 sys_op 444 (baml.sap.__parse_partial) - 31 store_var 3 (parsed) - - 360 32 load_var 3 (parsed) - 33 is_type 5 - 34 pop_jump_if_false +2 (to 36) - 35 jump -35 (to 0) - 36 load_var 3 (parsed) - - 363 37 jump +7 (to 44) - - 354 38 load_var 1 (self) - 39 load_const 0 (true) - 40 store_field 3 (_finished) - - 355 41 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 42 jump +2 (to 44) - - 350 43 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 44 return -} - -function ai.stream.TurnStream._check_terminal(self: ai.stream.TurnStream) -> void { - 202 0 load_var 1 (self) - 1 load_field 11 (_require_terminal) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - 7 load_const 1 (null) - 8 jump +9 (to 17) - 9 load_var 2 (_3) - 10 store_var 3 (provider) - - 203 11 load_var 1 (self) - 12 load_field 12 (_saw_terminal) - 13 unary_op ! - 14 pop_jump_if_false +2 (to 16) - 15 jump +3 (to 18) - 16 load_const 1 (null) - 17 return - - 204 18 load_var 1 (self) - 19 load_field 6 (_text) - 20 load_const 2 ("") - 21 cmp_op == - 22 pop_jump_if_false +2 (to 24) - 23 jump +5 (to 28) - - 207 24 load_var 1 (self) - 25 load_field 6 (_text) - 26 store_var 4 (partial) - - 204 27 jump +3 (to 30) - - 205 28 load_const 1 (null) - 29 store_var 4 (partial) - - 211 30 load_var 1 (self) - 31 load_field 6 (_text) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 store_var 6 (_15) - 34 load_type 3 - 35 load_var 6 (_15) - 36 call 138 ntypeargs=1 (baml.String.from) - 37 store_var 5 (_14) - - 210 38 load_var 3 (provider) - - 211 39 load_const 4 ("stream ended before the provider's terminal event: the connection closed after ") - 40 load_var 5 (_14) - 41 bin_op + - 42 load_const 5 (" characters of assistant text with no end-of-turn event, so the turn is truncated") - 43 bin_op + - - 212 44 load_var 4 (partial) - 45 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 46 throw -} - -function ai.stream.TurnStream._finish(self: ai.stream.TurnStream) -> void { - 191 0 load_var 1 (self) - 1 load_const 0 (true) - 2 store_field 10 (_done) - - 192 3 load_var 1 (self) - 4 load_field 0 (_sse) - 5 store_var 2 (_3) - 6 load_var 2 (_3) - 7 narrow_bind 1 2 - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - 10 load_const 2 (null) - 11 jump +5 (to 16) - 12 load_var 2 (_3) - 13 sys_op 246 (baml.http.SseStream.close) - 14 pop 1 - 15 load_const 2 (null) - 16 return -} - -function ai.stream.TurnStream.final_turn(self: ai.stream.TurnStream) -> ai.ModelTurn { - 307 0 load_const 0 (true) - 1 pop_jump_if_false +7 (to 8) - - 308 2 load_var 1 (self) - 3 call 963 ntypeargs=0 (ai.stream.TurnStream.next) - 4 store_var 2 (_3) - 5 load_var 2 (_3) - 6 narrow_bind 1 2 - 7 pop_jump_if_false -7 (to 0) - - 318 8 load_var 1 (self) - 9 call 962 ntypeargs=0 (ai.stream.TurnStream._check_terminal) - 10 pop 1 - - 319 11 load_var 1 (self) - 12 load_field 8 (_input_tokens) - 13 load_const 2 (null) - 14 call 672 ntypeargs=0 (baml.ops.equals_equals) - 15 unary_op ! - 16 jump_if_false +2 (to 18) - 17 jump +7 (to 24) - 18 pop 1 - 19 load_var 1 (self) - 20 load_field 9 (_output_tokens) - 21 load_const 2 (null) - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - 23 unary_op ! - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - - 327 26 load_const 2 (null) - 27 store_var 3 (usage) - - 319 28 jump +24 (to 52) - - 321 29 load_var 1 (self) - 30 load_field 8 (_input_tokens) - 31 store_var_load_var 5 (_13) - 32 load_const 2 (null) - 33 cmp_op == - 34 pop_jump_if_false +3 (to 37) - 35 load_const 3 (0) - 36 store_var 5 (_13) - 37 load_var 5 (_13) - 38 store_var 4 (_12) - - 322 39 load_var 1 (self) - 40 load_field 9 (_output_tokens) - 41 store_var_load_var 6 (_17) - 42 load_const 2 (null) - 43 cmp_op == - 44 pop_jump_if_false +3 (to 47) - 45 load_const 3 (0) - 46 store_var 6 (_17) - - 320 47 load_var2 4 6 - - 322 48 load_const 2 (null) - 49 load_const 2 (null) - 50 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 51 store_var 3 (usage) - - 331 52 load_var 1 (self) - 53 load_field 7 (_stop_reason) - 54 store_var_load_var 7 (_24) - 55 load_const 2 (null) - 56 cmp_op == - 57 pop_jump_if_false +4 (to 61) - 58 load_const 3 (ai.content.StopReason.Complete) - 59 alloc_variant 774 (ai.content.StopReason) - 60 store_var 7 (_24) - - 330 61 load_var 1 (self) - 62 load_field 6 (_text) - 63 init_instance 1 (ai.content.Text .text) - 64 load_type 4 - 65 alloc_array 1 - - 331 66 load_var2 7 3 - - 332 67 init_instance 2 (ai.ModelTurn .content, .stop_reason, .usage) - 68 return -} - -function ai.stream.TurnStream.from_chunks(chunks: string[]) -> ai.stream.TurnStream { - 173 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_var 1 (chunks) - 3 load_const 1 (0) - - 178 4 load_type 2 - 5 alloc_array 0 - 6 load_const 1 (0) - 7 load_const 3 ("") - 8 load_const 0 (null) - 9 load_const 0 (null) - 10 load_const 0 (null) - 11 load_const 4 (false) - 12 load_const 0 (null) - 13 load_const 4 (false) - 14 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal) - 15 return -} - -function ai.stream.TurnStream.from_sse(sse: baml.http.SseStream, decode: (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown, require_terminal: string | null) -> ai.stream.TurnStream { - 0 load_var 3 (require_terminal) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 149 4 load_const 1 (null) - 5 store_var 3 (require_terminal) - - 151 6 load_var2 1 2 - - 154 7 load_type 2 - 8 alloc_array 0 - 9 load_const 3 (0) - - 156 10 load_type 4 - 11 alloc_array 0 - 12 load_const 3 (0) - 13 load_const 5 ("") - 14 load_const 1 (null) - 15 load_const 1 (null) - 16 load_const 1 (null) - 17 load_const 6 (false) - 18 load_var 3 (require_terminal) - 19 load_const 6 (false) - 20 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal) - 21 return -} - -function ai.stream.TurnStream.next(self: ai.stream.TurnStream) -> string | ai.stream.Done { - 221 0 load_const 0 (true) - 1 pop_jump_if_false +2 (to 3) - 2 jump +4 (to 6) - - 296 3 load_const 1 ("unreachable") - 4 call 277 ntypeargs=0 (baml.sys.panic) - 5 jump +190 (to 195) - - 222 6 load_var 1 (self) - 7 load_field 10 (_done) - 8 pop_jump_if_false +2 (to 10) - 9 jump +185 (to 194) - - 226 10 load_var 1 (self) - 11 load_field 5 (_pcursor) - 12 store_var 2 (_4) - 13 load_var 1 (self) - 14 load_field 4 (_pending) - 15 container_len - 16 store_var 3 (_5) - 17 load_var2 2 3 - 18 cmp_int_op < - 19 pop_jump_if_false +2 (to 21) - 20 jump +91 (to 111) - - 255 21 load_var 1 (self) - 22 load_field 0 (_sse) - 23 store_var 15 (_33) - 24 load_var 15 (_33) - 25 narrow_bind 2 15 - 26 pop_jump_if_false +2 (to 28) - 27 jump +40 (to 67) - - 282 28 load_type 3 - 29 load_var 1 (self) - 30 load_field 2 (_chunks) - 31 load_var 1 (self) - 32 load_field 3 (_cursor) - 33 call 3 ntypeargs=1 (baml.Array.at) - 34 store_var 20 (_59) - 35 load_var 20 (_59) - 36 narrow_bind 4 20 - 37 pop_jump_if_false +2 (to 39) - 38 jump +6 (to 44) - - 289 39 load_var 1 (self) - 40 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 41 pop 1 - - 290 42 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 43 jump +152 (to 195) - - 282 44 load_var 20 (_59) - 45 store_var 21 (c) - - 284 46 load_var 1 (self) - 47 copy 0 - 48 load_field 3 (_cursor) - 49 load_const 4 (1) - 50 bin_op + - 51 store_field 3 (_cursor) - - 285 52 load_type 3 - 53 load_var 1 (self) - 54 load_field 6 (_text) - 55 call 138 ntypeargs=1 (baml.String.from) - 56 store_var 22 (_61) - 57 load_type 3 - 58 load_var 21 (c) - 59 call 138 ntypeargs=1 (baml.String.from) - 60 store_var 23 (_64) - 61 load_var2 1 22 - 62 load_var 23 (_64) - 63 bin_op + - 64 store_field 6 (_text) - - 286 65 load_var 21 (c) - 66 jump +129 (to 195) - - 255 67 load_var 15 (_33) - 68 sys_op 245 (baml.http.SseStream.next) - 69 store_var 16 (_35) - - 257 70 load_var 16 (_35) - 71 load_const 5 (null) - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +29 (to 103) - - 267 75 load_var 1 (self) - 76 load_field 1 (_decode) - 77 store_var 17 (_41) - 78 load_var 17 (_41) - 79 narrow_bind 6 17 - 80 pop_jump_if_false -80 (to 0) - - 257 81 load_var2 16 17 - - 268 82 call_indirect - 83 load_type 7 - 84 load_const 8 ("iter") - 85 virtual_call nargs=1 ntypeargs=0 - 86 store_var 18 (_46) - 87 load_var 18 (_46) - 88 load_type 9 - 89 load_const 10 ("next") - 90 virtual_call nargs=1 ntypeargs=0 - 91 store_var 19 (_47) - 92 load_var 19 (_47) - 93 is_type 11 - 94 pop_jump_if_false +2 (to 96) - 95 jump -95 (to 0) - - 269 96 load_type 12 - 97 load_var 1 (self) - 98 load_field 4 (_pending) - - 268 99 load_var 19 (_47) - - 269 100 call 4 ntypeargs=1 (baml.Array.push) - 101 pop 1 - 102 jump -15 (to 87) - - 262 103 load_var 1 (self) - 104 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 105 pop 1 - - 263 106 load_var 1 (self) - 107 call 962 ntypeargs=0 (ai.stream.TurnStream._check_terminal) - 108 pop 1 - - 264 109 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 110 jump +85 (to 195) - - 227 111 load_type 12 - 112 load_var 1 (self) - 113 load_field 4 (_pending) - 114 load_var 1 (self) - 115 load_field 5 (_pcursor) - 116 call 3 ntypeargs=1 (baml.Array.at) - 117 store_var 4 (e) - - 228 118 load_var 1 (self) - 119 copy 0 - 120 load_field 5 (_pcursor) - 121 load_const 4 (1) - 122 bin_op + - 123 store_field 5 (_pcursor) - - 229 124 load_var 4 (e) - 125 store_var 5 (_11) - 126 load_var 5 (_11) - 127 narrow_bind 13 5 - 128 pop_jump_if_false +2 (to 130) - 129 jump +46 (to 175) - 130 load_var 4 (e) - 131 store_var 9 (_19) - 132 load_var 9 (_19) - 133 narrow_bind 14 9 - 134 pop_jump_if_false +2 (to 136) - 135 jump +14 (to 149) - 136 load_var 4 (e) - 137 store_var 14 (_30) - 138 load_var 14 (_30) - 139 narrow_bind 15 14 - 140 pop_jump_if_false -140 (to 0) - - 247 141 load_var 1 (self) - 142 load_const 0 (true) - 143 store_field 12 (_saw_terminal) - - 248 144 load_var 1 (self) - 145 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 146 pop 1 - - 249 147 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 148 jump +47 (to 195) - - 229 149 load_var 9 (_19) - 150 store_var_load_var 10 (m) - - 235 151 load_field 0 (stop_reason) - 152 store_var 11 (_22) - 153 load_var 11 (_22) - 154 narrow_bind 16 11 - 155 pop_jump_if_false +3 (to 158) - - 236 156 load_var2 1 11 - - 235 157 store_field 7 (_stop_reason) - - 238 158 load_var 10 (m) - 159 load_field 1 (input_tokens) - 160 store_var 12 (_25) - 161 load_var 12 (_25) - 162 narrow_bind 17 12 - 163 pop_jump_if_false +3 (to 166) - - 239 164 load_var2 1 12 - - 238 165 store_field 8 (_input_tokens) - - 241 166 load_var 10 (m) - 167 load_field 2 (output_tokens) - 168 store_var 13 (_28) - 169 load_var 13 (_28) - 170 narrow_bind 17 13 - 171 pop_jump_if_false -171 (to 0) - - 242 172 load_var2 1 13 - - 241 173 store_field 9 (_output_tokens) - 174 jump -174 (to 0) - - 229 175 load_var 5 (_11) - 176 store_var 6 (d) - - 231 177 load_type 3 - 178 load_var 1 (self) - 179 load_field 6 (_text) - 180 call 138 ntypeargs=1 (baml.String.from) - 181 store_var 7 (_13) - 182 load_type 3 - 183 load_var 6 (d) - 184 load_field 0 (text) - 185 call 138 ntypeargs=1 (baml.String.from) - 186 store_var 8 (_16) - 187 load_var2 1 7 - 188 load_var 8 (_16) - 189 bin_op + - 190 store_field 6 (_text) - - 232 191 load_var 6 (d) - 192 load_field 0 (text) - 193 jump +2 (to 195) - - 223 194 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 195 return -} - -function ai.stream.decode_sse_batch(batch: string) -> ai.stream.SseEvent[] { - 63 0 load_type 0 - 1 load_var 1 (batch) - 2 call 357 ntypeargs=1 (baml.json.from_string) - 3 return -} - -function ai.stream.from_spec(spec: ai.FunctionSpec<#1>, client: ai.stream.StreamingClient | null) -> ai.stream.Stream<#0, #1> { - 0 load_var 10 - 1 make_cell - 2 store_var 10 - 3 load_var 2 (client) - 4 load_const 0 () - 5 cmp_op == - 6 pop_jump_if_false +3 (to 9) - - 400 7 load_const 1 (null) - 8 store_var 2 (client) - - 402 9 load_type 2 - 10 load_var 1 (spec) - 11 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 12 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 13 unary_op ! - 14 pop_jump_if_false +2 (to 16) - 15 jump +71 (to 86) - - 407 16 load_var 2 (client) - 17 store_var 6 (_16) - 18 load_var 6 (_16) - 19 narrow_bind 3 6 - 20 pop_jump_if_false +2 (to 22) - 21 jump +20 (to 41) - - 410 22 load_var 1 (spec) - 23 load_field 4 (default_client) - 24 store_var 7 (_19) - 25 load_var 7 (_19) - 26 narrow_bind 3 7 - 27 pop_jump_if_false +2 (to 29) - 28 jump +10 (to 38) - - 414 29 load_var 1 (spec) - 30 load_field 4 (default_client) - 31 load_type 4 - 32 load_const 5 ("id") - 33 virtual_call nargs=1 ntypeargs=0 - 34 store_var 8 (_22) - - 413 35 load_var 8 (_22) - 36 init_instance 0 (ai.errors.StreamingUnsupported .client_id) - 37 throw - - 410 38 load_var 7 (_19) - 39 store_var 5 (selected) - 40 jump +3 (to 43) - - 407 41 load_var 6 (_16) - 42 store_var 5 (selected) - - 421 43 load_var 5 (selected) - 44 load_type 4 - 45 load_const 6 ("id") - 46 virtual_call nargs=1 ntypeargs=0 - 47 store_var 9 (provider) - - 426 48 load_var 1 (spec) - 49 load_field 2 (prompt_template) - 50 store_var 11 (_28) - - 427 51 load_type 2 - 52 load_var 1 (spec) - 53 call 906 ntypeargs=1 (ai.Journal.new) - 54 store_var 12 (_29) - - 428 55 load_type 2 - 56 load_var 1 (spec) - 57 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 58 store_var 13 (_31) - - 429 59 load_type 2 - 60 load_var 1 (spec) - 61 call 915 ntypeargs=1 (ai.FunctionSpec.output_type) - 62 store_var 14 (_33) - - 424 63 load_var2 5 11 - - 425 64 load_var2 12 13 - 65 load_var 14 (_33) - 66 init_instance 1 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) - 67 load_type 3 - 68 load_const 7 ("invoke_stream") - 69 virtual_call nargs=2 ntypeargs=0 - 70 store_deref 10 - - 442 71 load_type 8 - 72 load_type 2 - 73 call 442 ntypeargs=2 (baml.sap.__new_parse_cache) - 74 store_var 15 (_36) - - 436 75 load_type 8 - 76 load_type 2 - 77 load_var 10 (turns) - 78 make_closure 2293 captures=1 ntypeargs=2 - 79 load_var 15 (_36) - 80 load_const 9 ("") - 81 load_const 10 (false) - 82 load_type 8 - 83 load_type 2 - 84 init_instance 2 (ai.stream.Stream ._next_text, ._cache, ._text, ._finished) - 85 return - - 404 86 load_type 2 - 87 load_var 1 (spec) - 88 call 913 ntypeargs=1 (ai.FunctionSpec.name) - 89 store_var 4 (_12) - 90 load_type 11 - 91 load_var 4 (_12) - 92 call 138 ntypeargs=1 (baml.String.from) - 93 store_var 3 (_11) - 94 load_const 12 ("streaming does not run the tool loop yet: ") - 95 load_var 3 (_11) - 96 bin_op + - 97 load_const 13 (" has a non-empty toolbox") - 98 bin_op + - 99 init_instance 3 (baml.errors.InvalidArgument .message) - 100 throw -} - -function ai.tools.Tool.call(self: ai.tools.Tool, args: map) -> string { - 26 0 load_var 1 (self) - 1 load_field 4 (raw_handler) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +63 (to 69) - - 29 7 load_var 1 (self) - 8 load_field 3 (handler) - 9 store_var 4 (_8) - 10 load_var 4 (_8) - 11 narrow_bind 1 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +13 (to 26) - - 37 14 load_type 2 - 15 load_var 1 (self) - 16 load_field 0 (name) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 12 (_34) - 19 load_const 3 ("tool ") - 20 load_var 12 (_34) - 21 bin_op + - 22 load_const 4 (" has no handler") - 23 bin_op + - 24 init_instance 0 (baml.errors.InvalidArgument .message) - 25 throw - - 30 26 load_type 5 - 27 load_type 5 - - 29 28 load_var2 4 2 - - 30 29 call 775 ntypeargs=2 (baml.reflect.call_any) - 30 store_var 5 (value) - 31 jump +33 (to 64) - 32 load_var 6 (e) - 33 store_var 7 (_15) - 34 load_var 7 (_15) - 35 narrow_bind 6 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +3 (to 40) - 38 load_var 6 (e) - 39 rethrow - 40 load_var 7 (_15) - 41 store_var 8 (bad) - - 32 42 load_type 2 - 43 load_var 1 (self) - 44 load_field 0 (name) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 9 (_21) - 47 load_type 7 - 48 load_var 8 (bad) - 49 call 138 ntypeargs=1 (baml.String.from) - 50 store_var 11 (_25) - 51 load_type 2 - 52 load_var 11 (_25) - 53 call 138 ntypeargs=1 (baml.String.from) - 54 store_var 10 (_24) - 55 load_const 8 ("invalid arguments for ") - 56 load_var 9 (_21) - 57 bin_op + - 58 load_const 9 (": ") - 59 bin_op + - 60 load_var 10 (_24) - 61 bin_op + - 62 init_instance 1 (baml.errors.InvalidArgument .message) - 63 throw - - 35 64 load_type 5 - 65 load_var 5 (value) - 66 call 355 ntypeargs=1 (baml.json.to_json) - 67 call 351 ntypeargs=0 (baml.json.stringify) - 68 jump +3 (to 71) - - 27 69 load_var2 2 3 - 70 call_indirect - 71 return -} - -function ai.tools.Toolbox.get(self: ai.tools.Toolbox, name: string) -> ai.tools.Tool | null { - 0 load_var 2 - 1 make_cell - 2 store_var 2 - - 112 3 load_type 0 - 4 load_type 1 - 5 load_var 1 (self) - 6 load_field 0 (entries) - 7 load_var 2 (name) - 8 make_closure 2138 1 - 9 call 19 ntypeargs=2 (baml.Array.find) - 10 return -} - -function ai.tools.Toolbox.is_empty(self: ai.tools.Toolbox) -> bool { - 118 0 load_var 1 (self) - 1 load_field 0 (entries) - 2 container_len - 3 store_var 2 (_2) - 4 load_var 2 (_2) - 5 load_const 0 (0) - 6 cmp_int_op == - 7 return -} - -function ai.tools.Toolbox.list(self: ai.tools.Toolbox) -> ai.tools.Tool[] { - 108 0 load_var 1 (self) - 1 load_field 0 (entries) - 2 return -} - -function ai.tools.Toolbox.new(tools: ai.tools.Tool[]) -> ai.tools.Toolbox { - 97 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (names) - - 98 3 load_var 1 (tools) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +25 (to 41) - 17 load_var 4 (_4) - 18 store_var 5 (t) - - 99 19 load_type 0 - 20 load_var2 2 5 - 21 load_field 0 (name) - 22 call 23 ntypeargs=1 (baml.Array.includes) - 23 pop_jump_if_false +2 (to 25) - 24 jump +7 (to 31) - - 102 25 load_type 0 - 26 load_var2 2 5 - 27 load_field 0 (name) - 28 call 4 ntypeargs=1 (baml.Array.push) - 29 pop 1 - 30 jump -22 (to 8) - - 100 31 load_type 0 - 32 load_var 5 (t) - 33 load_field 0 (name) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 6 (_13) - 36 load_const 6 ("duplicate tool name: ") - 37 load_var 6 (_13) - 38 bin_op + - 39 init_instance 0 (baml.errors.InvalidArgument .message) - 40 throw - - 104 41 load_var 1 (tools) - 42 init_instance 1 (ai.tools.Toolbox .entries) - 43 return -} - -function ai.tools.raw_tool(name: string, description: string, input_schema: map, handler: (map) -> string throws unknown, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - 0 load_var 5 (on_error) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 77 4 load_const 1 (null) - 5 store_var 5 (on_error) - - 79 6 load_var 1 (name) - 7 load_const 2 ("__baml_return_output") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +7 (to 17) - - 82 11 load_var2 1 2 - 12 load_var 3 (input_schema) - 13 load_const 1 (null) - 14 load_var2 4 5 - 15 init_instance 0 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) - 16 return - - 80 17 load_const 3 ("the tool name __baml_return_output is reserved") - 18 init_instance 1 (baml.errors.InvalidArgument .message) - 19 throw -} - -function ai.tools.tool(handler: baml.AnyFunction, name: string | null, description: string | null, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - 0 load_var 2 (name) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 45 4 load_const 1 (null) - 5 store_var 2 (name) - 6 load_var 3 (description) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 46 10 load_const 1 (null) - 11 store_var 3 (description) - 12 load_var 4 (on_error) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 47 16 load_const 1 (null) - 17 store_var 4 (on_error) - - 49 18 load_var 1 (handler) - 19 call 774 ntypeargs=0 (baml.reflect.signature) - 20 store_var 5 (sig) - - 50 21 load_var 2 (name) - 22 store_var_load_var 6 (_10) - 23 load_const 1 (null) - 24 cmp_op == - 25 pop_jump_if_false +4 (to 29) - 26 load_var 5 (sig) - 27 load_field 0 (name) - 28 store_var 6 (_10) - 29 load_var 6 (_10) - 30 store_var 7 (_12) - - 51 31 load_var 7 (_12) - 32 narrow_bind 2 7 - 33 pop_jump_if_false +2 (to 35) - 34 jump +4 (to 38) - - 64 35 load_const 3 ("anonymous tool needs a name") - 36 init_instance 0 (baml.errors.InvalidArgument .message) - 37 throw - - 51 38 load_var 7 (_12) - 39 store_var_load_var 8 (n) - - 52 40 load_const 4 ("__baml_return_output") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +27 (to 70) - - 57 44 load_var 3 (description) - 45 store_var_load_var 11 (_21) - 46 load_const 1 (null) - 47 cmp_op == - 48 pop_jump_if_false +4 (to 52) - 49 load_var 5 (sig) - 50 load_field 5 (docstring) - 51 store_var 11 (_21) - 52 load_var 11 (_21) - 53 store_var_load_var 10 (_19) - 54 load_const 1 (null) - 55 cmp_op == - 56 pop_jump_if_false +3 (to 59) - 57 load_const 5 ("") - 58 store_var 10 (_19) - 59 load_var 10 (_19) - 60 store_var 9 (_18) - - 58 61 load_var 1 (handler) - 62 call 978 ntypeargs=0 (ai.internal._schema_for_signature) - 63 store_var 12 (_24) - - 56 64 load_var2 8 9 - 65 load_var2 12 1 - 66 load_const 1 (null) - 67 load_var 4 (on_error) - 68 init_instance 1 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) - 69 return - - 53 70 load_const 6 ("the tool name __baml_return_output is reserved") - 71 init_instance 2 (baml.errors.InvalidArgument .message) - 72 throw -} - -function ai.wire.credential_sources(cred: string | baml.env.Ref | null, canonical_env: string | null) -> string { - 66 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (names) - - 67 3 load_var 1 (cred) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +6 (to 13) - - 68 8 load_type 0 - 9 load_var2 3 4 - - 67 10 load_field 0 (name) - - 68 11 call 4 ntypeargs=1 (baml.Array.push) - 12 pop 1 - - 70 13 load_var 2 (canonical_env) - 14 store_var 5 (_9) - 15 load_var 5 (_9) - 16 narrow_bind 2 5 - 17 pop_jump_if_false +5 (to 22) - - 71 18 load_type 0 - 19 load_var2 3 5 - 20 call 4 ntypeargs=1 (baml.Array.push) - 21 pop 1 - - 73 22 load_var 3 (names) - 23 container_len - 24 store_var 6 (_15) - 25 load_var 6 (_15) - 26 load_const 3 (0) - 27 cmp_int_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +6 (to 35) - - 76 30 load_type 0 - 31 load_var 3 (names) - 32 load_const 4 (", ") - 33 call 15 ntypeargs=1 (baml.Array.join) - 34 jump +2 (to 36) - - 74 35 load_const 5 ("(no environment variable was named)") - 36 return -} - -function ai.wire.merge_request_body(base: baml.json.json, overrides: baml.json.json | null) -> baml.json.json { - 208 0 load_var 2 (overrides) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 210 5 load_var2 1 2 - 6 call 997 ntypeargs=0 (ai.internal._merge_json) - 7 jump +2 (to 9) - - 209 8 load_var 1 (base) - 9 return -} - -function ai.wire.redact_url_secrets(text: string) -> string { - 51 0 load_var 1 (text) - 1 load_const 0 ("key=") - 2 call 995 ntypeargs=0 (ai.internal._redact_after) - - 52 3 load_const 1 ("token=") - 4 call 995 ntypeargs=0 (ai.internal._redact_after) - - 53 5 load_const 2 ("secret=") - 6 call 995 ntypeargs=0 (ai.internal._redact_after) - 7 return -} - -function ai.wire.render_output_format(t: type) -> string { - 115 0 load_var 1 (t) - 1 call 1006 ntypeargs=0 (ai.internal.validate_output_type) - 2 pop 1 - - 116 3 load_var 1 (t) - 4 sys_op 1007 (ai.internal.render_output_format) - 5 return -} - -function ai.wire.resolve_credential(cred: string | baml.env.Ref | null, env_fallback: string | null) -> string | null { - 27 0 load_var 1 (cred) - 1 store_var 3 (_4) - 2 load_var 3 (_4) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +20 (to 25) - 6 load_var 1 (cred) - 7 store_var 4 (_7) - 8 load_var 4 (_7) - 9 narrow_bind 1 4 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 30 12 load_const 2 (null) - - 27 13 jump +14 (to 27) - 14 load_var 4 (_7) - - 29 15 call 228 ntypeargs=0 (baml.env.Ref.get) - 16 store_var_load_var 5 (_10) - 17 load_const 2 (null) - 18 cmp_op == - 19 pop_jump_if_false +3 (to 22) - 20 load_const 3 ("") - 21 store_var 5 (_10) - 22 load_var 5 (_10) - 23 call 994 ntypeargs=0 (ai.internal._configured) - 24 jump +3 (to 27) - - 27 25 load_var 3 (_4) - - 28 26 call 994 ntypeargs=0 (ai.internal._configured) - - 32 27 store_var 6 (_13) - 28 load_var 6 (_13) - 29 narrow_bind 0 6 - 30 pop_jump_if_false +2 (to 32) - 31 jump +20 (to 51) - - 35 32 load_var 2 (env_fallback) - 33 store_var 7 (_15) - 34 load_var 7 (_15) - 35 narrow_bind 0 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +3 (to 40) - - 38 38 load_const 2 (null) - 39 jump +13 (to 52) - - 35 40 load_var 7 (_15) - 41 sys_op 226 (baml.env.get) - - 36 42 store_var_load_var 8 (_18) - 43 load_const 2 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 4 ("") - 47 store_var 8 (_18) - 48 load_var 8 (_18) - 49 call 994 ntypeargs=0 (ai.internal._configured) - 50 jump +2 (to 52) - - 32 51 load_var 6 (_13) - 52 return -} - -function ai.wire.resolve_media(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> ai.wire.ResolvedMedia { - 131 0 load_var 1 (media) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +131 (to 136) - 6 load_var 1 (media) - 7 store_var 12 (_18) - 8 load_var 12 (_18) - 9 narrow_bind 1 12 - 10 pop_jump_if_false +2 (to 12) - 11 jump +85 (to 96) - 12 load_var 1 (media) - 13 store_var 21 (_33) - 14 load_var 21 (_33) - 15 narrow_bind 2 21 - 16 pop_jump_if_false +2 (to 18) - 17 jump +39 (to 56) - - 163 18 load_var 1 (media) - 19 call 323 ntypeargs=0 (baml.media.Pdf.file) - 20 store_var_load_var 32 (_52) - 21 load_const 3 (null) - 22 cmp_op == - 23 pop_jump_if_false +4 (to 27) - 24 load_var 1 (media) - 25 call 322 ntypeargs=0 (baml.media.Pdf.url) - 26 store_var 32 (_52) - 27 load_var 32 (_52) - 28 store_var_load_var 31 (_50) - 29 load_const 3 (null) - 30 cmp_op == - 31 pop_jump_if_false +3 (to 34) - 32 load_const 4 ("") - 33 store_var 31 (_50) - 34 load_var 31 (_50) - 35 store_var 30 (source) - - 165 36 load_var 1 (media) - 37 call 322 ntypeargs=0 (baml.media.Pdf.url) - 38 store_var 33 (_56) - - 166 39 load_var 1 (media) - 40 call 323 ntypeargs=0 (baml.media.Pdf.file) - 41 store_var 34 (_57) - - 167 42 load_var 1 (media) - 43 call 324 ntypeargs=0 (baml.media.Pdf.base64) - 44 store_var 35 (_58) - - 168 45 load_var 1 (media) - 46 call 325 ntypeargs=0 (baml.media.Pdf.mime_type) - 47 load_var 30 (source) - 48 load_const 5 ("pdf") - 49 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 50 store_var 36 (_59) - - 164 51 load_var2 33 34 - 52 load_var2 35 36 - 53 load_var 2 (fetch_url) - 54 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 55 jump +120 (to 175) - - 131 56 load_var 21 (_33) - 57 store_var 22 (video) - - 153 58 load_var 22 (video) - 59 call 337 ntypeargs=0 (baml.media.Video.file) - 60 store_var_load_var 25 (_38) - 61 load_const 3 (null) - 62 cmp_op == - 63 pop_jump_if_false +4 (to 67) - 64 load_var 22 (video) - 65 call 336 ntypeargs=0 (baml.media.Video.url) - 66 store_var 25 (_38) - 67 load_var 25 (_38) - 68 store_var_load_var 24 (_36) - 69 load_const 3 (null) - 70 cmp_op == - 71 pop_jump_if_false +3 (to 74) - 72 load_const 6 ("") - 73 store_var 24 (_36) - 74 load_var 24 (_36) - 75 store_var 23 (source) - - 155 76 load_var 22 (video) - 77 call 336 ntypeargs=0 (baml.media.Video.url) - 78 store_var 26 (_42) - - 156 79 load_var 22 (video) - 80 call 337 ntypeargs=0 (baml.media.Video.file) - 81 store_var 27 (_43) - - 157 82 load_var 22 (video) - 83 call 338 ntypeargs=0 (baml.media.Video.base64) - 84 store_var 28 (_44) - - 158 85 load_var 22 (video) - 86 call 339 ntypeargs=0 (baml.media.Video.mime_type) - 87 load_var 23 (source) - 88 load_const 7 ("video") - 89 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 90 store_var 29 (_45) - - 154 91 load_var2 26 27 - 92 load_var2 28 29 - 93 load_var 2 (fetch_url) - 94 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 95 jump +80 (to 175) - - 131 96 load_var 12 (_18) - 97 store_var 13 (audio) - - 143 98 load_var 13 (audio) - 99 call 330 ntypeargs=0 (baml.media.Audio.file) - 100 store_var_load_var 16 (_23) - 101 load_const 3 (null) - 102 cmp_op == - 103 pop_jump_if_false +4 (to 107) - 104 load_var 13 (audio) - 105 call 329 ntypeargs=0 (baml.media.Audio.url) - 106 store_var 16 (_23) - 107 load_var 16 (_23) - 108 store_var_load_var 15 (_21) - 109 load_const 3 (null) - 110 cmp_op == - 111 pop_jump_if_false +3 (to 114) - 112 load_const 8 ("") - 113 store_var 15 (_21) - 114 load_var 15 (_21) - 115 store_var 14 (source) - - 145 116 load_var 13 (audio) - 117 call 329 ntypeargs=0 (baml.media.Audio.url) - 118 store_var 17 (_27) - - 146 119 load_var 13 (audio) - 120 call 330 ntypeargs=0 (baml.media.Audio.file) - 121 store_var 18 (_28) - - 147 122 load_var 13 (audio) - 123 call 331 ntypeargs=0 (baml.media.Audio.base64) - 124 store_var 19 (_29) - - 148 125 load_var 13 (audio) - 126 call 332 ntypeargs=0 (baml.media.Audio.mime_type) - 127 load_var 14 (source) - 128 load_const 9 ("audio") - 129 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 130 store_var 20 (_30) - - 144 131 load_var2 17 18 - 132 load_var2 19 20 - 133 load_var 2 (fetch_url) - 134 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 135 jump +40 (to 175) - - 131 136 load_var 3 (_3) - 137 store_var 4 (image) - - 133 138 load_var 4 (image) - 139 call 344 ntypeargs=0 (baml.media.Image.file) - 140 store_var_load_var 7 (_8) - 141 load_const 3 (null) - 142 cmp_op == - 143 pop_jump_if_false +4 (to 147) - 144 load_var 4 (image) - 145 call 343 ntypeargs=0 (baml.media.Image.url) - 146 store_var 7 (_8) - 147 load_var 7 (_8) - 148 store_var_load_var 6 (_6) - 149 load_const 3 (null) - 150 cmp_op == - 151 pop_jump_if_false +3 (to 154) - 152 load_const 10 ("") - 153 store_var 6 (_6) - 154 load_var 6 (_6) - 155 store_var 5 (source) - - 135 156 load_var 4 (image) - 157 call 343 ntypeargs=0 (baml.media.Image.url) - 158 store_var 8 (_12) - - 136 159 load_var 4 (image) - 160 call 344 ntypeargs=0 (baml.media.Image.file) - 161 store_var 9 (_13) - - 137 162 load_var 4 (image) - 163 call 345 ntypeargs=0 (baml.media.Image.base64) - 164 store_var 10 (_14) - - 138 165 load_var 4 (image) - 166 call 346 ntypeargs=0 (baml.media.Image.mime_type) - 167 load_var 5 (source) - 168 load_const 11 ("image") - 169 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 170 store_var 11 (_15) - - 134 171 load_var2 8 9 - 172 load_var2 10 11 - 173 load_var 2 (fetch_url) - 174 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 175 return -} - -function ai.wire.sanitize_for_client(j: ai.Journal, client_id: string) -> ai.Journal { - 268 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 270 3 load_type 1 - 4 alloc_array 0 - 5 store_var 4 (pending) - - 271 6 load_var 1 (j) - 7 call 905 ntypeargs=0 (ai.Journal.entries) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_6) - 12 load_var 5 (_6) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_7) - 17 load_var 6 (_7) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +116 (to 136) - 21 load_var 6 (_7) - 22 store_var 7 (event) - - 272 23 load_var 7 (event) - 24 store_var 8 (_11) - 25 load_var 8 (_11) - 26 narrow_bind 7 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +56 (to 84) - 29 load_var 7 (event) - 30 store_var 15 (_38) - 31 load_var 15 (_38) - 32 narrow_bind 8 15 - 33 pop_jump_if_false +2 (to 35) - 34 jump +40 (to 74) - 35 load_var 7 (event) - 36 store_var 17 (_46) - 37 load_var 17 (_46) - 38 narrow_bind 9 17 - 39 pop_jump_if_false +2 (to 41) - 40 jump +23 (to 63) - 41 load_var 7 (event) - 42 store_var 19 (_54) - 43 load_var 19 (_54) - 44 narrow_bind 10 19 - 45 pop_jump_if_false +2 (to 47) - 46 jump +6 (to 52) - - 310 47 load_type 0 - 48 load_var2 3 7 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -39 (to 12) - - 272 52 load_var 19 (_54) - 53 store_var 20 (failed) - - 305 54 load_var2 4 20 - 55 load_field 0 (id) - 56 call 1000 ntypeargs=0 (ai.internal._resolve_pending_call) - 57 pop 1 - - 306 58 load_type 0 - 59 load_var2 3 20 - 60 call 4 ntypeargs=1 (baml.Array.push) - 61 pop 1 - 62 jump -50 (to 12) - - 272 63 load_var 17 (_46) - 64 store_var 18 (completed) - - 300 65 load_var2 4 18 - 66 load_field 0 (id) - 67 call 1000 ntypeargs=0 (ai.internal._resolve_pending_call) - 68 pop 1 - - 301 69 load_type 0 - 70 load_var2 3 18 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -61 (to 12) - - 272 74 load_var 15 (_38) - 75 store_var 16 (user) - - 295 76 load_var2 3 4 - 77 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 78 pop 1 - - 296 79 load_type 0 - 80 load_var2 3 16 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -71 (to 12) - - 272 84 load_var 8 (_11) - 85 store_var 9 (assistant) - - 274 86 load_var2 3 4 - 87 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 88 pop 1 - - 275 89 load_var 9 (assistant) - 90 load_field 0 (content) - 91 load_var 9 (assistant) - 92 load_field 1 (client_id) - 93 load_var 2 (client_id) - 94 cmp_op == - 95 call 998 ntypeargs=0 (ai.internal._wire_blocks) - 96 store_var 10 (blocks) - - 276 97 load_var 10 (blocks) - 98 container_len - 99 store_var 11 (_21) - 100 load_var 11 (_21) - 101 load_const 11 (0) - 102 cmp_int_op > - 103 pop_jump_if_false -91 (to 12) - - 277 104 load_type 0 - 105 load_var2 3 10 - - 280 106 load_var 9 (assistant) - 107 load_field 1 (client_id) - 108 init_instance 0 (ai.events.AssistantMessage .content, .client_id) - - 277 109 call 4 ntypeargs=1 (baml.Array.push) - 110 pop 1 - - 283 111 load_var 10 (blocks) - 112 load_type 12 - 113 load_const 13 ("iter") - 114 virtual_call nargs=1 ntypeargs=0 - 115 store_var 12 (_28) - 116 load_var 12 (_28) - 117 load_type 14 - 118 load_const 15 ("next") - 119 virtual_call nargs=1 ntypeargs=0 - 120 store_var 13 (_29) - 121 load_var 13 (_29) - 122 is_type 6 - 123 pop_jump_if_false +2 (to 125) - 124 jump -112 (to 12) - 125 load_var 13 (_29) - 126 store_var 14 (_33) - - 284 127 load_var 14 (_33) - 128 narrow_bind 16 14 - 129 pop_jump_if_false -13 (to 116) - - 285 130 load_type 1 - 131 load_var2 4 14 - - 284 132 load_field 0 (id) - - 285 133 call 4 ntypeargs=1 (baml.Array.push) - 134 pop 1 - 135 jump -19 (to 116) - - 315 136 load_var2 3 4 - 137 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 138 pop 1 - - 316 139 load_var 3 (out) - 140 init_instance 1 (ai.Journal .log) - 141 return -} - -function ai.wire.send_as(req: baml.http.Request, provider: string) -> #0 { - 83 0 load_var 1 (req) - 1 load_const 0 () - 2 call 250 ntypeargs=0 (baml.http.send) - 3 store_var 3 (resp) - 4 jump +19 (to 23) - 5 load_var 4 (e) - 6 throw_if_panic - - 89 7 load_type 1 - 8 load_var 4 (e) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 call 929 ntypeargs=0 (ai.wire.redact_url_secrets) - 11 store_var 6 (_8) - 12 load_type 2 - 13 load_var 6 (_8) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 5 (_7) - - 85 16 load_var 2 (provider) - - 89 17 load_const 3 ("transport failed before a response arrived: ") - 18 load_var 5 (_7) - 19 bin_op + - 20 load_const 4 (null) - 21 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 22 throw - - 94 23 load_var 3 (resp) - 24 sys_op 238 (baml.http.Response.text) - 25 store_var 7 (text) - 26 jump +8 (to 34) - 27 load_var 8 (e) - 28 throw_if_panic - - 96 29 load_var 2 (provider) - 30 load_const 5 ("the response body could not be read completely") - 31 load_const 4 (null) - 32 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 33 throw - - 103 34 load_var 3 (resp) - 35 call 240 ntypeargs=0 (baml.http.Response.ok) - 36 unary_op ! - 37 pop_jump_if_false +2 (to 39) - 38 jump +11 (to 49) - - 107 39 load_type 6 - 40 load_var 7 (text) - 41 call 357 ntypeargs=1 (baml.json.from_string) - 42 jump +6 (to 48) - 43 load_var 9 (e) - 44 throw_if_panic - - 108 45 load_var2 2 7 - 46 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 47 throw - 48 return - - 105 49 load_var2 2 3 - 50 load_field 0 (status_code) - 51 load_var2 7 3 - 52 load_field 1 (headers) - 53 call 977 ntypeargs=0 (ai.errors.classify_http) - 54 throw -} - -function anthropic.AnthropicClient.ai.Client.id(self: anthropic.AnthropicClient) -> string { - 158 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("anthropic/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function anthropic.AnthropicClient.ai.Client.invoke(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 162 0 load_var2 1 2 - 1 call 1192 ntypeargs=0 (anthropic.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 163 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function anthropic.AnthropicClient.ai.stream.StreamingClient.invoke_stream(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 170 0 load_var2 1 2 - 1 call 1199 ntypeargs=0 (anthropic.internal.invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 171 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function anthropic.AnthropicClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, max_tokens: int, temperature: float | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, thinking: anthropic.ThinkingConfig | null, tool_choice: anthropic.ToolChoice | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> anthropic.AnthropicClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 103 4 load_const 1 ("claude-haiku-4-5") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 104 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 105 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (max_tokens) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 106 22 load_const 3 (8192) - 23 store_var 4 (max_tokens) - 24 load_var 5 (temperature) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 107 28 load_const 2 (null) - 29 store_var 5 (temperature) - 30 load_var 6 (top_p) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 108 34 load_const 2 (null) - 35 store_var 6 (top_p) - 36 load_var 7 (top_k) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 109 40 load_const 2 (null) - 41 store_var 7 (top_k) - 42 load_var 8 (stop_sequences) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 110 46 load_const 2 (null) - 47 store_var 8 (stop_sequences) - 48 load_var 9 (thinking) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 111 52 load_const 2 (null) - 53 store_var 9 (thinking) - 54 load_var 10 (tool_choice) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 112 58 load_const 2 (null) - 59 store_var 10 (tool_choice) - 60 load_var 11 (request_body) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 113 64 load_const 2 (null) - 65 store_var 11 (request_body) - 66 load_var 12 (headers) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 114 70 load_const 2 (null) - 71 store_var 12 (headers) - 72 load_var 13 (query_params) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 115 76 load_const 2 (null) - 77 store_var 13 (query_params) - - 117 78 load_var2 1 2 - 79 load_var2 3 4 - 80 load_var2 5 6 - 81 load_var2 7 8 - 82 load_var2 9 10 - 83 load_var2 11 12 - 84 load_var 13 (query_params) - 85 init_instance 0 (anthropic.AnthropicClient .model, .api_key, .base_url, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .headers, .query_params) - 86 return -} - -function anthropic.AnthropicClient.resolved_api_key(self: anthropic.AnthropicClient) -> string { - 143 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("ANTHROPIC_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +15 (to 23) - - 147 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("ANTHROPIC_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 3 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - 18 load_const 4 ("anthropic needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 19 load_var 3 (_8) - 20 bin_op + - - 146 21 call 1168 ntypeargs=0 (anthropic.internal._reject) - 22 throw - - 143 23 load_var 2 (_4) - 24 return -} - -function anthropic.AnthropicClient.resolved_base_url(self: anthropic.AnthropicClient) -> string | null { - 153 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function anthropic.ThinkingConfig.disabled() -> anthropic.ThinkingConfig { - 23 0 load_const 0 ("disabled") - 1 load_const 1 (null) - 2 init_instance 0 (anthropic.ThinkingConfig .type, .budget_tokens) - 3 return -} - -function anthropic.ThinkingConfig.enabled(budget_tokens: int) -> anthropic.ThinkingConfig { - 19 0 load_const 0 ("enabled") - 1 load_var 1 (budget_tokens) - 2 init_instance 0 (anthropic.ThinkingConfig .type, .budget_tokens) - 3 return -} - -function anthropic.ToolChoice.any(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 1 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 44 4 load_const 1 (null) - 5 store_var 1 (disable_parallel_tool_use) - - 46 6 load_const 2 ("any") - 7 load_const 1 (null) - - 45 8 load_var 1 (disable_parallel_tool_use) - 9 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 10 return -} - -function anthropic.ToolChoice.auto(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 1 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 38 4 load_const 1 (null) - 5 store_var 1 (disable_parallel_tool_use) - - 40 6 load_const 2 ("auto") - 7 load_const 1 (null) - - 39 8 load_var 1 (disable_parallel_tool_use) - 9 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 10 return -} - -function anthropic.ToolChoice.none() -> anthropic.ToolChoice { - 57 0 load_const 0 ("none") - 1 load_const 1 (null) - 2 load_const 1 (null) - 3 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 4 return -} - -function anthropic.ToolChoice.tool(name: string, disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 2 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 50 4 load_const 1 (null) - 5 store_var 2 (disable_parallel_tool_use) - - 52 6 load_const 2 ("tool") - 7 load_var2 1 2 - 8 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 9 return -} - -function anthropic.internal.AnthStreamState.new() -> anthropic.internal.AnthStreamState { - 958 0 load_const 0 ("") - 1 load_const 1 ("") - - 961 2 load_type 2 - 3 alloc_array 0 - 4 load_const 3 (null) - 5 load_const 3 (null) - 6 load_const 3 (null) - 7 load_const 3 (null) - 8 load_const 3 (null) - 9 init_instance 0 (anthropic.internal.AnthStreamState .thinking, .signature, .tool_calls, .cache_read_input_tokens, .cache_creation_input_tokens, .reasoning_tokens, .stop_reason_raw, .model) - 10 return -} - -function anthropic.internal.AnthStreamState.tool_uses(self: anthropic.internal.AnthStreamState) -> ai.content.ToolUse[] { - 974 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 975 3 load_var 1 (self) - 4 load_field 2 (tool_calls) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +37 (to 54) - 18 load_var 4 (_5) - 19 store_var 5 (call) - - 976 20 load_type 6 - 21 load_type 7 - 22 alloc_map 0 - 23 store_var 6 (empty) - - 977 24 load_var 5 (call) - 25 load_field 3 (args_json) - 26 call 144 ntypeargs=0 (baml.String.trim) - 27 load_const 8 ("") - 28 cmp_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +12 (to 42) - - 980 31 load_type 9 - 32 load_var 5 (call) - 33 load_field 3 (args_json) - 34 call 357 ntypeargs=1 (baml.json.from_string) - 35 store_var 7 (args) - 36 jump +8 (to 44) - 37 load_var 8 (e) - 38 throw_if_panic - - 981 39 load_var 6 (empty) - 40 store_var 7 (args) - - 980 41 jump +3 (to 44) - - 978 42 load_var 6 (empty) - 43 store_var 7 (args) - - 984 44 load_type 0 - 45 load_var2 2 5 - 46 load_field 1 (id) - 47 load_var 5 (call) - 48 load_field 2 (name) - 49 load_var 7 (args) - 50 init_instance 0 (ai.content.ToolUse .id, .name, .args) - 51 call 4 ntypeargs=1 (baml.Array.push) - 52 pop 1 - 53 jump -44 (to 9) - - 986 54 load_var 2 (out) - 55 return -} - -function anthropic.internal._anth_apply_cache_control(blocks: (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[], cache_control: baml.json.json | null) -> void { - 269 0 load_var 2 (cache_control) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +56 (to 60) - - 272 5 load_var 1 (blocks) - 6 container_len - 7 store_var 3 (_6) - 8 load_type 1 - 9 load_var2 1 3 - 10 load_const 2 (1) - 11 sub_int - 12 call 3 ntypeargs=1 (baml.Array.at) - 13 store_var 4 (_8) - 14 load_var 4 (_8) - 15 narrow_bind 3 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +12 (to 29) - 18 load_var 4 (_8) - 19 narrow_bind 4 4 - 20 pop_jump_if_false +2 (to 22) - 21 jump +8 (to 29) - 22 load_var 4 (_8) - 23 narrow_bind 5 4 - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - 26 load_var 4 (_8) - 27 narrow_bind 6 4 - 28 pop_jump_if_false +32 (to 60) - 29 load_var 4 (_8) - 30 store_var 5 (last) - - 273 31 load_var 5 (last) - 32 store_var 6 (_10) - 33 load_var 6 (_10) - 34 narrow_bind 3 6 - 35 pop_jump_if_false +2 (to 37) - 36 jump +22 (to 58) - 37 load_var 5 (last) - 38 store_var 7 (_12) - 39 load_var 7 (_12) - 40 narrow_bind 4 7 - 41 pop_jump_if_false +2 (to 43) - 42 jump +13 (to 55) - 43 load_var 5 (last) - 44 store_var 8 (_14) - 45 load_var 8 (_14) - 46 narrow_bind 5 8 - 47 pop_jump_if_false +2 (to 49) - 48 jump +4 (to 52) - 49 load_var2 5 2 - 50 store_field 4 (cache_control) - 51 jump +9 (to 60) - 52 load_var2 8 2 - 53 store_field 4 (cache_control) - 54 jump +6 (to 60) - 55 load_var2 7 2 - 56 store_field 2 (cache_control) - 57 jump +3 (to 60) - 58 load_var2 6 2 - 59 store_field 2 (cache_control) - - 268 60 load_const 0 (null) - 61 return -} - -function anthropic.internal._anth_drop_nulls(j: baml.json.json) -> baml.json.json { - 214 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +36 (to 41) - 6 load_var 1 (j) - 7 store_var 10 (_27) - 8 load_var 10 (_27) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 241 12 load_var 1 (j) - - 214 13 jump +81 (to 94) - - 235 14 load_type 2 - 15 alloc_array 0 - 16 store_var 11 (out) - - 214 17 load_var 10 (_27) - 18 load_type 3 - 19 load_const 4 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 12 (_31) - - 236 22 load_var 12 (_31) - 23 load_type 5 - 24 load_const 6 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 13 (_32) - 27 load_var 13 (_32) - 28 is_type 7 - 29 pop_jump_if_false +2 (to 31) - 30 jump +9 (to 39) - 31 load_var 13 (_32) - - 237 32 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - 33 store_var 14 (_37) - 34 load_type 2 - 35 load_var2 11 14 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -16 (to 22) - - 239 39 load_var 11 (out) - - 214 40 jump +54 (to 94) - 41 load_var 2 (_2) - 42 store_var 3 (obj) - - 216 43 load_type 8 - 44 load_type 2 - 45 alloc_map 0 - 46 store_var 4 (out) - - 217 47 load_type 8 - 48 load_type 2 - 49 load_var 3 (obj) - 50 call 35 ntypeargs=2 (baml.Map.keys) - 51 load_type 9 - 52 load_const 10 ("iter") - 53 virtual_call nargs=1 ntypeargs=0 - 54 store_var 5 (_8) - 55 load_var 5 (_8) - 56 load_type 11 - 57 load_const 12 ("next") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 6 (_9) - 60 load_var 6 (_9) - 61 is_type 7 - 62 pop_jump_if_false +2 (to 64) - 63 jump +30 (to 93) - 64 load_var 6 (_9) - 65 store_var 7 (key) - - 218 66 load_type 8 - 67 load_type 2 - 68 load_var2 3 7 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 8 (value) - - 219 71 load_var 8 (value) - 72 load_const 13 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump -20 (to 55) - - 222 76 load_var 7 (key) - 77 call 1169 ntypeargs=0 (anthropic.internal._anth_verbatim_subtree) - 78 pop_jump_if_false +2 (to 80) - 79 jump +5 (to 84) - - 225 80 load_var 8 (value) - 81 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - 82 store_var 9 (kept) - 83 jump +3 (to 86) - - 223 84 load_var 8 (value) - 85 store_var 9 (kept) - - 227 86 load_type 8 - 87 load_type 2 - 88 load_var2 4 7 - 89 load_var 9 (kept) - 90 call 37 ntypeargs=2 (baml.Map.set) - 91 pop 1 - 92 jump -37 (to 55) - - 232 93 load_var 4 (out) - 94 return -} - -function anthropic.internal._anth_stream_call_at(state: anthropic.internal.AnthStreamState, index: int | null) -> anthropic.internal.AnthStreamToolCall | null { - 991 0 load_var 2 (index) - 1 store_var_load_var 4 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +4 (to 8) - 5 load_const 1 (1) - 6 unary_op - - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 store_var 3 (wanted) - - 992 10 load_var 1 (state) - 11 load_field 2 (tool_calls) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 5 (_7) - 16 load_var 5 (_7) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 6 (_8) - 21 load_var 6 (_8) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +9 (to 33) - 25 load_var 6 (_8) - 26 store_var_load_var 7 (call) - - 993 27 load_field 0 (index) - 28 load_var 3 (wanted) - 29 cmp_int_op == - 30 pop_jump_if_false -14 (to 16) - - 994 31 load_var 7 (call) - 32 jump +2 (to 34) - - 997 33 load_const 0 (null) - 34 return -} - -function anthropic.internal._anth_stream_failure(error: anthropic.internal.AnthStreamError | null, raw: string) -> ai.errors.Failure { - 1005 0 load_var 1 (error) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - 5 load_var 1 (error) - 6 load_field 0 (0) - 7 jump +2 (to 9) - 8 load_const 0 (null) - 9 store_var_load_var 4 (_4) - 10 load_const 0 (null) - 11 cmp_op == - 12 pop_jump_if_false +3 (to 15) - 13 load_const 1 ("") - 14 store_var 4 (_4) - 15 load_var 4 (_4) - 16 store_var 3 (kind) - - 1006 17 load_var 1 (error) - 18 load_const 0 (null) - 19 cmp_op == - 20 pop_jump_if_false +2 (to 22) - 21 jump +4 (to 25) - 22 load_var 1 (error) - 23 load_field 1 (1) - 24 jump +2 (to 26) - 25 load_const 0 (null) - 26 store_var_load_var 6 (_10) - 27 load_const 0 (null) - 28 cmp_op == - 29 pop_jump_if_false +3 (to 32) - 30 load_var 3 (kind) - 31 store_var 6 (_10) - 32 load_var 6 (_10) - 33 store_var 5 (detail) - - 1007 34 load_var 3 (kind) - 35 load_const 2 ("rate_limit_error") - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +85 (to 123) - 39 load_var 3 (kind) - 40 load_const 3 ("overloaded_error") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +63 (to 106) - 44 load_var 3 (kind) - 45 load_const 4 ("api_error") - 46 cmp_op == - 47 pop_jump_if_false +2 (to 49) - 48 jump +41 (to 89) - 49 load_var 3 (kind) - 50 load_const 5 ("timeout_error") - 51 cmp_op == - 52 pop_jump_if_false +2 (to 54) - 53 jump +19 (to 72) - - 1023 54 load_type 6 - 55 load_var 3 (kind) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 13 (_45) - 58 load_type 6 - 59 load_var 5 (detail) - 60 call 138 ntypeargs=1 (baml.String.from) - 61 store_var 14 (_48) - - 1020 62 load_const 7 ("anthropic") - 63 load_const 0 (null) - - 1023 64 load_var 13 (_45) - 65 load_const 8 (": ") - 66 bin_op + - 67 load_var 14 (_48) - 68 bin_op + - 69 load_var 2 (raw) - 70 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 1007 71 jump +56 (to 127) - - 1015 72 load_type 9 - 73 load_var 3 (kind) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 11 (_37) - 76 load_type 6 - 77 load_var 5 (detail) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 12 (_40) - - 1013 80 load_const 10 ("anthropic") - - 1015 81 load_var 11 (_37) - 82 load_const 11 (": ") - 83 bin_op + - 84 load_var 12 (_40) - 85 bin_op + - 86 load_var 2 (raw) - 87 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 88 jump +39 (to 127) - - 1015 89 load_type 9 - 90 load_var 3 (kind) - 91 call 138 ntypeargs=1 (baml.String.from) - 92 store_var 9 (_28) - 93 load_type 6 - 94 load_var 5 (detail) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 10 (_31) - - 1013 97 load_const 12 ("anthropic") - - 1015 98 load_var 9 (_28) - 99 load_const 13 (": ") - 100 bin_op + - 101 load_var 10 (_31) - 102 bin_op + - 103 load_var 2 (raw) - 104 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 105 jump +22 (to 127) - - 1015 106 load_type 9 - 107 load_var 3 (kind) - 108 call 138 ntypeargs=1 (baml.String.from) - 109 store_var 7 (_19) - 110 load_type 6 - 111 load_var 5 (detail) - 112 call 138 ntypeargs=1 (baml.String.from) - 113 store_var 8 (_22) - - 1013 114 load_const 14 ("anthropic") - - 1015 115 load_var 7 (_19) - 116 load_const 15 (": ") - 117 bin_op + - 118 load_var 8 (_22) - 119 bin_op + - 120 load_var 2 (raw) - 121 init_instance 3 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 122 jump +5 (to 127) - - 1008 123 load_const 16 ("anthropic") - 124 load_const 0 (null) - 125 load_var 2 (raw) - 126 init_instance 4 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 127 return -} - -function anthropic.internal._anth_supported_image_mime(mime: string) -> bool { - 303 0 load_var 1 (mime) - 1 call 142 ntypeargs=0 (baml.String.to_lower_case) - 2 store_var 2 (m) - - 304 3 load_var 2 (m) - 4 load_const 0 ("image/jpeg") - 5 cmp_op == - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_var 2 (m) - 10 load_const 1 ("image/png") - 11 cmp_op == - 12 jump_if_false +2 (to 14) - 13 jump +5 (to 18) - 14 pop 1 - 15 load_var 2 (m) - 16 load_const 2 ("image/gif") - 17 cmp_op == - 18 jump_if_false +2 (to 20) - 19 jump +5 (to 24) - 20 pop 1 - 21 load_var 2 (m) - 22 load_const 3 ("image/webp") - 23 cmp_op == - 24 return -} - -function anthropic.internal._anth_verbatim_subtree(key: string) -> bool { - 210 0 load_var 1 (key) - 1 load_const 0 ("input") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("input_schema") - 8 cmp_op == - 9 return -} - -function anthropic.internal._anthropic_assistant_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - 417 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 418 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +61 (to 77) - 17 load_var 4 (_4) - 18 store_var 5 (b) - - 419 19 load_var 5 (b) - 20 store_var 6 (_8) - 21 load_var 6 (_8) - 22 narrow_bind 6 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +36 (to 60) - 25 load_var 5 (b) - 26 store_var 8 (_17) - 27 load_var 8 (_17) - 28 narrow_bind 7 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump -22 (to 8) - 31 load_var 5 (b) - 32 store_var 9 (_18) - 33 load_var 9 (_18) - 34 narrow_bind 8 9 - 35 pop_jump_if_false +2 (to 37) - 36 jump -28 (to 8) - 37 load_var 5 (b) - 38 store_var 10 (u) - - 437 39 load_var 10 (u) - 40 load_field 0 (id) - 41 store_var 11 (_22) - - 438 42 load_var 10 (u) - 43 load_field 1 (name) - 44 store_var 12 (_23) - - 439 45 load_type 9 - 46 load_var 10 (u) - 47 load_field 2 (args) - 48 call 355 ntypeargs=1 (baml.json.to_json) - 49 store_var 13 (_24) - - 434 50 load_type 0 - 51 load_var 2 (out) - - 435 52 load_const 10 ("tool_use") - 53 load_var2 11 12 - 54 load_var 13 (_24) - 55 load_const 11 (null) - 56 init_instance 0 (anthropic.internal.AnthToolUseBlock .type, .id, .name, .input, .cache_control) - - 434 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - 59 jump -51 (to 8) - - 419 60 load_var 6 (_8) - 61 store_var_load_var 7 (t) - - 421 62 load_field 0 (text) - 63 call 144 ntypeargs=0 (baml.String.trim) - 64 load_const 12 ("") - 65 cmp_op != - 66 pop_jump_if_false -58 (to 8) - - 422 67 load_type 0 - 68 load_var 2 (out) - 69 load_const 13 ("text") - 70 load_var 7 (t) - 71 load_field 0 (text) - 72 load_const 11 (null) - 73 init_instance 1 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 74 call 4 ntypeargs=1 (baml.Array.push) - 75 pop 1 - 76 jump -68 (to 8) - - 447 77 load_var 2 (out) - 78 return -} - -function anthropic.internal._anthropic_body_params(c: anthropic.AnthropicClient) -> anthropic.internal.AnthropicBodyParams { - 572 0 load_var 1 (c) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 573 3 load_var 1 (c) - 4 load_field 3 (max_tokens) - 5 store_var 3 (_3) - - 574 6 load_var 1 (c) - 7 load_field 4 (temperature) - 8 store_var 4 (_4) - - 575 9 load_var 1 (c) - 10 load_field 5 (top_p) - 11 store_var 5 (_5) - - 576 12 load_var 1 (c) - 13 load_field 6 (top_k) - 14 store_var 6 (_6) - - 577 15 load_var 1 (c) - 16 load_field 7 (stop_sequences) - 17 store_var 7 (_7) - - 578 18 load_var 1 (c) - 19 load_field 8 (thinking) - 20 store_var 8 (_8) - - 579 21 load_var 1 (c) - 22 load_field 9 (tool_choice) - 23 store_var 9 (_9) - - 580 24 load_var 1 (c) - 25 load_field 10 (request_body) - 26 store_var 10 (_10) - - 581 27 load_var 1 (c) - 28 load_type 0 - 29 load_const 1 ("id") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 11 (_11) - - 571 32 load_var2 2 3 - 33 load_var2 4 5 - 34 load_var2 6 7 - 35 load_var2 8 9 - 36 load_var2 10 11 - 37 init_instance 0 (anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id) - 38 return -} - -function anthropic.internal._anthropic_headers(c: anthropic.AnthropicClient) -> map { - 755 0 load_const 0 ("2023-06-01") - 1 load_const 1 ("application/json") - 2 load_const 2 ("anthropic-version") - 3 load_const 3 ("content-type") - 4 load_type 4 - 5 load_type 4 - 6 alloc_map 2 - 7 store_var 2 (headers) - - 759 8 load_var 1 (c) - 9 load_field 11 (headers) - 10 store_var 3 (_4) - 11 load_var 3 (_4) - 12 narrow_bind 5 3 - 13 pop_jump_if_false +42 (to 55) - 14 load_var 3 (_4) - 15 store_var 4 (extra) - - 760 16 load_type 4 - 17 load_type 4 - 18 load_var 4 (extra) - 19 call 35 ntypeargs=2 (baml.Map.keys) - 20 load_type 6 - 21 load_const 7 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 5 (_9) - 24 load_var 5 (_9) - 25 load_type 8 - 26 load_const 9 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 6 (_10) - 29 load_var 6 (_10) - 30 is_type 10 - 31 pop_jump_if_false +2 (to 33) - 32 jump +23 (to 55) - 33 load_var 6 (_10) - 34 store_var 7 (key) - - 761 35 load_var 7 (key) - 36 call 142 ntypeargs=0 (baml.String.to_lower_case) - 37 store_var 8 (_15) - 38 load_type 4 - 39 load_type 4 - 40 load_var2 4 7 - 41 call 38 ntypeargs=2 (baml.Map.get) - 42 store_var_load_var 9 (_17) - 43 load_const 11 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 12 ("") - 47 store_var 9 (_17) - 48 load_type 4 - 49 load_type 4 - 50 load_var2 2 8 - 51 load_var 9 (_17) - 52 call 37 ntypeargs=2 (baml.Map.set) - 53 pop 1 - 54 jump -30 (to 24) - - 764 55 load_var 1 (c) - 56 call 1163 ntypeargs=0 (anthropic.AnthropicClient.resolved_api_key) - 57 store_var 10 (_26) - 58 load_type 4 - 59 load_type 4 - 60 load_var 2 (headers) - 61 load_const 13 ("x-api-key") - 62 load_var 10 (_26) - 63 call 37 ntypeargs=2 (baml.Map.set) - 64 pop 1 - - 765 65 load_var 2 (headers) - 66 return -} - -function anthropic.internal._anthropic_lower_journal(j: ai.Journal) -> anthropic.internal.AnthropicMessage[] { - 479 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (msgs) - - 480 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +81 (to 98) - 18 load_var 4 (_5) - 19 store_var 5 (e) - - 481 20 load_var 5 (e) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +58 (to 83) - 26 load_var 5 (e) - 27 store_var 7 (_17) - 28 load_var 7 (_17) - 29 narrow_bind 7 7 - 30 pop_jump_if_false +2 (to 32) - 31 jump +32 (to 63) - 32 load_var 5 (e) - 33 store_var 10 (_27) - 34 load_var 10 (_27) - 35 narrow_bind 8 10 - 36 pop_jump_if_false +2 (to 38) - 37 jump +16 (to 53) - 38 load_var 5 (e) - 39 store_var 12 (_33) - 40 load_var 12 (_33) - 41 narrow_bind 9 12 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 12 (_33) - 44 store_var 13 (f) - - 515 45 load_var2 2 13 - 46 load_field 0 (id) - 47 load_var 13 (f) - 48 load_field 1 (message) - 49 load_const 10 (true) - 50 call 1177 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) - 51 pop 1 - 52 jump -43 (to 9) - - 481 53 load_var 10 (_27) - 54 store_var 11 (c) - - 512 55 load_var2 2 11 - 56 load_field 0 (id) - 57 load_var 11 (c) - 58 load_field 1 (output) - 59 load_const 11 (false) - 60 call 1177 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) - 61 pop 1 - 62 jump -53 (to 9) - - 481 63 load_var 7 (_17) - 64 load_field 0 (content) - - 495 65 call 1176 ntypeargs=0 (anthropic.internal._anthropic_assistant_blocks) - 66 store_var 8 (blocks) - - 500 67 load_var 8 (blocks) - 68 container_len - 69 store_var 9 (_22) - 70 load_var 9 (_22) - 71 load_const 12 (0) - 72 cmp_int_op > - 73 pop_jump_if_false -64 (to 9) - - 501 74 load_type 0 - 75 load_var 2 (msgs) - - 502 76 load_const 13 ("assistant") - 77 load_const 11 (false) - - 505 78 load_var 8 (blocks) - 79 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 501 80 call 4 ntypeargs=1 (baml.Array.push) - 81 pop 1 - 82 jump -73 (to 9) - - 483 83 load_type 0 - 84 load_var 2 (msgs) - - 484 85 load_const 14 ("user") - 86 load_const 11 (false) - - 488 87 load_const 15 ("text") - - 481 88 load_var 6 (_9) - 89 load_field 0 (content) - 90 load_const 16 (null) - 91 init_instance 1 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 92 load_type 17 - 93 alloc_array 1 - 94 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 483 95 call 4 ntypeargs=1 (baml.Array.push) - 96 pop 1 - 97 jump -88 (to 9) - - 520 98 load_var 2 (msgs) - 99 return -} - -function anthropic.internal._anthropic_lower_prompt(prompt: ai.Prompt) -> anthropic.internal.AnthropicPrompt { - 379 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (system) - - 380 3 load_type 1 - 4 alloc_array 0 - 5 store_var 3 (messages) - - 381 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_6) - 17 load_var 5 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +74 (to 94) - 21 load_var 5 (_6) - 22 store_var 6 (message) - - 382 23 load_type 7 - 24 load_type 8 - 25 load_var 6 (message) - 26 load_field 3 (metadata) - 27 load_const 9 ("cache_control") - 28 call 38 ntypeargs=2 (baml.Map.get) - 29 store_var 7 (cache_control) - - 383 30 load_var 6 (message) - 31 load_field 0 (role) - 32 load_const 10 ("system") - 33 cmp_op == - 34 pop_jump_if_false +2 (to 36) - 35 jump +33 (to 68) - - 391 36 load_var 6 (message) - 37 load_field 0 (role) - 38 load_const 11 ("assistant") - 39 cmp_op == - 40 pop_jump_if_false +2 (to 42) - 41 jump +4 (to 45) - - 394 42 load_const 12 ("user") - 43 store_var 11 (role) - - 391 44 jump +3 (to 47) - - 392 45 load_const 13 ("assistant") - 46 store_var 11 (role) - - 396 47 load_var2 6 11 - 48 call 1174 ntypeargs=0 (anthropic.internal._anthropic_prompt_blocks) - 49 store_var 12 (blocks) - - 397 50 load_var2 12 7 - 51 call 1171 ntypeargs=0 (anthropic.internal._anth_apply_cache_control) - 52 pop 1 - - 400 53 load_var 12 (blocks) - 54 container_len - 55 store_var 13 (_40) - 56 load_var 13 (_40) - 57 load_const 14 (0) - 58 cmp_int_op > - 59 pop_jump_if_false -47 (to 12) - - 401 60 load_type 1 - 61 load_var2 3 11 - - 402 62 load_const 15 (false) - 63 load_var 12 (blocks) - 64 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 401 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -55 (to 12) - - 384 68 load_var 6 (message) - 69 load_const 16 ("system") - 70 call 1174 ntypeargs=0 (anthropic.internal._anthropic_prompt_blocks) - 71 store_var 8 (blocks) - - 385 72 load_var2 8 7 - 73 call 1171 ntypeargs=0 (anthropic.internal._anth_apply_cache_control) - 74 pop 1 - - 386 75 load_var 8 (blocks) - 76 load_type 17 - 77 load_const 18 ("iter") - 78 virtual_call nargs=1 ntypeargs=0 - 79 store_var 9 (_22) - 80 load_var 9 (_22) - 81 load_type 19 - 82 load_const 20 ("next") - 83 virtual_call nargs=1 ntypeargs=0 - 84 store_var 10 (_23) - 85 load_var 10 (_23) - 86 is_type 6 - 87 pop_jump_if_false +2 (to 89) - 88 jump -76 (to 12) - - 387 89 load_type 0 - 90 load_var2 2 10 - 91 call 4 ntypeargs=1 (baml.Array.push) - 92 pop 1 - 93 jump -13 (to 80) - - 408 94 load_var2 2 3 - 95 init_instance 1 (anthropic.internal.AnthropicPrompt .system, .messages) - 96 return -} - -function anthropic.internal._anthropic_media_block(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, block_type: string) -> anthropic.internal.AnthMediaBlock { - 308 0 load_var 1 (media) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 3 (resolved) - - 309 4 load_var 3 (resolved) - 5 load_field 0 (url) - 6 store_var 5 (_6) - 7 load_var 5 (_6) - 8 narrow_bind 1 5 - 9 pop_jump_if_false +2 (to 11) - 10 jump +41 (to 51) - - 314 11 load_var 2 (block_type) - 12 load_const 2 ("image") - 13 cmp_op == - 14 jump_if_false +6 (to 20) - 15 pop 1 - 16 load_var 3 (resolved) - 17 load_field 2 (mime_type) - 18 call 1172 ntypeargs=0 (anthropic.internal._anth_supported_image_mime) - 19 unary_op ! - 20 pop_jump_if_false +2 (to 22) - 21 jump +18 (to 39) - - 321 22 load_var 3 (resolved) - 23 load_field 2 (mime_type) - 24 store_var 7 (_19) - - 322 25 load_var 3 (resolved) - 26 load_field 1 (base64) - 27 store_var_load_var 8 (_21) - 28 load_const 3 (null) - 29 cmp_op == - 30 pop_jump_if_false +3 (to 33) - 31 load_const 4 ("") - 32 store_var 8 (_21) - - 319 33 load_const 5 ("base64") - 34 load_var2 7 8 - - 322 35 load_const 3 (null) - 36 init_instance 0 (anthropic.internal.AnthSource .type, .media_type, .data, .url) - 37 store_var 4 (source) - - 309 38 jump +19 (to 57) - - 316 39 load_type 6 - 40 load_var 3 (resolved) - 41 load_field 2 (mime_type) - 42 call 138 ntypeargs=1 (baml.String.from) - 43 store_var 6 (_16) - 44 load_const 7 ("Anthropic does not accept ") - 45 load_var 6 (_16) - 46 bin_op + - 47 load_const 8 (" images: the Messages API supports image/jpeg, image/png, image/gif and image/webp") - 48 bin_op + - - 315 49 call 1168 ntypeargs=0 (anthropic.internal._reject) - 50 throw - - 312 51 load_const 9 ("url") - 52 load_const 3 (null) - 53 load_const 3 (null) - - 309 54 load_var 5 (_6) - 55 init_instance 1 (anthropic.internal.AnthSource .type, .media_type, .data, .url) - 56 store_var 4 (source) - - 326 57 load_var2 2 4 - 58 load_const 3 (null) - 59 init_instance 2 (anthropic.internal.AnthMediaBlock .type, .source, .cache_control) - 60 return -} - -function anthropic.internal._anthropic_prompt_blocks(message: ai.PromptMessage, role: string) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - 330 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (blocks) - - 331 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +99 (to 116) - 18 load_var 5 (_6) - 19 store_var 6 (part) - - 332 20 load_var 6 (part) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +75 (to 100) - 26 load_var 6 (part) - 27 store_var 9 (_18) - 28 load_var 9 (_18) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +44 (to 75) - 32 load_var 6 (part) - 33 store_var 13 (_29) - 34 load_var 13 (_29) - 35 narrow_bind 8 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +35 (to 72) - 38 load_var 6 (part) - 39 store_var 14 (_31) - 40 load_var 14 (_31) - 41 narrow_bind 9 14 - 42 pop_jump_if_false +2 (to 44) - 43 jump +4 (to 47) - - 371 44 load_const 10 ("Anthropic does not support video prompt input") - 45 call 1168 ntypeargs=0 (anthropic.internal._reject) - 46 throw - - 332 47 load_var 14 (_31) - 48 store_var 15 (pdf) - - 362 49 load_var 2 (role) - 50 load_const 11 ("user") - 51 cmp_op != - 52 pop_jump_if_false +2 (to 54) - 53 jump +10 (to 63) - - 367 54 load_var 15 (pdf) - 55 load_const 12 ("document") - 56 call 1173 ntypeargs=0 (anthropic.internal._anthropic_media_block) - 57 store_var 17 (_39) - 58 load_type 0 - 59 load_var2 3 17 - 60 call 4 ntypeargs=1 (baml.Array.push) - 61 pop 1 - 62 jump -53 (to 9) - - 364 63 load_type 13 - 64 load_var 2 (role) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 16 (_36) - 67 load_const 14 ("Anthropic only supports PDF input in user messages, found ") - 68 load_var 16 (_36) - 69 bin_op + - - 363 70 call 1168 ntypeargs=0 (anthropic.internal._reject) - 71 throw - - 357 72 load_const 15 ("Anthropic does not support audio prompt input: the Messages API has no audio content block") - 73 call 1168 ntypeargs=0 (anthropic.internal._reject) - 74 throw - - 332 75 load_var 9 (_18) - 76 store_var 10 (image) - - 342 77 load_var 2 (role) - 78 load_const 16 ("user") - 79 cmp_op != - 80 pop_jump_if_false +2 (to 82) - 81 jump +10 (to 91) - - 347 82 load_var 10 (image) - 83 load_const 17 ("image") - 84 call 1173 ntypeargs=0 (anthropic.internal._anthropic_media_block) - 85 store_var 12 (_26) - 86 load_type 0 - 87 load_var2 3 12 - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 344 91 load_type 13 - 92 load_var 2 (role) - 93 call 138 ntypeargs=1 (baml.String.from) - 94 store_var 11 (_23) - 95 load_const 18 ("Anthropic only supports image input in user messages, found ") - 96 load_var 11 (_23) - 97 bin_op + - - 343 98 call 1168 ntypeargs=0 (anthropic.internal._reject) - 99 throw - - 332 100 load_var 7 (_10) - 101 store_var 8 (text) - - 336 102 load_var 8 (text) - 103 call 144 ntypeargs=0 (baml.String.trim) - 104 load_const 19 ("") - 105 cmp_op != - 106 pop_jump_if_false -97 (to 9) - - 337 107 load_type 0 - 108 load_var 3 (blocks) - 109 load_const 20 ("text") - 110 load_var 8 (text) - 111 load_const 21 (null) - 112 init_instance 0 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 113 call 4 ntypeargs=1 (baml.Array.push) - 114 pop 1 - 115 jump -106 (to 9) - - 375 116 load_var 3 (blocks) - 117 return -} - -function anthropic.internal._anthropic_push_tool_result(msgs: anthropic.internal.AnthropicMessage[], id: string, content: string, is_error: bool) -> void { - 457 0 load_const 0 ("tool_result") - 1 load_var2 2 3 - 2 load_var 4 (is_error) - 3 load_const 1 (null) - 4 init_instance 0 (anthropic.internal.AnthToolResultBlock .type, .tool_use_id, .content, .is_error, .cache_control) - 5 store_var 5 (block) - - 465 6 load_var 1 (msgs) - 7 container_len - 8 store_var 6 (_8) - 9 load_type 2 - 10 load_var2 1 6 - 11 load_const 3 (1) - 12 sub_int - 13 call 3 ntypeargs=1 (baml.Array.at) - 14 store_var 7 (_10) - 15 load_var 7 (_10) - 16 narrow_bind 4 7 - 17 pop_jump_if_false +2 (to 19) - 18 jump +13 (to 31) - - 472 19 load_type 2 - 20 load_var 1 (msgs) - 21 load_const 5 ("user") - 22 load_const 6 (true) - 23 load_var 5 (block) - 24 load_type 7 - 25 alloc_array 1 - 26 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 27 call 4 ntypeargs=1 (baml.Array.push) - 28 pop 1 - - 471 29 load_const 1 (null) - - 465 30 jump +25 (to 55) - 31 load_var 7 (_10) - 32 store_var_load_var 8 (m) - - 466 33 load_field 1 (tool_results) - 34 pop_jump_if_false +2 (to 36) - 35 jump +13 (to 48) - - 469 36 load_type 2 - 37 load_var 1 (msgs) - 38 load_const 8 ("user") - 39 load_const 6 (true) - 40 load_var 5 (block) - 41 load_type 7 - 42 alloc_array 1 - 43 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 44 call 4 ntypeargs=1 (baml.Array.push) - 45 pop 1 - - 468 46 load_const 1 (null) - - 466 47 jump +8 (to 55) - - 467 48 load_type 7 - 49 load_var 8 (m) - 50 load_field 2 (blocks) - 51 load_var 5 (block) - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - - 466 54 load_const 1 (null) - 55 return -} - -function anthropic.internal._anthropic_query_suffix(query_params: map | null) -> string { - 734 0 load_var 1 (query_params) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +73 (to 77) - - 737 5 load_type 1 - 6 alloc_array 0 - 7 store_var 2 (pairs) - - 738 8 load_type 1 - 9 load_type 1 - 10 load_var 1 (query_params) - 11 call 35 ntypeargs=2 (baml.Map.keys) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 3 (_8) - 16 load_var 3 (_8) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 4 (_9) - 21 load_var 4 (_9) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +30 (to 54) - 25 load_var 4 (_9) - 26 store_var 5 (key) - - 739 27 load_type 1 - 28 load_var 5 (key) - 29 call 138 ntypeargs=1 (baml.String.from) - 30 store_var 6 (_16) - 31 load_type 1 - 32 load_type 1 - 33 load_var2 1 5 - 34 call 38 ntypeargs=2 (baml.Map.get) - 35 store_var_load_var 8 (_21) - 36 load_const 0 (null) - 37 cmp_op == - 38 pop_jump_if_false +3 (to 41) - 39 load_const 7 ("") - 40 store_var 8 (_21) - 41 load_type 1 - 42 load_var 8 (_21) - 43 call 138 ntypeargs=1 (baml.String.from) - 44 store_var 7 (_19) - 45 load_type 1 - 46 load_var2 2 6 - 47 load_const 8 ("=") - 48 bin_op + - 49 load_var 7 (_19) - 50 bin_op + - 51 call 4 ntypeargs=1 (baml.Array.push) - 52 pop 1 - 53 jump -37 (to 16) - - 741 54 load_var 2 (pairs) - 55 container_len - 56 store_var 9 (_30) - 57 load_var 9 (_30) - 58 load_const 9 (0) - 59 cmp_int_op > - 60 pop_jump_if_false +2 (to 62) - 61 jump +3 (to 64) - - 744 62 load_const 10 ("") - - 741 63 jump +15 (to 78) - - 742 64 load_type 1 - 65 load_var 2 (pairs) - 66 load_const 11 ("&") - 67 call 15 ntypeargs=1 (baml.Array.join) - 68 store_var 11 (_32) - 69 load_type 1 - 70 load_var 11 (_32) - 71 call 138 ntypeargs=1 (baml.String.from) - 72 store_var 10 (_31) - 73 load_const 12 ("?") - 74 load_var 10 (_31) - 75 bin_op + - - 741 76 jump +2 (to 78) - - 735 77 load_const 13 ("") - 78 return -} - -function anthropic.internal._anthropic_render_messages(msgs: anthropic.internal.AnthropicMessage[]) -> anthropic.internal.AnthMessageParam[] { - 535 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 536 3 load_var 1 (msgs) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +62 (to 78) - 17 load_var 4 (_4) - 18 store_var 5 (m) - - 537 19 load_var 2 (out) - 20 container_len - 21 store_var 6 (_10) - 22 load_type 0 - 23 load_var2 2 6 - 24 load_const 6 (1) - 25 sub_int - 26 call 3 ntypeargs=1 (baml.Array.at) - 27 store_var 7 (_12) - 28 load_var 7 (_12) - 29 narrow_bind 7 7 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 7 (_12) - 32 store_var_load_var 8 (last) - - 538 33 load_field 0 (role) - 34 load_var 5 (m) - 35 load_field 0 (role) - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +18 (to 56) - - 545 39 load_var 5 (m) - 40 load_field 0 (role) - 41 store_var 11 (_29) - 42 load_type 8 - 43 load_var 5 (m) - 44 load_field 2 (blocks) - 45 load_type 8 - 46 alloc_array 0 - 47 call 7 ntypeargs=1 (baml.Array.concat) - 48 store_var 12 (_30) - 49 load_type 0 - 50 load_var2 2 11 - 51 load_var 12 (_30) - 52 init_instance 0 (anthropic.internal.AnthMessageParam .role, .content) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -47 (to 8) - - 539 56 load_var 5 (m) - 57 load_field 2 (blocks) - 58 load_type 9 - 59 load_const 10 ("iter") - 60 virtual_call nargs=1 ntypeargs=0 - 61 store_var 9 (_18) - 62 load_var 9 (_18) - 63 load_type 11 - 64 load_const 12 ("next") - 65 virtual_call nargs=1 ntypeargs=0 - 66 store_var 10 (_19) - 67 load_var 10 (_19) - 68 is_type 5 - 69 pop_jump_if_false +2 (to 71) - 70 jump -62 (to 8) - - 540 71 load_type 8 - 72 load_var 8 (last) - 73 load_field 1 (content) - - 539 74 load_var 10 (_19) - - 540 75 call 4 ntypeargs=1 (baml.Array.push) - 76 pop 1 - 77 jump -15 (to 62) - - 547 78 load_var 2 (out) - 79 return -} - -function anthropic.internal._anthropic_request(c: anthropic.AnthropicClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 775 0 load_var 1 (c) - 1 call 1164 ntypeargs=0 (anthropic.AnthropicClient.resolved_base_url) - 2 store_var_load_var 4 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("https://api.anthropic.com") - 7 store_var 4 (_5) - - 778 8 load_type 2 - - 775 9 load_var 4 (_5) - - 778 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 5 (_10) - 12 load_var 1 (c) - 13 load_field 12 (query_params) - 14 call 1186 ntypeargs=0 (anthropic.internal._anthropic_query_suffix) - 15 store_var 7 (_14) - 16 load_type 2 - 17 load_var 7 (_14) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 6 (_13) - - 779 20 load_var 1 (c) - 21 call 1187 ntypeargs=0 (anthropic.internal._anthropic_headers) - 22 store_var 8 (_17) - - 780 23 load_var 1 (c) - 24 call 1180 ntypeargs=0 (anthropic.internal._anthropic_body_params) - 25 load_var2 2 3 - 26 call 1185 ntypeargs=0 (anthropic.internal.anthropic_messages_body) - 27 store_var 9 (_18) - - 776 28 load_const 3 ("POST") - - 778 29 load_var 5 (_10) - 30 load_const 4 ("/v1/messages") - 31 bin_op + - 32 load_var 6 (_13) - 33 bin_op + - 34 load_var2 8 9 - 35 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 36 return -} - -function anthropic.internal._anthropic_sse_failure(message: string) -> ai.errors.Failure { - 1195 0 load_var 1 (message) - - 1194 1 load_const 0 ("SSE request failed with status ") - - 1195 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +36 (to 39) - - 1194 4 load_const 1 ("SSE request failed with status ") - - 1196 5 call 139 ntypeargs=0 (baml.String.length) - 6 store_var 3 (_6) - 7 load_var 1 (message) - 8 call 139 ntypeargs=0 (baml.String.length) - 9 store_var 4 (_7) - 10 load_var2 1 3 - 11 load_var 4 (_7) - 12 call 153 ntypeargs=0 (baml.String.slice) - 13 store_var 2 (rest) - - 1197 14 load_var 2 (rest) - 15 load_const 2 (":") - 16 call 155 ntypeargs=0 (baml.String.index_of) - 17 store_var 5 (_9) - 18 load_var 5 (_9) - 19 narrow_bind 3 5 - 20 pop_jump_if_false +19 (to 39) - 21 load_var 5 (_9) - 22 store_var 6 (separator) - - 1198 23 load_var 2 (rest) - 24 load_const 3 (0) - 25 load_var 6 (separator) - 26 call 153 ntypeargs=0 (baml.String.slice) - 27 call 81 ntypeargs=0 (baml.Int.parse) - 28 store_var 7 (status) - 29 jump +5 (to 34) - 30 load_var 8 (e) - 31 throw_if_panic - - 1199 32 load_const 3 (0) - 33 store_var 7 (status) - - 1201 34 load_var 7 (status) - 35 load_const 3 (0) - 36 cmp_int_op > - 37 pop_jump_if_false +2 (to 39) - 38 jump +12 (to 50) - - 1212 39 load_type 4 - 40 load_var 1 (message) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 13 (_24) - - 1210 43 load_const 5 ("anthropic") - - 1212 44 load_const 6 ("transport failed before a response arrived: ") - 45 load_var 13 (_24) - 46 bin_op + - 47 load_const 7 (null) - 48 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 49 jump +19 (to 68) - - 1204 50 load_var 7 (status) - 51 store_var 9 (_17) - - 1205 52 load_var 6 (separator) - 53 load_const 8 (1) - 54 add_int - 55 store_var 11 (_20) - 56 load_var 2 (rest) - 57 call 139 ntypeargs=0 (baml.String.length) - 58 store_var 12 (_22) - 59 load_var2 2 11 - 60 load_var 12 (_22) - 61 call 153 ntypeargs=0 (baml.String.slice) - 62 call 144 ntypeargs=0 (baml.String.trim) - 63 store_var 10 (_18) - - 1202 64 load_const 9 ("anthropic") - 65 load_var2 9 10 - 66 load_const 10 () - 67 call 977 ntypeargs=0 (ai.errors.classify_http) - 68 return -} - -function anthropic.internal._anthropic_stop_reason(s: string) -> ai.content.StopReason { - 797 0 load_var 1 (s) - 1 load_const 0 ("end_turn") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +28 (to 32) - 5 load_var 1 (s) - 6 load_const 1 ("stop_sequence") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +20 (to 29) - 10 load_var 1 (s) - 11 load_const 2 ("tool_use") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +12 (to 26) - 15 load_var 1 (s) - 16 load_const 3 ("refusal") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +4 (to 23) - - 802 20 load_const 4 (ai.content.StopReason.MaxTokens) - 21 alloc_variant 774 (ai.content.StopReason) - - 797 22 jump +12 (to 34) - - 800 23 load_const 5 (ai.content.StopReason.Refused) - 24 alloc_variant 774 (ai.content.StopReason) - - 797 25 jump +9 (to 34) - - 799 26 load_const 6 (ai.content.StopReason.ToolUse) - 27 alloc_variant 774 (ai.content.StopReason) - - 797 28 jump +6 (to 34) - - 798 29 load_const 7 (ai.content.StopReason.Complete) - 30 alloc_variant 774 (ai.content.StopReason) - - 797 31 jump +3 (to 34) - - 798 32 load_const 7 (ai.content.StopReason.Complete) - 33 alloc_variant 774 (ai.content.StopReason) - 34 return -} - -function anthropic.internal._anthropic_thinking_param(thinking: anthropic.ThinkingConfig | null) -> anthropic.internal.AnthThinkingParam | null { - 615 0 load_var 1 (thinking) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +7 (to 11) - - 618 5 load_var 1 (thinking) - 6 load_field 0 (type) - 7 load_var 1 (thinking) - 8 load_field 1 (budget_tokens) - 9 init_instance 0 (anthropic.internal.AnthThinkingParam .type, .budget_tokens) - - 615 10 jump +2 (to 12) - - 616 11 load_const 0 (null) - 12 return -} - -function anthropic.internal._anthropic_tool_choice_param(choice: anthropic.ToolChoice | null) -> anthropic.internal.AnthToolChoiceParam { - 601 0 load_var 1 (choice) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +9 (to 13) - - 606 5 load_var 1 (choice) - 6 load_field 0 (type) - - 607 7 load_var 1 (choice) - 8 load_field 1 (name) - - 608 9 load_var 1 (choice) - 10 load_field 2 (disable_parallel_tool_use) - 11 init_instance 0 (anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use) - - 601 12 jump +5 (to 17) - - 603 13 load_const 1 ("auto") - 14 load_const 0 (null) - 15 load_const 0 (null) - 16 init_instance 1 (anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use) - 17 return -} - -function anthropic.internal._anthropic_tool_params(toolbox: ai.tools.Toolbox) -> anthropic.internal.AnthToolParam[] { - 586 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 587 3 load_var 1 (toolbox) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +22 (to 39) - 18 load_var 4 (_5) - 19 store_var 5 (t) - - 590 20 load_var 5 (t) - 21 load_field 0 (name) - 22 store_var 6 (_11) - - 591 23 load_var 5 (t) - 24 load_field 1 (description) - 25 store_var 7 (_12) - - 592 26 load_type 6 - 27 load_var 5 (t) - 28 load_field 2 (input_schema) - 29 call 355 ntypeargs=1 (baml.json.to_json) - 30 store_var 8 (_13) - - 588 31 load_type 0 - 32 load_var2 2 6 - - 589 33 load_var2 7 8 - 34 load_const 7 (null) - 35 init_instance 0 (anthropic.internal.AnthToolParam .name, .description, .input_schema, .cache_control) - - 588 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -29 (to 9) - - 597 39 load_var 2 (out) - 40 return -} - -function anthropic.internal._reject(detail: string) -> ai.errors.InvalidRequest { - 31 0 load_const 0 ("anthropic") - 1 load_const 1 (null) - 2 load_var 1 (detail) - 3 load_const 1 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 return -} - -function anthropic.internal.anthropic_decode_batch(batch: string, state: anthropic.internal.AnthStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1032 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 1033 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +541 (to 558) - 18 load_var 5 (_6) - 19 store_var_load_var 6 (raw) - - 1034 20 load_field 1 (data) - 21 store_var 7 (_11) - 22 load_var 7 (_11) - 23 narrow_bind 6 7 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 7 (_11) - 26 store_var 8 (data) - - 1035 27 load_type 7 - 28 load_var 8 (data) - 29 call 357 ntypeargs=1 (baml.json.from_string) - 30 jump +4 (to 34) - 31 load_var 9 (e) - 32 throw_if_panic - - 1036 33 load_const 8 (null) - - 1038 34 store_var 10 (_17) - 35 load_var 10 (_17) - 36 narrow_bind 9 10 - 37 pop_jump_if_false -28 (to 9) - 38 load_var 10 (_17) - 39 store_var_load_var 11 (event) - - 1039 40 load_field 0 (type) - 41 store_var_load_var 14 (_22) - 42 load_const 8 (null) - 43 cmp_op == - 44 pop_jump_if_false +4 (to 48) - 45 load_var 6 (raw) - 46 load_field 0 (event) - 47 store_var 14 (_22) - 48 load_var 14 (_22) - 49 store_var_load_var 13 (_20) - 50 load_const 8 (null) - 51 cmp_op == - 52 pop_jump_if_false +3 (to 55) - 53 load_const 10 ("") - 54 store_var 13 (_20) - 55 load_var 13 (_20) - 56 store_var_load_var 12 (t) - - 1040 57 load_const 11 ("error") - 58 cmp_op == - 59 pop_jump_if_false +2 (to 61) - 60 jump +493 (to 553) - 61 load_var 12 (t) - 62 load_const 12 ("message_start") - 63 cmp_op == - 64 pop_jump_if_false +2 (to 66) - 65 jump +366 (to 431) - 66 load_var 12 (t) - 67 load_const 13 ("content_block_start") - 68 cmp_op == - 69 pop_jump_if_false +2 (to 71) - 70 jump +255 (to 325) - 71 load_var 12 (t) - 72 load_const 14 ("content_block_delta") - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump +128 (to 203) - 76 load_var 12 (t) - 77 load_const 15 ("message_delta") - 78 cmp_op == - 79 pop_jump_if_false +2 (to 81) - 80 jump +11 (to 91) - 81 load_var 12 (t) - 82 load_const 16 ("message_stop") - 83 cmp_op == - 84 pop_jump_if_false -75 (to 9) - - 1170 85 load_type 0 - 86 load_var 3 (out) - 87 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 1143 91 load_var 11 (event) - 92 load_field 5 (usage) - 93 store_var 55 (_169) - 94 load_var 55 (_169) - 95 narrow_bind 17 55 - 96 pop_jump_if_false +44 (to 140) - 97 load_var 55 (_169) - 98 store_var_load_var 56 (usage) - - 1145 99 load_field 2 (cache_read_input_tokens) - 100 store_var_load_var 57 (_171) - 101 load_const 8 (null) - 102 cmp_op == - 103 pop_jump_if_false +4 (to 107) - 104 load_var 2 (state) - 105 load_field 3 (cache_read_input_tokens) - 106 store_var 57 (_171) - 107 load_var2 2 57 - 108 store_field 3 (cache_read_input_tokens) - - 1147 109 load_var 56 (usage) - 110 load_field 3 (cache_creation_input_tokens) - 111 store_var_load_var 58 (_174) - - 1148 112 load_const 8 (null) - 113 cmp_op == - 114 pop_jump_if_false +4 (to 118) - 115 load_var 2 (state) - 116 load_field 4 (cache_creation_input_tokens) - 117 store_var 58 (_174) - - 1147 118 load_var2 2 58 - 119 store_field 4 (cache_creation_input_tokens) - - 1150 120 load_var 56 (usage) - 121 load_field 4 (output_tokens_details) - 122 load_const 8 (null) - 123 cmp_op == - 124 pop_jump_if_false +2 (to 126) - 125 jump +5 (to 130) - 126 load_var 56 (usage) - 127 load_field 4 (output_tokens_details) - 128 load_field 0 (0) - 129 jump +2 (to 131) - 130 load_const 8 (null) - 131 store_var_load_var 59 (_177) - 132 load_const 8 (null) - 133 cmp_op == - 134 pop_jump_if_false +4 (to 138) - - 1151 135 load_var 2 (state) - 136 load_field 5 (reasoning_tokens) - 137 store_var 59 (_177) - - 1150 138 load_var2 2 59 - 139 store_field 5 (reasoning_tokens) - - 1153 140 load_var 11 (event) - 141 load_field 2 (delta) - 142 load_const 8 (null) - 143 cmp_op == - 144 pop_jump_if_false +2 (to 146) - 145 jump +6 (to 151) - 146 load_var 11 (event) - 147 load_field 2 (delta) - 148 load_field 5 (5) - 149 store_var 61 (_184) - 150 jump +3 (to 153) - 151 load_const 8 (null) - 152 store_var 61 (_184) - 153 load_var 61 (_184) - 154 load_const 8 (null) - 155 cmp_op == - 156 pop_jump_if_false +2 (to 158) - 157 jump +9 (to 166) - 158 load_var 61 (_184) - 159 store_var 62 (s) - - 1156 160 load_var2 2 62 - 161 store_field 6 (stop_reason_raw) - - 1157 162 load_var 62 (s) - 163 call 1190 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) - 164 store_var 60 (stop) - 165 jump +3 (to 168) - - 1154 166 load_const 8 (null) - 167 store_var 60 (stop) - - 1162 168 load_var 60 (stop) - 169 store_var 63 (_193) - - 1163 170 load_var 11 (event) - 171 load_field 5 (usage) - 172 load_const 8 (null) - 173 cmp_op == - 174 pop_jump_if_false +2 (to 176) - 175 jump +6 (to 181) - 176 load_var 11 (event) - 177 load_field 5 (usage) - 178 load_field 0 (0) - 179 store_var 64 (_194) - 180 jump +3 (to 183) - 181 load_const 8 (null) - 182 store_var 64 (_194) - - 1164 183 load_var 11 (event) - 184 load_field 5 (usage) - 185 load_const 8 (null) - 186 cmp_op == - 187 pop_jump_if_false +2 (to 189) - 188 jump +6 (to 194) - 189 load_var 11 (event) - 190 load_field 5 (usage) - 191 load_field 1 (1) - 192 store_var 65 (_198) - 193 jump +3 (to 196) - 194 load_const 8 (null) - 195 store_var 65 (_198) - - 1160 196 load_type 0 - 197 load_var2 3 63 - - 1161 198 load_var2 64 65 - 199 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1160 200 call 4 ntypeargs=1 (baml.Array.push) - 201 pop 1 - 202 jump -193 (to 9) - - 1106 203 load_var 11 (event) - 204 load_field 2 (delta) - 205 store_var 39 (_119) - 206 load_var 39 (_119) - 207 narrow_bind 18 39 - 208 pop_jump_if_false -199 (to 9) - 209 load_var 39 (_119) - 210 store_var_load_var 40 (d) - - 1107 211 load_field 0 (type) - 212 store_var_load_var 42 (_122) - 213 load_const 8 (null) - 214 cmp_op == - 215 pop_jump_if_false +3 (to 218) - 216 load_const 19 ("") - 217 store_var 42 (_122) - 218 load_var 42 (_122) - 219 store_var_load_var 41 (kind) - - 1108 220 load_const 20 ("text_delta") - 221 cmp_op == - 222 pop_jump_if_false +2 (to 224) - 223 jump +90 (to 313) - 224 load_var 41 (kind) - 225 load_const 21 ("input_json_delta") - 226 cmp_op == - 227 pop_jump_if_false +2 (to 229) - 228 jump +54 (to 282) - 229 load_var 41 (kind) - 230 load_const 22 ("thinking_delta") - 231 cmp_op == - 232 pop_jump_if_false +2 (to 234) - 233 jump +27 (to 260) - 234 load_var 41 (kind) - 235 load_const 23 ("signature_delta") - 236 cmp_op == - 237 pop_jump_if_false -228 (to 9) - - 1131 238 load_type 24 - 239 load_var 2 (state) - 240 load_field 1 (signature) - 241 call 138 ntypeargs=1 (baml.String.from) - 242 store_var 52 (_158) - 243 load_var 40 (d) - 244 load_field 4 (signature) - 245 store_var_load_var 54 (_163) - 246 load_const 8 (null) - 247 cmp_op == - 248 pop_jump_if_false +3 (to 251) - 249 load_const 25 ("") - 250 store_var 54 (_163) - 251 load_type 24 - 252 load_var 54 (_163) - 253 call 138 ntypeargs=1 (baml.String.from) - 254 store_var 53 (_161) - 255 load_var2 2 52 - 256 load_var 53 (_161) - 257 bin_op + - 258 store_field 1 (signature) - - 1108 259 jump -250 (to 9) - - 1127 260 load_type 24 - 261 load_var 2 (state) - 262 load_field 0 (thinking) - 263 call 138 ntypeargs=1 (baml.String.from) - 264 store_var 49 (_148) - 265 load_var 40 (d) - 266 load_field 3 (thinking) - 267 store_var_load_var 51 (_153) - 268 load_const 8 (null) - 269 cmp_op == - 270 pop_jump_if_false +3 (to 273) - 271 load_const 26 ("") - 272 store_var 51 (_153) - 273 load_type 24 - 274 load_var 51 (_153) - 275 call 138 ntypeargs=1 (baml.String.from) - 276 store_var 50 (_151) - 277 load_var2 2 49 - 278 load_var 50 (_151) - 279 bin_op + - 280 store_field 0 (thinking) - - 1108 281 jump -272 (to 9) - - 1116 282 load_var2 2 11 - - 1118 283 load_field 1 (index) - - 1116 284 call 1195 ntypeargs=0 (anthropic.internal._anth_stream_call_at) - 285 store_var 44 (_136) - 286 load_var 44 (_136) - 287 narrow_bind 27 44 - 288 pop_jump_if_false -279 (to 9) - 289 load_var 44 (_136) - 290 store_var 45 (call) - - 1120 291 load_type 24 - 292 load_var 45 (call) - 293 load_field 3 (args_json) - 294 call 138 ntypeargs=1 (baml.String.from) - 295 store_var 46 (_138) - 296 load_var 40 (d) - 297 load_field 2 (partial_json) - 298 store_var_load_var 48 (_143) - 299 load_const 8 (null) - 300 cmp_op == - 301 pop_jump_if_false +3 (to 304) - 302 load_const 28 ("") - 303 store_var 48 (_143) - 304 load_type 24 - 305 load_var 48 (_143) - 306 call 138 ntypeargs=1 (baml.String.from) - 307 store_var 47 (_141) - 308 load_var2 45 46 - 309 load_var 47 (_141) - 310 bin_op + - 311 store_field 3 (args_json) - - 1116 312 jump -303 (to 9) - - 1110 313 load_var 40 (d) - 314 load_field 1 (text) - 315 store_var 43 (_127) - 316 load_var 43 (_127) - 317 narrow_bind 6 43 - 318 pop_jump_if_false -309 (to 9) - - 1111 319 load_type 0 - 320 load_var2 3 43 - - 1110 321 init_instance 1 (ai.stream.TextDelta .text) - - 1111 322 call 4 ntypeargs=1 (baml.Array.push) - 323 pop 1 - 324 jump -315 (to 9) - - 1071 325 load_var 11 (event) - 326 load_field 3 (content_block) - 327 store_var 24 (_74) - 328 load_var 24 (_74) - 329 narrow_bind 29 24 - 330 pop_jump_if_false -321 (to 9) - 331 load_var 24 (_74) - 332 store_var_load_var 25 (block) - - 1072 333 load_field 0 (type) - 334 store_var_load_var 27 (_77) - 335 load_const 8 (null) - 336 cmp_op == - 337 pop_jump_if_false +3 (to 340) - 338 load_const 30 ("") - 339 store_var 27 (_77) - 340 load_var 27 (_77) - 341 store_var_load_var 26 (kind) - - 1073 342 load_const 31 ("tool_use") - 343 cmp_op == - 344 pop_jump_if_false +2 (to 346) - 345 jump +45 (to 390) - 346 load_var 26 (kind) - 347 load_const 32 ("thinking") - 348 cmp_op == - 349 pop_jump_if_false +2 (to 351) - 350 jump +18 (to 368) - - 1091 351 load_var 25 (block) - 352 load_field 3 (text) - 353 store_var 37 (_109) - 354 load_var 37 (_109) - 355 narrow_bind 6 37 - 356 pop_jump_if_false -347 (to 9) - 357 load_var 37 (_109) - 358 store_var_load_var 38 (text) - - 1092 359 load_const 33 ("") - 360 cmp_op != - 361 pop_jump_if_false -352 (to 9) - - 1093 362 load_type 0 - 363 load_var2 3 38 - 364 init_instance 2 (ai.stream.TextDelta .text) - 365 call 4 ntypeargs=1 (baml.Array.push) - 366 pop 1 - 367 jump -358 (to 9) - - 1086 368 load_type 24 - 369 load_var 2 (state) - 370 load_field 0 (thinking) - 371 call 138 ntypeargs=1 (baml.String.from) - 372 store_var 34 (_99) - 373 load_var 25 (block) - 374 load_field 4 (thinking) - 375 store_var_load_var 36 (_104) - 376 load_const 8 (null) - 377 cmp_op == - 378 pop_jump_if_false +3 (to 381) - 379 load_const 34 ("") - 380 store_var 36 (_104) - 381 load_type 24 - 382 load_var 36 (_104) - 383 call 138 ntypeargs=1 (baml.String.from) - 384 store_var 35 (_102) - 385 load_var2 2 34 - 386 load_var 35 (_102) - 387 bin_op + - 388 store_field 0 (thinking) - - 1073 389 jump -380 (to 9) - - 1075 390 load_var 2 (state) - 391 load_field 2 (tool_calls) - 392 store_var 28 (_82) - - 1077 393 load_var 11 (event) - 394 load_field 1 (index) - 395 store_var_load_var 30 (_85) - 396 load_const 8 (null) - 397 cmp_op == - 398 pop_jump_if_false +5 (to 403) - 399 load_var 2 (state) - 400 load_field 2 (tool_calls) - 401 container_len - 402 store_var 30 (_85) - 403 load_var 30 (_85) - 404 store_var 29 (_84) - - 1078 405 load_var 25 (block) - 406 load_field 1 (id) - 407 store_var_load_var 32 (_90) - 408 load_const 8 (null) - 409 cmp_op == - 410 pop_jump_if_false +3 (to 413) - 411 load_const 35 ("") - 412 store_var 32 (_90) - 413 load_var 32 (_90) - 414 store_var 31 (_89) - - 1079 415 load_var 25 (block) - 416 load_field 2 (name) - 417 store_var_load_var 33 (_94) - 418 load_const 8 (null) - 419 cmp_op == - 420 pop_jump_if_false +3 (to 423) - 421 load_const 36 ("") - 422 store_var 33 (_94) - - 1075 423 load_type 37 - 424 load_var2 28 29 - - 1076 425 load_var2 31 33 - - 1079 426 load_const 38 ("") - 427 init_instance 3 (anthropic.internal.AnthStreamToolCall .index, .id, .name, .args_json) - - 1075 428 call 4 ntypeargs=1 (baml.Array.push) - 429 pop 1 - 430 jump -421 (to 9) - - 1045 431 load_var 11 (event) - 432 load_field 4 (message) - 433 store_var 15 (_32) - 434 load_var 15 (_32) - 435 narrow_bind 39 15 - 436 pop_jump_if_false +55 (to 491) - 437 load_var 15 (_32) - 438 store_var 16 (message) - - 1046 439 load_var2 2 16 - 440 load_field 1 (model) - 441 store_field 7 (model) - - 1047 442 load_var 16 (message) - 443 load_field 3 (usage) - 444 store_var 17 (_35) - 445 load_var 17 (_35) - 446 narrow_bind 17 17 - 447 pop_jump_if_false +44 (to 491) - 448 load_var 17 (_35) - 449 store_var_load_var 18 (usage) - - 1049 450 load_field 2 (cache_read_input_tokens) - 451 store_var_load_var 19 (_37) - 452 load_const 8 (null) - 453 cmp_op == - 454 pop_jump_if_false +4 (to 458) - 455 load_var 2 (state) - 456 load_field 3 (cache_read_input_tokens) - 457 store_var 19 (_37) - 458 load_var2 2 19 - 459 store_field 3 (cache_read_input_tokens) - - 1051 460 load_var 18 (usage) - 461 load_field 3 (cache_creation_input_tokens) - 462 store_var_load_var 20 (_40) - - 1052 463 load_const 8 (null) - 464 cmp_op == - 465 pop_jump_if_false +4 (to 469) - 466 load_var 2 (state) - 467 load_field 4 (cache_creation_input_tokens) - 468 store_var 20 (_40) - - 1051 469 load_var2 2 20 - 470 store_field 4 (cache_creation_input_tokens) - - 1054 471 load_var 18 (usage) - 472 load_field 4 (output_tokens_details) - 473 load_const 8 (null) - 474 cmp_op == - 475 pop_jump_if_false +2 (to 477) - 476 jump +5 (to 481) - 477 load_var 18 (usage) - 478 load_field 4 (output_tokens_details) - 479 load_field 0 (0) - 480 jump +2 (to 482) - 481 load_const 8 (null) - 482 store_var_load_var 21 (_43) - 483 load_const 8 (null) - 484 cmp_op == - 485 pop_jump_if_false +4 (to 489) - - 1055 486 load_var 2 (state) - 487 load_field 5 (reasoning_tokens) - 488 store_var 21 (_43) - - 1054 489 load_var2 2 21 - 490 store_field 5 (reasoning_tokens) - - 1064 491 load_var 11 (event) - 492 load_field 4 (message) - 493 load_const 8 (null) - 494 cmp_op == - 495 pop_jump_if_false +2 (to 497) - 496 jump +20 (to 516) - 497 load_var 11 (event) - 498 load_field 4 (message) - 499 load_field 3 (3) - 500 load_const 8 (null) - 501 cmp_op == - 502 pop_jump_if_false +2 (to 504) - 503 jump +13 (to 516) - 504 load_var 11 (event) - 505 load_field 4 (message) - 506 load_const 8 (null) - 507 cmp_op == - 508 pop_jump_if_false +2 (to 510) - 509 jump +7 (to 516) - 510 load_var 11 (event) - 511 load_field 4 (message) - 512 load_field 3 (3) - 513 load_field 0 (0) - 514 store_var 22 (_51) - 515 jump +3 (to 518) - 516 load_const 8 (null) - 517 store_var 22 (_51) - - 1065 518 load_var 11 (event) - 519 load_field 4 (message) - 520 load_const 8 (null) - 521 cmp_op == - 522 pop_jump_if_false +2 (to 524) - 523 jump +20 (to 543) - 524 load_var 11 (event) - 525 load_field 4 (message) - 526 load_field 3 (3) - 527 load_const 8 (null) - 528 cmp_op == - 529 pop_jump_if_false +2 (to 531) - 530 jump +13 (to 543) - 531 load_var 11 (event) - 532 load_field 4 (message) - 533 load_const 8 (null) - 534 cmp_op == - 535 pop_jump_if_false +2 (to 537) - 536 jump +7 (to 543) - 537 load_var 11 (event) - 538 load_field 4 (message) - 539 load_field 3 (3) - 540 load_field 1 (1) - 541 store_var 23 (_61) - 542 jump +3 (to 545) - 543 load_const 8 (null) - 544 store_var 23 (_61) - - 1061 545 load_type 0 - 546 load_var 3 (out) - - 1062 547 load_const 8 (null) - 548 load_var2 22 23 - 549 init_instance 4 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1061 550 call 4 ntypeargs=1 (baml.Array.push) - 551 pop 1 - 552 jump -543 (to 9) - - 1042 553 load_var 11 (event) - 554 load_field 6 (error) - 555 load_var 8 (data) - 556 call 1196 ntypeargs=0 (anthropic.internal._anth_stream_failure) - 557 throw - - 1185 558 load_var 3 (out) - 559 return -} - -function anthropic.internal.anthropic_messages_body(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> string { - 723 0 load_var2 1 2 - 1 load_var 3 (stream) - 2 call 1184 ntypeargs=0 (anthropic.internal.anthropic_messages_request) - 3 store_var 4 (request) - - 724 4 load_type 0 - 5 load_var 4 (request) - 6 call 355 ntypeargs=1 (baml.json.to_json) - 7 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - - 725 8 load_var 1 (params) - 9 load_field 8 (request_body) - 10 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 11 call 351 ntypeargs=0 (baml.json.stringify) - 12 return -} - -function anthropic.internal.anthropic_messages_request(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> anthropic.internal.AnthropicMessagesRequest { - 630 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 4 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 4 (_5) - 7 call_indirect - - 631 8 call 1175 ntypeargs=0 (anthropic.internal._anthropic_lower_prompt) - 9 store_var 5 (lowered_prompt) - - 632 10 load_var 5 (lowered_prompt) - 11 load_field 0 (system) - 12 store_var 6 (system) - - 633 13 load_var 5 (lowered_prompt) - 14 load_field 1 (messages) - 15 store_var 7 (lowered) - - 637 16 load_var 2 (input) - 17 load_field 1 (journal) - 18 load_var 1 (params) - 19 load_field 9 (client_id) - 20 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 636 21 call 1178 ntypeargs=0 (anthropic.internal._anthropic_lower_journal) - 22 load_type 0 - 23 load_const 1 ("iter") - 24 virtual_call nargs=1 ntypeargs=0 - 25 store_var 8 (_16) - 26 load_var 8 (_16) - 27 load_type 2 - 28 load_const 3 ("next") - 29 virtual_call nargs=1 ntypeargs=0 - 30 store_var 9 (_17) - 31 load_var 9 (_17) - 32 is_type 4 - 33 pop_jump_if_false +2 (to 35) - 34 jump +6 (to 40) - - 639 35 load_type 5 - 36 load_var2 7 9 - 37 call 4 ntypeargs=1 (baml.Array.push) - 38 pop 1 - 39 jump -13 (to 26) - - 645 40 load_type 5 - 41 load_var 7 (lowered) - 42 load_const 6 (0) - 43 call 3 ntypeargs=1 (baml.Array.at) - 44 load_const 7 (null) - 45 cmp_op == - 46 pop_jump_if_false +2 (to 48) - 47 jump +7 (to 54) - 48 load_type 5 - 49 load_var 7 (lowered) - 50 load_const 6 (0) - 51 call 3 ntypeargs=1 (baml.Array.at) - 52 load_field 0 (0) - 53 jump +2 (to 55) - 54 load_const 7 (null) - 55 store_var_load_var 11 (_25) - 56 load_const 7 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 8 ("") - 60 store_var 11 (_25) - 61 load_var 11 (_25) - 62 store_var_load_var 10 (first_role) - - 649 63 load_const 9 ("user") - 64 cmp_op != - 65 jump_if_false +3 (to 68) - 66 pop 1 - 67 jump +3 (to 70) - 68 store_var 12 (promote_system) - 69 jump +8 (to 77) - 70 load_var 6 (system) - 71 container_len - 72 store_var 13 (_36) - 73 load_var 13 (_36) - 74 load_const 6 (0) - 75 cmp_int_op > - 76 store_var 12 (promote_system) - - 653 77 load_var 7 (lowered) - 78 container_len - 79 store_var 14 (_40) - 80 load_var 14 (_40) - 81 load_const 6 (0) - 82 cmp_int_op > - 83 jump_if_false +5 (to 88) - 84 pop 1 - 85 load_var 10 (first_role) - 86 load_const 10 ("user") - 87 cmp_op != - 88 jump_if_false +8 (to 96) - 89 pop 1 - 90 load_var 6 (system) - 91 container_len - 92 store_var 15 (_42) - 93 load_var 15 (_42) - 94 load_const 6 (0) - 95 cmp_int_op == - - 654 96 load_var 12 (promote_system) - 97 pop_jump_if_false +2 (to 99) - 98 jump +20 (to 118) - - 656 99 pop_jump_if_false +2 (to 101) - 100 jump +3 (to 103) - - 665 101 load_var 7 (lowered) - - 656 102 jump +25 (to 127) - - 657 103 load_type 5 - - 658 104 load_const 11 ("user") - 105 load_const 12 (false) - - 661 106 load_const 13 ("text") - 107 load_const 14 ("(continue)") - 108 load_const 7 (null) - 109 init_instance 0 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 110 load_type 15 - 111 alloc_array 1 - 112 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 113 load_type 5 - 114 alloc_array 1 - - 663 115 load_var 7 (lowered) - - 657 116 call 7 ntypeargs=1 (baml.Array.concat) - 117 jump +10 (to 127) - - 655 118 load_type 5 - 119 load_const 16 ("user") - 120 load_const 12 (false) - 121 load_var 6 (system) - 122 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 123 load_type 5 - 124 alloc_array 1 - 125 load_var 7 (lowered) - 126 call 7 ntypeargs=1 (baml.Array.concat) - - 667 127 call 1179 ntypeargs=0 (anthropic.internal._anthropic_render_messages) - 128 store_var 16 (messages) - - 668 129 load_var 16 (messages) - 130 container_len - 131 store_var 17 (_60) - 132 load_var 17 (_60) - 133 load_const 6 (0) - 134 cmp_int_op == - 135 pop_jump_if_false +2 (to 137) - 136 jump +86 (to 222) - - 679 137 load_var 12 (promote_system) - 138 jump_if_false +2 (to 140) - 139 jump +8 (to 147) - 140 pop 1 - 141 load_var 6 (system) - 142 container_len - 143 store_var 19 (_65) - 144 load_var 19 (_65) - 145 load_const 6 (0) - 146 cmp_int_op == - 147 pop_jump_if_false +2 (to 149) - 148 jump +4 (to 152) - - 682 149 load_var 6 (system) - 150 store_var 18 (system_param) - - 679 151 jump +3 (to 154) - - 680 152 load_const 7 (null) - 153 store_var 18 (system_param) - - 684 154 load_var 2 (input) - 155 load_field 2 (toolbox) - 156 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 157 unary_op ! - 158 store_var_load_var 20 (has_tools) - - 685 159 pop_jump_if_false +2 (to 161) - 160 jump +4 (to 164) - - 688 161 load_const 7 (null) - 162 store_var 21 (tool_params) - - 685 163 jump +5 (to 168) - - 686 164 load_var 2 (input) - 165 load_field 2 (toolbox) - 166 call 1181 ntypeargs=0 (anthropic.internal._anthropic_tool_params) - 167 store_var 21 (tool_params) - - 690 168 load_var 20 (has_tools) - 169 pop_jump_if_false +2 (to 171) - 170 jump +4 (to 174) - - 693 171 load_const 7 (null) - 172 store_var 22 (choice) - - 690 173 jump +5 (to 178) - - 691 174 load_var 1 (params) - 175 load_field 7 (tool_choice) - 176 call 1182 ntypeargs=0 (anthropic.internal._anthropic_tool_choice_param) - 177 store_var 22 (choice) - - 695 178 load_var 3 (stream) - 179 pop_jump_if_false +2 (to 181) - 180 jump +4 (to 184) - - 698 181 load_const 7 (null) - 182 store_var 23 (stream_flag) - - 695 183 jump +3 (to 186) - - 696 184 load_const 17 (true) - 185 store_var 23 (stream_flag) - - 701 186 load_var 1 (params) - 187 load_field 0 (model) - 188 store_var 24 (_76) - - 702 189 load_var 1 (params) - 190 load_field 1 (max_tokens) - 191 store_var 25 (_77) - - 703 192 load_var 18 (system_param) - 193 store_var 26 (_78) - - 705 194 load_var 21 (tool_params) - 195 store_var 27 (_80) - - 706 196 load_var 22 (choice) - 197 store_var 28 (_81) - - 707 198 load_var 1 (params) - 199 load_field 2 (temperature) - 200 store_var 29 (_82) - - 708 201 load_var 1 (params) - 202 load_field 3 (top_p) - 203 store_var 30 (_83) - - 709 204 load_var 1 (params) - 205 load_field 4 (top_k) - 206 store_var 31 (_84) - - 710 207 load_var 1 (params) - 208 load_field 5 (stop_sequences) - 209 store_var 32 (_85) - - 711 210 load_var 1 (params) - 211 load_field 6 (thinking) - 212 call 1183 ntypeargs=0 (anthropic.internal._anthropic_thinking_param) - 213 store_var 33 (_86) - - 700 214 load_var2 24 25 - 215 load_var2 26 16 - - 704 216 load_var2 27 28 - 217 load_var2 29 30 - 218 load_var2 31 32 - 219 load_var2 33 23 - - 712 220 init_instance 3 (anthropic.internal.AnthropicMessagesRequest .model, .max_tokens, .system, .messages, .tools, .tool_choice, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .stream) - 221 return - - 669 222 load_const 18 ("anthropic") - 223 load_const 7 (null) - 224 load_const 19 ("the rendered prompt and journal produced no message content") - 225 load_const 7 (null) - 226 init_instance 4 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 227 throw -} - -function anthropic.internal.anthropic_parse(resp: anthropic.internal.AnthropicResponse) -> ai.ModelTurn { - 808 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (content) - - 809 3 load_var 1 (resp) - 4 load_field 4 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +84 (to 101) - 18 load_var 4 (_5) - 19 store_var 5 (b) - - 810 20 load_var 5 (b) - 21 load_field 0 (type) - 22 store_var_load_var 6 (_9) - 23 load_const 6 ("text") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +61 (to 87) - 27 load_var 6 (_9) - 28 load_const 7 ("thinking") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +42 (to 73) - 32 load_var 6 (_9) - 33 load_const 8 ("tool_use") - 34 cmp_op == - 35 pop_jump_if_false -26 (to 9) - - 823 36 load_var 5 (b) - 37 load_field 4 (id) - 38 store_var_load_var 10 (_31) - 39 load_const 9 (null) - 40 cmp_op == - 41 pop_jump_if_false +3 (to 44) - 42 load_const 10 ("") - 43 store_var 10 (_31) - 44 load_var 10 (_31) - 45 store_var 9 (_30) - - 824 46 load_var 5 (b) - 47 load_field 5 (name) - 48 store_var_load_var 12 (_35) - 49 load_const 9 (null) - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - 52 load_const 11 ("") - 53 store_var 12 (_35) - 54 load_var 12 (_35) - 55 store_var 11 (_34) - - 825 56 load_var 5 (b) - 57 load_field 6 (input) - 58 store_var_load_var 13 (_39) - 59 load_const 9 (null) - 60 cmp_op == - 61 pop_jump_if_false +5 (to 66) - - 820 62 load_type 12 - 63 load_type 13 - 64 alloc_map 0 - 65 store_var 13 (_39) - - 821 66 load_type 0 - 67 load_var2 2 9 - - 822 68 load_var2 11 13 - - 825 69 init_instance 0 (ai.content.ToolUse .id, .name, .args) - - 821 70 call 4 ntypeargs=1 (baml.Array.push) - 71 pop 1 - 72 jump -63 (to 9) - - 816 73 load_var 5 (b) - 74 load_field 2 (thinking) - 75 store_var_load_var 8 (_22) - 76 load_const 9 (null) - 77 cmp_op == - 78 pop_jump_if_false +3 (to 81) - 79 load_const 14 ("") - 80 store_var 8 (_22) - 81 load_type 0 - 82 load_var2 2 8 - 83 init_instance 1 (ai.content.Reasoning .summary) - 84 call 4 ntypeargs=1 (baml.Array.push) - 85 pop 1 - 86 jump -77 (to 9) - - 812 87 load_var 5 (b) - 88 load_field 1 (text) - 89 store_var_load_var 7 (_14) - 90 load_const 9 (null) - 91 cmp_op == - 92 pop_jump_if_false +3 (to 95) - 93 load_const 15 ("") - 94 store_var 7 (_14) - 95 load_type 0 - 96 load_var2 2 7 - 97 init_instance 2 (ai.content.Text .text) - 98 call 4 ntypeargs=1 (baml.Array.push) - 99 pop 1 - 100 jump -91 (to 9) - - 836 101 load_var 1 (resp) - 102 load_field 5 (stop_reason) - 103 store_var_load_var 15 (_44) - 104 load_const 9 (null) - 105 cmp_op == - 106 pop_jump_if_false +2 (to 108) - 107 jump +5 (to 112) - 108 load_var 15 (_44) - - 838 109 call 1190 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) - 110 store_var 14 (stop) - 111 jump +4 (to 115) - - 837 112 load_const 16 (ai.content.StopReason.Complete) - 113 alloc_variant 774 (ai.content.StopReason) - 114 store_var 14 (stop) - - 841 115 load_var 1 (resp) - 116 load_field 7 (usage) - 117 store_var 17 (_50) - 118 load_var 17 (_50) - 119 narrow_bind 17 17 - 120 pop_jump_if_false +2 (to 122) - 121 jump +4 (to 125) - - 855 122 load_const 9 (null) - 123 store_var 16 (usage) - - 841 124 jump +42 (to 166) - 125 load_var 17 (_50) - 126 store_var_load_var 18 (u) - - 844 127 load_field 0 (input_tokens) - 128 store_var_load_var 20 (_53) - 129 load_const 9 (null) - 130 cmp_op == - 131 pop_jump_if_false +3 (to 134) - 132 load_const 16 (0) - 133 store_var 20 (_53) - 134 load_var 20 (_53) - 135 store_var 19 (_52) - - 845 136 load_var 18 (u) - 137 load_field 1 (output_tokens) - 138 store_var_load_var 22 (_57) - 139 load_const 9 (null) - 140 cmp_op == - 141 pop_jump_if_false +3 (to 144) - 142 load_const 16 (0) - 143 store_var 22 (_57) - 144 load_var 22 (_57) - 145 store_var 21 (_56) - - 850 146 load_var 18 (u) - 147 load_field 3 (cache_read_input_tokens) - 148 store_var 23 (_60) - - 852 149 load_var 18 (u) - 150 load_field 2 (output_tokens_details) - 151 load_const 9 (null) - 152 cmp_op == - 153 pop_jump_if_false +2 (to 155) - 154 jump +6 (to 160) - 155 load_var 18 (u) - 156 load_field 2 (output_tokens_details) - 157 load_field 0 (0) - 158 store_var 24 (_61) - 159 jump +3 (to 162) - 160 load_const 9 (null) - 161 store_var 24 (_61) - - 843 162 load_var2 19 21 - 163 load_var2 23 24 - 164 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 165 store_var 16 (usage) - - 858 166 load_var2 2 14 - 167 load_var 16 (usage) - 168 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) - 169 return -} - -function anthropic.internal.anthropic_render(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> baml.http.Request { - 786 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - 3 return -} - -function anthropic.internal.invoke(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 863 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - 3 store_var 3 (req) - - 864 4 load_type 1 - 5 load_var 3 (req) - 6 load_const 2 ("anthropic") - 7 call 931 ntypeargs=1 (ai.wire.send_as) - - 865 8 call 1191 ntypeargs=0 (anthropic.internal.anthropic_parse) - 9 return -} - -function anthropic.internal.invoke_stream(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 7 - 1 make_cell - 2 store_var 7 - - 1220 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - - 1221 6 sys_op 252 (baml.http.fetch_sse) - 7 store_var 3 (sse) - 8 jump +30 (to 38) - 9 load_var 4 (e) - 10 is_type 1 - 11 pop_jump_if_false +2 (to 13) - 12 jump +22 (to 34) - 13 load_var 4 (e) - 14 is_type 2 - 15 pop_jump_if_false +2 (to 17) - 16 jump +3 (to 19) - 17 load_var 4 (e) - 18 rethrow - - 1226 19 load_type 3 - 20 load_var 4 (e) - 21 call 138 ntypeargs=1 (baml.String.from) - 22 store_var 6 (_14) - 23 load_type 4 - 24 load_var 6 (_14) - 25 call 138 ntypeargs=1 (baml.String.from) - 26 store_var 5 (_13) - - 1224 27 load_const 5 ("anthropic") - - 1226 28 load_const 6 ("the streaming request timed out: ") - 29 load_var 5 (_13) - 30 bin_op + - 31 load_const 7 (null) - 32 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 33 throw - - 1222 34 load_var 4 (e) - 35 load_field 0 (message) - 36 call 1198 ntypeargs=0 (anthropic.internal._anthropic_sse_failure) - 37 throw - - 1231 38 call 1193 ntypeargs=0 (anthropic.internal.AnthStreamState.new) - 39 store_deref 7 - - 1238 40 load_var2 3 7 - - 1239 41 make_closure 3362 1 - 42 load_const 8 ("anthropic") - - 1237 43 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 44 return -} - -function assert.approx_equal(actual: float, expected: float, eps: float) -> void { - 77 0 load_var 3 (eps) - 1 load_const 0 (0.0) - 2 cmp_float_op < - 3 jump_if_false +2 (to 5) - 4 jump +4 (to 8) - 5 pop 1 - 6 load_var 3 (eps) - 7 call 95 ntypeargs=0 (baml.Float.is_nan) - 8 pop_jump_if_false +4 (to 12) - - 78 9 load_const 1 ("assertion failed: epsilon must be a non-negative number") - 10 call 277 ntypeargs=0 (baml.sys.panic) - 11 pop 1 - - 80 12 load_var2 1 2 - 13 sub_float - 14 call 98 ntypeargs=0 (baml.Float.abs) - 15 store_var 4 (delta) - - 81 16 load_var 4 (delta) - 17 call 95 ntypeargs=0 (baml.Float.is_nan) - 18 jump_if_false +2 (to 20) - 19 jump +4 (to 23) - 20 pop 1 - 21 load_var2 4 3 - 22 cmp_float_op > - 23 pop_jump_if_false +2 (to 25) - 24 jump +3 (to 27) - 25 load_const 2 (null) - 26 jump +35 (to 61) - - 83 27 load_type 3 - 28 load_var 4 (delta) - 29 call 138 ntypeargs=1 (baml.String.from) - 30 store_var 5 (_20) - 31 load_type 3 - 32 load_var 3 (eps) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 6 (_23) - 35 load_type 3 - 36 load_var 1 (actual) - 37 call 138 ntypeargs=1 (baml.String.from) - 38 store_var 7 (_25) - 39 load_type 3 - 40 load_var 2 (expected) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 8 (_27) - 43 load_const 4 ("assertion failed: |left - right| = \"") - 44 load_var 5 (_20) - 45 bin_op + - 46 load_const 5 ("\", eps = \"") - 47 bin_op + - 48 load_var 6 (_23) - 49 bin_op + - 50 load_const 6 ("\", left = \"") - 51 bin_op + - 52 load_var 7 (_25) - 53 bin_op + - 54 load_const 7 ("\", right = \"") - 55 bin_op + - 56 load_var 8 (_27) - 57 bin_op + - 58 load_const 8 ("\"") - 59 bin_op + - - 82 60 call 277 ntypeargs=0 (baml.sys.panic) - 61 return -} - -function assert.contains(haystack: string, needle: string) -> void { - 90 0 load_var2 1 2 - 1 call 147 ntypeargs=0 (baml.String.includes) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +3 (to 9) - - 91 7 load_const 1 ("assertion failed: string does not contain expected substring") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function assert.equal(actual: unknown, expected: unknown) -> void { - 55 0 load_var2 1 2 - 1 call 672 ntypeargs=0 (baml.ops.equals_equals) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +23 (to 29) - - 57 7 load_var 1 (actual) - 8 call 898 ntypeargs=0 (assert.format_operand) - 9 store_var 4 (_9) - 10 load_type 1 - 11 load_var 4 (_9) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 3 (_8) - 14 load_var 2 (expected) - 15 call 898 ntypeargs=0 (assert.format_operand) - 16 store_var 6 (_12) - 17 load_type 1 - 18 load_var 6 (_12) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 5 (_11) - 21 load_const 2 ("assertion failed: left = ") - 22 load_var 3 (_8) - 23 bin_op + - 24 load_const 3 (", right = ") - 25 bin_op + - 26 load_var 5 (_11) - 27 bin_op + - - 56 28 call 277 ntypeargs=0 (baml.sys.panic) - 29 return -} - -function assert.format_operand(value: unknown) -> string { - 34 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +5 (to 10) - - 36 6 load_type 1 - 7 load_var 1 (value) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 jump +10 (to 19) - - 35 10 load_type 2 - - 34 11 load_var 2 (_2) - - 35 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 3 (_5) - 14 load_const 3 ("\"") - 15 load_var 3 (_5) - 16 bin_op + - 17 load_const 4 ("\"") - 18 bin_op + - 19 return -} - -function assert.is_true(condition: bool) -> void { - 5 0 load_var 1 (condition) - 1 unary_op ! - 2 pop_jump_if_false +2 (to 4) - 3 jump +3 (to 6) - 4 load_const 0 (null) - 5 jump +3 (to 8) - - 6 6 load_const 1 ("assertion failed: expected true") - 7 call 277 ntypeargs=0 (baml.sys.panic) - 8 return -} - -function assert.is_type(actual: unknown) -> #0 { - 97 0 load_var 1 (actual) - 1 is_type 0 - 2 pop_jump_if_false +2 (to 4) - 3 jump +20 (to 23) - - 101 4 load_type 1 - - 100 5 load_type 0 - - 101 6 call 138 ntypeargs=1 (baml.String.from) - 7 store_var 2 (_8) - 8 load_type 2 - 9 load_var 1 (actual) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 3 (_11) - 12 load_const 3 ("assertion failed: expected type \"") - 13 load_var 2 (_8) - 14 bin_op + - 15 load_const 4 ("\", got \"") - 16 bin_op + - 17 load_var 3 (_11) - 18 bin_op + - 19 load_const 5 ("\"") - 20 bin_op + - 21 call 277 ntypeargs=0 (baml.sys.panic) - 22 jump +2 (to 24) - - 98 23 load_var 1 (actual) - 24 return -} - -function assert.not_null(value: unknown | null) -> void { - 12 0 load_var 1 (value) - 1 load_const 0 (null) - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +3 (to 9) - - 13 7 load_const 1 ("assertion failed: expected non-null value") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function aws.BedrockClient.ai.Client.id(self: aws.BedrockClient) -> string { - 146 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("bedrock/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function aws.BedrockClient.ai.Client.invoke(self: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 150 0 load_var2 1 2 - 1 call 1327 ntypeargs=0 (aws.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 151 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function aws.BedrockClient.new(model: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null, endpoint_url: string | baml.env.Ref | null, max_tokens: int | null, temperature: float | null, top_p: float | null, stop_sequences: string[] | null, tool_choice: string | null, cache_system_prompt: bool, cache_tools: bool, additional_model_request_fields: baml.json.json | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> aws.BedrockClient { - 0 load_var 2 (region) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 97 4 load_const 1 (null) - 5 store_var 2 (region) - 6 load_var 3 (profile) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 98 10 load_const 1 (null) - 11 store_var 3 (profile) - 12 load_var 4 (access_key_id) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 99 16 load_const 1 (null) - 17 store_var 4 (access_key_id) - 18 load_var 5 (secret_access_key) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 100 22 load_const 1 (null) - 23 store_var 5 (secret_access_key) - 24 load_var 6 (session_token) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 101 28 load_const 1 (null) - 29 store_var 6 (session_token) - 30 load_var 7 (endpoint_url) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 102 34 load_const 1 (null) - 35 store_var 7 (endpoint_url) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 103 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (temperature) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 104 46 load_const 1 (null) - 47 store_var 9 (temperature) - 48 load_var 10 (top_p) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 105 52 load_const 1 (null) - 53 store_var 10 (top_p) - 54 load_var 11 (stop_sequences) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 106 58 load_const 1 (null) - 59 store_var 11 (stop_sequences) - 60 load_var 12 (tool_choice) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 107 64 load_const 1 (null) - 65 store_var 12 (tool_choice) - 66 load_var 13 (cache_system_prompt) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 108 70 load_const 2 (false) - 71 store_var 13 (cache_system_prompt) - 72 load_var 14 (cache_tools) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 109 76 load_const 2 (false) - 77 store_var 14 (cache_tools) - 78 load_var 15 (additional_model_request_fields) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 110 82 load_const 1 (null) - 83 store_var 15 (additional_model_request_fields) - 84 load_var 16 (request_body) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 111 88 load_const 1 (null) - 89 store_var 16 (request_body) - 90 load_var 17 (headers) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 112 94 load_const 1 (null) - 95 store_var 17 (headers) - 96 load_var 18 (query_params) - 97 load_const 0 () - 98 cmp_op == - 99 pop_jump_if_false +3 (to 102) - - 113 100 load_const 1 (null) - 101 store_var 18 (query_params) - - 115 102 load_var2 1 2 - 103 load_var2 3 4 - 104 load_var2 5 6 - 105 load_var2 7 8 - 106 load_var2 9 10 - 107 load_var2 11 12 - 108 load_var2 13 14 - 109 load_var2 15 16 - 110 load_var2 17 18 - 111 init_instance 0 (aws.BedrockClient .model, .region, .profile, .access_key_id, .secret_access_key, .session_token, .endpoint_url, .max_tokens, .temperature, .top_p, .stop_sequences, .tool_choice, .cache_system_prompt, .cache_tools, .additional_model_request_fields, .request_body, .headers, .query_params) - 112 return -} - -function aws.BedrockClient.resolved_endpoint_url(self: aws.BedrockClient) -> string | null { - 141 0 load_var 1 (self) - 1 load_field 6 (endpoint_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function aws.internal.ContentBlock.of_audio(audio: aws.internal.AudioBlock) -> aws.internal.ContentBlock { - 175 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document) - 5 load_var 1 (audio) - 6 init_field 4 (audio) - 7 load_var 2 (_2) - 8 init_spread 1 (.toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_cache_point() -> aws.internal.ContentBlock { - 187 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 1 (_1) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 1 (_1) - 4 init_spread 0 (.text, .image, .video, .document, .audio, .toolUse, .toolResult) - 5 load_const 0 ("default") - 6 init_instance 0 (aws.internal.CachePointBlock .type) - 7 init_field 7 (cachePoint) - 8 return -} - -function aws.internal.ContentBlock.of_document(document: aws.internal.DocumentBlock) -> aws.internal.ContentBlock { - 171 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video) - 5 load_var 1 (document) - 6 init_field 3 (document) - 7 load_var 2 (_2) - 8 init_spread 1 (.audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_image(image: aws.internal.ImageBlock) -> aws.internal.ContentBlock { - 163 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text) - 5 load_var 1 (image) - 6 init_field 1 (image) - 7 load_var 2 (_2) - 8 init_spread 1 (.video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_text(text: string) -> aws.internal.ContentBlock { - 159 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 1 (text) - 4 init_field 0 (text) - 5 load_var 2 (_2) - 6 init_spread 0 (.image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 7 return -} - -function aws.internal.ContentBlock.of_tool_result(tool_result: aws.internal.ToolResultBlock) -> aws.internal.ContentBlock { - 183 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document, .audio, .toolUse) - 5 load_var 1 (tool_result) - 6 init_field 6 (toolResult) - 7 load_var 2 (_2) - 8 init_spread 1 (.cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_tool_use(tool_use: aws.internal.ToolUseBlock) -> aws.internal.ContentBlock { - 179 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document, .audio) - 5 load_var 1 (tool_use) - 6 init_field 5 (toolUse) - 7 load_var 2 (_2) - 8 init_spread 1 (.toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_video(video: aws.internal.VideoBlock) -> aws.internal.ContentBlock { - 167 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image) - 5 load_var 1 (video) - 6 init_field 2 (video) - 7 load_var 2 (_2) - 8 init_spread 1 (.document, .audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.SystemContentBlock.of_cache_point() -> aws.internal.SystemContentBlock { - 216 0 load_const 0 (null) - 1 load_const 1 ("default") - 2 init_instance 0 (aws.internal.CachePointBlock .type) - 3 init_instance 1 (aws.internal.SystemContentBlock .text, .cachePoint) - 4 return -} - -function aws.internal.SystemContentBlock.of_text(text: string) -> aws.internal.SystemContentBlock { - 212 0 load_var 1 (text) - 1 load_const 0 (null) - 2 init_instance 0 (aws.internal.SystemContentBlock .text, .cachePoint) - 3 return -} - -function aws.internal.ToolEntry.of_cache_point() -> aws.internal.ToolEntry { - 271 0 load_const 0 (null) - 1 load_const 1 ("default") - 2 init_instance 0 (aws.internal.CachePointBlock .type) - 3 init_instance 1 (aws.internal.ToolEntry .toolSpec, .cachePoint) - 4 return -} - -function aws.internal.ToolEntry.of_spec(spec: aws.internal.ToolSpec) -> aws.internal.ToolEntry { - 267 0 load_var 1 (spec) - 1 load_const 0 (null) - 2 init_instance 0 (aws.internal.ToolEntry .toolSpec, .cachePoint) - 3 return -} - -function aws.internal.ToolInputSchema.baml.ToJson.to_json(self: aws.internal.ToolInputSchema) -> baml.json.json { - 247 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (out) - - 248 4 load_type 0 - 5 load_type 1 - 6 load_var 2 (out) - 7 load_const 2 ("json") - 8 load_var 1 (self) - 9 load_field 0 (json_schema) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 249 12 load_var 2 (out) - 13 return -} - -function aws.internal._apply_query(url: string, params: map | null) -> string { - 1076 0 load_var 2 (params) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +108 (to 112) - - 1079 5 load_type 1 - 6 alloc_array 0 - 7 store_var 3 (pairs) - - 1080 8 load_type 1 - 9 load_type 1 - 10 load_var 2 (params) - 11 call 35 ntypeargs=2 (baml.Map.keys) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 4 (_9) - 16 load_var 4 (_9) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 5 (_10) - 21 load_var 5 (_10) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +35 (to 59) - 25 load_var 5 (_10) - 26 store_var_load_var 6 (name) - - 1082 27 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 28 store_var 8 (_18) - 29 load_type 1 - 30 load_var 8 (_18) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 7 (_17) - 33 load_type 1 - 34 load_type 1 - 35 load_var2 2 6 - 36 call 38 ntypeargs=2 (baml.Map.get) - 37 store_var_load_var 11 (_24) - 38 load_const 0 (null) - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - 41 load_const 7 ("") - 42 store_var 11 (_24) - 43 load_var 11 (_24) - 44 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 45 store_var 10 (_22) - 46 load_type 1 - 47 load_var 10 (_22) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 9 (_21) - - 1081 50 load_type 1 - 51 load_var2 3 7 - - 1082 52 load_const 8 ("=") - 53 bin_op + - 54 load_var 9 (_21) - 55 bin_op + - - 1081 56 call 4 ntypeargs=1 (baml.Array.push) - 57 pop 1 - 58 jump -42 (to 16) - - 1085 59 load_var 3 (pairs) - 60 container_len - 61 store_var 12 (_33) - 62 load_var 12 (_33) - 63 load_const 9 (0) - 64 cmp_int_op == - 65 pop_jump_if_false +2 (to 67) - 66 jump +44 (to 110) - - 1087 67 load_var 1 (url) - 68 load_const 10 ("?") - 69 call 147 ntypeargs=0 (baml.String.includes) - 70 pop_jump_if_false +2 (to 72) - 71 jump +20 (to 91) - - 1090 72 load_type 1 - 73 load_var 1 (url) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 16 (_43) - 76 load_type 1 - 77 load_var 3 (pairs) - 78 load_const 11 ("&") - 79 call 15 ntypeargs=1 (baml.Array.join) - 80 store_var 18 (_46) - 81 load_type 1 - 82 load_var 18 (_46) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 17 (_45) - 85 load_var 16 (_43) - 86 load_const 12 ("?") - 87 bin_op + - 88 load_var 17 (_45) - 89 bin_op + - - 1087 90 jump +23 (to 113) - - 1088 91 load_type 1 - 92 load_var 1 (url) - 93 call 138 ntypeargs=1 (baml.String.from) - 94 store_var 13 (_36) - 95 load_type 1 - 96 load_var 3 (pairs) - 97 load_const 13 ("&") - 98 call 15 ntypeargs=1 (baml.Array.join) - 99 store_var 15 (_39) - 100 load_type 1 - 101 load_var 15 (_39) - 102 call 138 ntypeargs=1 (baml.String.from) - 103 store_var 14 (_38) - 104 load_var 13 (_36) - 105 load_const 14 ("&") - 106 bin_op + - 107 load_var 14 (_38) - 108 bin_op + - - 1087 109 jump +4 (to 113) - - 1086 110 load_var 1 (url) - - 1085 111 jump +2 (to 113) - - 1077 112 load_var 1 (url) - 113 return -} - -function aws.internal._assistant_content(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> aws.internal.ContentBlock[] { - 683 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 684 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +45 (to 61) - 17 load_var 4 (_4) - 18 store_var 5 (block) - - 685 19 load_var 5 (block) - 20 store_var 6 (_8) - 21 load_var 6 (_8) - 22 narrow_bind 6 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +28 (to 52) - 25 load_var 5 (block) - 26 store_var 8 (_14) - 27 load_var 8 (_14) - 28 narrow_bind 7 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump -22 (to 8) - 31 load_var 5 (block) - 32 store_var 9 (_15) - 33 load_var 9 (_15) - 34 narrow_bind 8 9 - 35 pop_jump_if_false +2 (to 37) - 36 jump -28 (to 8) - 37 load_var 5 (block) - 38 store_var_load_var 10 (use) - - 701 39 load_field 0 (id) - 40 load_var 10 (use) - 41 load_field 1 (name) - 42 load_var 10 (use) - 43 load_field 2 (args) - 44 init_instance 0 (aws.internal.ToolUseBlock .toolUseId, .name, .input) - - 700 45 call 1283 ntypeargs=0 (aws.internal.ContentBlock.of_tool_use) - 46 store_var 11 (_18) - - 699 47 load_type 0 - 48 load_var2 2 11 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -43 (to 8) - - 685 52 load_var 6 (_8) - 53 load_field 0 (text) - - 687 54 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 55 store_var 7 (_11) - 56 load_type 0 - 57 load_var2 2 7 - 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -52 (to 8) - - 708 61 load_var 2 (out) - 62 return -} - -function aws.internal._audio_block(audio: baml.media.Audio) -> aws.internal.ContentBlock { - 518 0 load_var 1 (audio) - 1 call 329 ntypeargs=0 (baml.media.Audio.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 521 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 call 1298 ntypeargs=0 (aws.internal._audio_format) - - 522 11 load_var 2 (resolved) - 12 load_const 0 ("audio") - 13 call 1299 ntypeargs=0 (aws.internal._media_source) - - 520 14 init_instance 0 (aws.internal.AudioBlock .format, .source) - - 519 15 call 1282 ntypeargs=0 (aws.internal.ContentBlock.of_audio) - 16 return -} - -function aws.internal._audio_format(mime: string) -> string { - 443 0 load_var 1 (mime) - 1 load_const 0 ("audio/mpeg") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +143 (to 147) - 5 load_var 1 (mime) - 6 load_const 1 ("audio/mp3") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +136 (to 145) - 10 load_var 1 (mime) - 11 load_const 2 ("audio/wav") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +129 (to 143) - 15 load_var 1 (mime) - 16 load_const 3 ("audio/x-wav") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +122 (to 141) - 20 load_var 1 (mime) - 21 load_const 4 ("audio/wave") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +115 (to 139) - 25 load_var 1 (mime) - 26 load_const 5 ("audio/flac") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +108 (to 137) - 30 load_var 1 (mime) - 31 load_const 6 ("audio/x-flac") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +101 (to 135) - 35 load_var 1 (mime) - 36 load_const 7 ("audio/ogg") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +94 (to 133) - 40 load_var 1 (mime) - 41 load_const 8 ("audio/opus") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +87 (to 131) - 45 load_var 1 (mime) - 46 load_const 9 ("audio/aac") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +80 (to 129) - 50 load_var 1 (mime) - 51 load_const 10 ("audio/x-aac") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +73 (to 127) - 55 load_var 1 (mime) - 56 load_const 11 ("audio/mp4") - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +66 (to 125) - 60 load_var 1 (mime) - 61 load_const 12 ("audio/m4a") - 62 cmp_op == - 63 pop_jump_if_false +2 (to 65) - 64 jump +59 (to 123) - 65 load_var 1 (mime) - 66 load_const 13 ("audio/x-m4a") - 67 cmp_op == - 68 pop_jump_if_false +2 (to 70) - 69 jump +52 (to 121) - 70 load_var 1 (mime) - 71 load_const 14 ("audio/x-matroska") - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +45 (to 119) - 75 load_var 1 (mime) - 76 load_const 15 ("audio/mpga") - 77 cmp_op == - 78 pop_jump_if_false +2 (to 80) - 79 jump +38 (to 117) - 80 load_var 1 (mime) - 81 load_const 16 ("audio/pcm") - 82 cmp_op == - 83 pop_jump_if_false +2 (to 85) - 84 jump +31 (to 115) - 85 load_var 1 (mime) - 86 load_const 17 ("audio/x-pcm") - 87 cmp_op == - 88 pop_jump_if_false +2 (to 90) - 89 jump +24 (to 113) - 90 load_var 1 (mime) - 91 load_const 18 ("audio/L16") - 92 cmp_op == - 93 pop_jump_if_false +2 (to 95) - 94 jump +17 (to 111) - 95 load_var 1 (mime) - 96 load_const 19 ("audio/webm") - 97 cmp_op == - 98 pop_jump_if_false +2 (to 100) - 99 jump +10 (to 109) - - 457 100 load_type 20 - 101 load_var 1 (mime) - 102 call 138 ntypeargs=1 (baml.String.from) - 103 store_var 2 (_24) - 104 load_const 21 ("unsupported audio format for Bedrock: ") - 105 load_var 2 (_24) - 106 bin_op + - 107 call 1294 ntypeargs=0 (aws.internal._reject) - 108 throw - - 456 109 load_const 22 ("webm") - - 443 110 jump +38 (to 148) - - 455 111 load_const 23 ("pcm") - - 443 112 jump +36 (to 148) - - 455 113 load_const 24 ("pcm") - - 443 114 jump +34 (to 148) - - 455 115 load_const 25 ("pcm") - - 443 116 jump +32 (to 148) - - 454 117 load_const 26 ("mpga") - - 443 118 jump +30 (to 148) - - 453 119 load_const 27 ("mka") - - 443 120 jump +28 (to 148) - - 452 121 load_const 28 ("m4a") - - 443 122 jump +26 (to 148) - - 452 123 load_const 29 ("m4a") - - 443 124 jump +24 (to 148) - - 451 125 load_const 30 ("mp4") - - 443 126 jump +22 (to 148) - - 450 127 load_const 31 ("x-aac") - - 443 128 jump +20 (to 148) - - 449 129 load_const 32 ("aac") - - 443 130 jump +18 (to 148) - - 448 131 load_const 33 ("opus") - - 443 132 jump +16 (to 148) - - 447 133 load_const 34 ("ogg") - - 443 134 jump +14 (to 148) - - 446 135 load_const 35 ("flac") - - 443 136 jump +12 (to 148) - - 446 137 load_const 36 ("flac") - - 443 138 jump +10 (to 148) - - 445 139 load_const 37 ("wav") - - 443 140 jump +8 (to 148) - - 445 141 load_const 38 ("wav") - - 443 142 jump +6 (to 148) - - 445 143 load_const 39 ("wav") - - 443 144 jump +4 (to 148) - - 444 145 load_const 40 ("mp3") - - 443 146 jump +2 (to 148) - - 444 147 load_const 41 ("mp3") - 148 return -} - -function aws.internal._conversation_role(role: string) -> string { - 624 0 load_var 1 (role) - 1 load_const 0 ("assistant") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 627 5 load_const 1 ("user") - - 624 6 jump +2 (to 8) - - 625 7 load_const 2 ("assistant") - 8 return -} - -function aws.internal._document_block(pdf: baml.media.Pdf) -> aws.internal.ContentBlock { - 499 0 load_var 1 (pdf) - 1 call 322 ntypeargs=0 (baml.media.Pdf.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 500 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 load_const 0 ("application/pdf") - 11 cmp_op != - 12 pop_jump_if_false +2 (to 14) - 13 jump +11 (to 24) - - 509 14 load_var 2 (resolved) - 15 load_const 1 ("document") - 16 call 1299 ntypeargs=0 (aws.internal._media_source) - 17 store_var 5 (_14) - - 504 18 load_const 2 ("pdf") - 19 load_const 3 ("document") - 20 load_var 5 (_14) - 21 init_instance 0 (aws.internal.DocumentBlock .format, .name, .source) - - 503 22 call 1281 ntypeargs=0 (aws.internal.ContentBlock.of_document) - 23 return - - 501 24 load_type 4 - 25 load_var 2 (resolved) - 26 load_field 2 (mime_type) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 4 (_10) - 29 load_const 5 ("unsupported document format for Bedrock: ") - 30 load_var 4 (_10) - 31 bin_op + - 32 call 1294 ntypeargs=0 (aws.internal._reject) - 33 throw -} - -function aws.internal._empty_content_block() -> aws.internal.ContentBlock { - 192 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 load_const 0 (null) - 7 load_const 0 (null) - 8 init_instance 0 (aws.internal.ContentBlock .text, .image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal._image_block(image: baml.media.Image) -> aws.internal.ContentBlock { - 477 0 load_var 1 (image) - 1 call 343 ntypeargs=0 (baml.media.Image.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 480 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 call 1296 ntypeargs=0 (aws.internal._image_format) - - 481 11 load_var 2 (resolved) - 12 load_const 0 ("image") - 13 call 1299 ntypeargs=0 (aws.internal._media_source) - - 479 14 init_instance 0 (aws.internal.ImageBlock .format, .source) - - 478 15 call 1279 ntypeargs=0 (aws.internal.ContentBlock.of_image) - 16 return -} - -function aws.internal._image_format(mime: string) -> string { - 411 0 load_var 1 (mime) - 1 load_const 0 ("image/png") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +38 (to 42) - 5 load_var 1 (mime) - 6 load_const 1 ("image/jpeg") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +31 (to 40) - 10 load_var 1 (mime) - 11 load_const 2 ("image/jpg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 1 (mime) - 16 load_const 3 ("image/gif") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 1 (mime) - 21 load_const 4 ("image/webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - - 416 25 load_type 5 - 26 load_var 1 (mime) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 2 (_9) - 29 load_const 6 ("unsupported image format for Bedrock: ") - 30 load_var 2 (_9) - 31 bin_op + - 32 call 1294 ntypeargs=0 (aws.internal._reject) - 33 throw - - 415 34 load_const 7 ("webp") - - 411 35 jump +8 (to 43) - - 414 36 load_const 8 ("gif") - - 411 37 jump +6 (to 43) - - 413 38 load_const 9 ("jpeg") - - 411 39 jump +4 (to 43) - - 413 40 load_const 10 ("jpeg") - - 411 41 jump +2 (to 43) - - 412 42 load_const 11 ("png") - 43 return -} - -function aws.internal._inference_config(client: aws.BedrockClient) -> aws.internal.InferenceConfig | null { - 866 0 load_var 1 (client) - 1 load_field 7 (max_tokens) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +13 (to 18) - 6 load_var 2 (_3) - 7 store_var_load_var 3 (limit) - - 870 8 load_const 1 (2147483647) - 9 cmp_int_op > - 10 jump_if_false +2 (to 12) - 11 jump +5 (to 16) - 12 pop 1 - 13 load_var 3 (limit) - 14 load_const 0 (0) - 15 cmp_int_op < - 16 pop_jump_if_false +2 (to 18) - 17 jump +60 (to 77) - - 876 18 load_var 1 (client) - 19 load_field 10 (stop_sequences) - 20 store_var_load_var 6 (_16) - 21 load_const 2 (null) - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +17 (to 41) - 25 load_var 6 (_16) - 26 store_var 7 (sequences) - - 879 27 load_var 7 (sequences) - 28 container_len - 29 store_var 8 (_20) - 30 load_var 8 (_20) - 31 load_const 0 (0) - 32 cmp_int_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +4 (to 38) - - 882 35 load_var 7 (sequences) - 36 store_var 5 (stops) - - 879 37 jump +6 (to 43) - - 880 38 load_const 2 (null) - 39 store_var 5 (stops) - - 879 40 jump +3 (to 43) - - 877 41 load_const 2 (null) - 42 store_var 5 (stops) - - 886 43 load_var 1 (client) - 44 load_field 7 (max_tokens) - 45 load_const 2 (null) - 46 call 672 ntypeargs=0 (baml.ops.equals_equals) - 47 jump_if_false +6 (to 53) - 48 pop 1 - - 887 49 load_var 1 (client) - 50 load_field 8 (temperature) - 51 load_const 2 (null) - 52 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 53 jump_if_false +6 (to 59) - 54 pop 1 - - 888 55 load_var 1 (client) - 56 load_field 9 (top_p) - 57 load_const 2 (null) - 58 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 59 jump_if_false +5 (to 64) - 60 pop 1 - - 889 61 load_var 5 (stops) - 62 load_const 2 (null) - 63 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 64 pop_jump_if_false +2 (to 66) - 65 jump +10 (to 75) - - 893 66 load_var 1 (client) - 67 load_field 7 (max_tokens) - - 894 68 load_var 1 (client) - 69 load_field 8 (temperature) - - 895 70 load_var 1 (client) - 71 load_field 9 (top_p) - - 896 72 load_var 5 (stops) - 73 init_instance 0 (aws.internal.InferenceConfig .maxTokens, .temperature, .topP, .stopSequences) - 74 jump +2 (to 76) - - 890 75 load_const 2 (null) - 76 return - - 872 77 load_type 3 - 78 load_var 3 (limit) - 79 call 138 ntypeargs=1 (baml.String.from) - 80 store_var 4 (_12) - 81 load_const 4 ("max_tokens value ") - 82 load_var 4 (_12) - 83 bin_op + - 84 load_const 5 (" is out of the supported range (0..=2147483647)") - 85 bin_op + - - 871 86 call 1294 ntypeargs=0 (aws.internal._reject) - 87 throw -} - -function aws.internal._is_malformed_stop(raw: string) -> bool { - 1223 0 load_var 1 (raw) - 1 load_const 0 ("malformed_model_output") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (raw) - 7 load_const 1 ("malformed_tool_use") - 8 cmp_op == - 9 return -} - -function aws.internal._is_opaque_key(key: string) -> bool { - 338 0 load_var 1 (key) - 1 load_const 0 ("additionalModelRequestFields") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("json") - 8 cmp_op == - 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - 12 load_var 1 (key) - 13 load_const 2 ("input") - 14 cmp_op == - 15 return -} - -function aws.internal._is_s3_url(url: string | null) -> bool { - 407 0 load_var 1 (url) - 1 store_var_load_var 2 (_3) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("") - 6 store_var 2 (_3) - 7 load_var 2 (_3) - 8 load_const 2 ("s3://") - 9 call 148 ntypeargs=0 (baml.String.starts_with) - 10 return -} - -function aws.internal._is_unreserved_byte(byte: int) -> bool { - 43 0 load_var 1 (byte) - 1 load_const 0 (48) - 2 cmp_int_op >= - 3 jump_if_false +5 (to 8) - 4 pop 1 - 5 load_var 1 (byte) - 6 load_const 1 (57) - 7 cmp_int_op <= - 8 jump_if_false +2 (to 10) - 9 jump +10 (to 19) - 10 pop 1 - - 44 11 load_var 1 (byte) - 12 load_const 2 (65) - 13 cmp_int_op >= - 14 jump_if_false +5 (to 19) - 15 pop 1 - 16 load_var 1 (byte) - 17 load_const 3 (90) - 18 cmp_int_op <= - - 43 19 jump_if_false +2 (to 21) - 20 jump +10 (to 30) - 21 pop 1 - - 45 22 load_var 1 (byte) - 23 load_const 4 (97) - 24 cmp_int_op >= - 25 jump_if_false +5 (to 30) - 26 pop 1 - 27 load_var 1 (byte) - 28 load_const 5 (122) - 29 cmp_int_op <= - - 43 30 jump_if_false +2 (to 32) - 31 jump +5 (to 36) - 32 pop 1 - - 46 33 load_var 1 (byte) - 34 load_const 6 (45) - 35 cmp_int_op == - - 43 36 jump_if_false +2 (to 38) - 37 jump +5 (to 42) - 38 pop 1 - - 47 39 load_var 1 (byte) - 40 load_const 7 (46) - 41 cmp_int_op == - - 43 42 jump_if_false +2 (to 44) - 43 jump +5 (to 48) - 44 pop 1 - - 48 45 load_var 1 (byte) - 46 load_const 8 (95) - 47 cmp_int_op == - - 43 48 jump_if_false +2 (to 50) - 49 jump +5 (to 54) - 50 pop 1 - - 49 51 load_var 1 (byte) - 52 load_const 9 (126) - 53 cmp_int_op == - 54 return -} - -function aws.internal._lower_journal(journal: ai.Journal, with_status: bool) -> aws.internal.Message[] { - 763 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (pending) - - 764 3 load_var 1 (journal) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +85 (to 102) - 18 load_var 5 (_6) - 19 store_var 6 (event) - - 765 20 load_var 6 (event) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +61 (to 86) - 26 load_var 6 (event) - 27 store_var 9 (_19) - 28 load_var 9 (_19) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +34 (to 65) - 32 load_var 6 (event) - 33 store_var 12 (_30) - 34 load_var 12 (_30) - 35 narrow_bind 8 12 - 36 pop_jump_if_false +2 (to 38) - 37 jump +17 (to 54) - 38 load_var 6 (event) - 39 store_var 14 (_36) - 40 load_var 14 (_36) - 41 narrow_bind 9 14 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 14 (_36) - 44 store_var 15 (failed) - - 801 45 load_var2 3 15 - 46 load_field 0 (id) - 47 load_var 15 (failed) - 48 load_field 1 (message) - 49 load_const 10 (true) - 50 load_var 2 (with_status) - 51 call 1311 ntypeargs=0 (aws.internal._push_tool_result) - 52 pop 1 - 53 jump -44 (to 9) - - 765 54 load_var 12 (_30) - 55 store_var 13 (completed) - - 798 56 load_var2 3 13 - 57 load_field 0 (id) - 58 load_var 13 (completed) - 59 load_field 1 (output) - 60 load_const 11 (false) - 61 load_var 2 (with_status) - 62 call 1311 ntypeargs=0 (aws.internal._push_tool_result) - 63 pop 1 - 64 jump -55 (to 9) - - 765 65 load_var 9 (_19) - 66 load_field 0 (content) - - 779 67 call 1309 ntypeargs=0 (aws.internal._assistant_content) - 68 store_var 10 (content) - - 787 69 load_var 10 (content) - 70 container_len - 71 store_var 11 (_24) - 72 load_var 11 (_24) - 73 load_const 12 (0) - 74 cmp_int_op > - 75 pop_jump_if_false -66 (to 9) - - 788 76 load_type 0 - 77 load_var 3 (pending) - - 790 78 load_const 13 ("assistant") - 79 load_var 10 (content) - 80 init_instance 0 (aws.internal.Message .role, .content) - 81 load_const 11 (false) - 82 init_instance 1 (aws.internal.PendingMessage .message, .tool_results) - - 788 83 call 4 ntypeargs=1 (baml.Array.push) - 84 pop 1 - 85 jump -76 (to 9) - - 765 86 load_var 7 (_10) - 87 load_field 0 (content) - - 771 88 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 89 store_var 8 (_16) - - 767 90 load_type 0 - 91 load_var 3 (pending) - - 769 92 load_const 14 ("user") - - 771 93 load_var 8 (_16) - 94 load_type 15 - 95 alloc_array 1 - 96 init_instance 2 (aws.internal.Message .role, .content) - 97 load_const 11 (false) - 98 init_instance 3 (aws.internal.PendingMessage .message, .tool_results) - - 767 99 call 4 ntypeargs=1 (baml.Array.push) - 100 pop 1 - 101 jump -92 (to 9) - - 806 102 load_type 16 - 103 alloc_array 0 - 104 store_var 16 (out) - - 807 105 load_var 3 (pending) - 106 load_type 17 - 107 load_const 18 ("iter") - 108 virtual_call nargs=1 ntypeargs=0 - 109 store_var 17 (_44) - 110 load_var 17 (_44) - 111 load_type 19 - 112 load_const 20 ("next") - 113 virtual_call nargs=1 ntypeargs=0 - 114 store_var 18 (_45) - 115 load_var 18 (_45) - 116 is_type 5 - 117 pop_jump_if_false +2 (to 119) - 118 jump +7 (to 125) - - 808 119 load_type 16 - 120 load_var2 16 18 - - 807 121 load_field 0 (message) - - 808 122 call 4 ntypeargs=1 (baml.Array.push) - 123 pop 1 - 124 jump -14 (to 110) - - 810 125 load_var 16 (out) - 126 return -} - -function aws.internal._lower_prompt(prompt: ai.Prompt) -> aws.internal.BedrockPrompt { - 640 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (system) - - 641 3 load_type 1 - 4 alloc_array 0 - 5 store_var 3 (messages) - - 642 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_6) - 17 load_var 5 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +68 (to 88) - 21 load_var 5 (_6) - 22 store_var_load_var 6 (message) - - 643 23 load_field 0 (role) - 24 load_const 7 ("system") - 25 cmp_op == - 26 pop_jump_if_false +2 (to 28) - 27 jump +31 (to 58) - - 652 28 load_var 6 (message) - 29 call 1304 ntypeargs=0 (aws.internal._prompt_content) - 30 store_var 10 (content) - - 656 31 load_var 10 (content) - 32 container_len - 33 store_var 11 (_30) - 34 load_var 11 (_30) - 35 load_const 8 (0) - 36 cmp_int_op > - 37 pop_jump_if_false -25 (to 12) - - 657 38 load_var 6 (message) - 39 call 1306 ntypeargs=0 (aws.internal._wants_cache_point) - 40 pop_jump_if_false +7 (to 47) - - 658 41 call 1285 ntypeargs=0 (aws.internal.ContentBlock.of_cache_point) - 42 store_var 12 (_34) - 43 load_type 9 - 44 load_var2 10 12 - 45 call 4 ntypeargs=1 (baml.Array.push) - 46 pop 1 - - 660 47 load_var 6 (message) - 48 load_field 0 (role) - 49 call 1307 ntypeargs=0 (aws.internal._conversation_role) - 50 store_var 13 (_38) - 51 load_type 1 - 52 load_var2 3 13 - 53 load_var 10 (content) - 54 init_instance 0 (aws.internal.Message .role, .content) - 55 call 4 ntypeargs=1 (baml.Array.push) - 56 pop 1 - 57 jump -45 (to 12) - - 644 58 load_var 6 (message) - 59 call 1305 ntypeargs=0 (aws.internal._prompt_system) - 60 load_type 10 - 61 load_const 11 ("iter") - 62 virtual_call nargs=1 ntypeargs=0 - 63 store_var 7 (_14) - 64 load_var 7 (_14) - 65 load_type 12 - 66 load_const 13 ("next") - 67 virtual_call nargs=1 ntypeargs=0 - 68 store_var 8 (_15) - 69 load_var 8 (_15) - 70 is_type 6 - 71 pop_jump_if_false +2 (to 73) - 72 jump +6 (to 78) - - 645 73 load_type 0 - 74 load_var2 2 8 - 75 call 4 ntypeargs=1 (baml.Array.push) - 76 pop 1 - 77 jump -13 (to 64) - - 647 78 load_var 6 (message) - 79 call 1306 ntypeargs=0 (aws.internal._wants_cache_point) - 80 pop_jump_if_false -68 (to 12) - - 648 81 call 1288 ntypeargs=0 (aws.internal.SystemContentBlock.of_cache_point) - 82 store_var 9 (_25) - 83 load_type 0 - 84 load_var2 2 9 - 85 call 4 ntypeargs=1 (baml.Array.push) - 86 pop 1 - 87 jump -75 (to 12) - - 665 88 load_var2 2 3 - 89 init_instance 1 (aws.internal.BedrockPrompt .system, .messages) - 90 return -} - -function aws.internal._media_source(resolved: ai.wire.ResolvedMedia, kind: string) -> aws.internal.MediaSource { - 464 0 load_var 1 (resolved) - 1 load_field 1 (base64) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +49 (to 55) - - 467 7 load_var 1 (resolved) - 8 load_field 0 (url) - 9 store_var 4 (_8) - 10 load_var 4 (_8) - 11 narrow_bind 0 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +12 (to 25) - - 473 14 load_type 1 - 15 load_var 2 (kind) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 8 (_25) - 18 load_const 2 ("Bedrock ") - 19 load_var 8 (_25) - 20 bin_op + - 21 load_const 3 (" content could not be resolved") - 22 bin_op + - 23 call 1294 ntypeargs=0 (aws.internal._reject) - 24 throw - - 467 25 load_var 4 (_8) - 26 store_var 5 (url) - - 468 27 load_var 5 (url) - 28 load_const 4 ("s3://") - 29 call 148 ntypeargs=0 (baml.String.starts_with) - 30 pop_jump_if_false +2 (to 32) - 31 jump +18 (to 49) - - 471 32 load_type 1 - 33 load_var 2 (kind) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 6 (_17) - 36 load_type 1 - 37 load_var 5 (url) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 7 (_19) - 40 load_const 5 ("Bedrock requires s3:// URIs for ") - 41 load_var 6 (_17) - 42 bin_op + - 43 load_const 6 (" URLs, got: ") - 44 bin_op + - 45 load_var 7 (_19) - 46 bin_op + - 47 call 1294 ntypeargs=0 (aws.internal._reject) - 48 throw - - 469 49 load_const 7 (null) - 50 load_var 5 (url) - 51 load_const 7 (null) - 52 init_instance 0 (aws.internal.S3Location .uri, .bucketOwner) - 53 init_instance 1 (aws.internal.MediaSource .bytes, .s3Location) - 54 jump +4 (to 58) - - 464 55 load_var 3 (_4) - 56 load_const 7 (null) - 57 init_instance 2 (aws.internal.MediaSource .bytes, .s3Location) - 58 return -} - -function aws.internal._merge_adjacent_roles(messages: aws.internal.Message[]) -> aws.internal.Message[] { - 931 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 932 3 load_var 1 (messages) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +62 (to 78) - 17 load_var 4 (_4) - 18 store_var 5 (message) - - 933 19 load_var 2 (out) - 20 container_len - 21 store_var 6 (_10) - 22 load_type 0 - 23 load_var2 2 6 - 24 load_const 6 (1) - 25 sub_int - 26 call 3 ntypeargs=1 (baml.Array.at) - 27 store_var 7 (_12) - 28 load_var 7 (_12) - 29 narrow_bind 7 7 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 7 (_12) - 32 store_var_load_var 8 (last) - - 934 33 load_field 0 (role) - 34 load_var 5 (message) - 35 load_field 0 (role) - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +18 (to 56) - - 941 39 load_var 5 (message) - 40 load_field 0 (role) - 41 store_var 11 (_29) - 42 load_type 8 - 43 load_var 5 (message) - 44 load_field 1 (content) - 45 load_type 8 - 46 alloc_array 0 - 47 call 7 ntypeargs=1 (baml.Array.concat) - 48 store_var 12 (_30) - 49 load_type 0 - 50 load_var2 2 11 - 51 load_var 12 (_30) - 52 init_instance 0 (aws.internal.Message .role, .content) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -47 (to 8) - - 935 56 load_var 5 (message) - 57 load_field 1 (content) - 58 load_type 9 - 59 load_const 10 ("iter") - 60 virtual_call nargs=1 ntypeargs=0 - 61 store_var 9 (_18) - 62 load_var 9 (_18) - 63 load_type 11 - 64 load_const 12 ("next") - 65 virtual_call nargs=1 ntypeargs=0 - 66 store_var 10 (_19) - 67 load_var 10 (_19) - 68 is_type 5 - 69 pop_jump_if_false +2 (to 71) - 70 jump -62 (to 8) - - 936 71 load_type 8 - 72 load_var 8 (last) - 73 load_field 1 (content) - - 935 74 load_var 10 (_19) - - 936 75 call 4 ntypeargs=1 (baml.Array.push) - 76 pop 1 - 77 jump -15 (to 62) - - 943 78 load_var 2 (out) - 79 return -} - -function aws.internal._merge_headers(base: map, extra: map | null) -> map { - 1057 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 3 (out) - - 1058 4 load_type 0 - 5 load_type 0 - 6 load_var 1 (base) - 7 call 35 ntypeargs=2 (baml.Map.keys) - 8 load_type 1 - 9 load_const 2 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_7) - 12 load_var 4 (_7) - 13 load_type 3 - 14 load_const 4 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_8) - 17 load_var 5 (_8) - 18 is_type 5 - 19 pop_jump_if_false +2 (to 21) - 20 jump +23 (to 43) - 21 load_var 5 (_8) - 22 store_var 6 (name) - - 1059 23 load_var 6 (name) - 24 call 142 ntypeargs=0 (baml.String.to_lower_case) - 25 store_var 7 (_13) - 26 load_type 0 - 27 load_type 0 - 28 load_var2 1 6 - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var_load_var 8 (_15) - 31 load_const 6 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 7 ("") - 35 store_var 8 (_15) - 36 load_type 0 - 37 load_type 0 - 38 load_var2 3 7 - 39 load_var 8 (_15) - 40 call 37 ntypeargs=2 (baml.Map.set) - 41 pop 1 - 42 jump -30 (to 12) - - 1061 43 load_var 2 (extra) - 44 load_const 6 (null) - 45 cmp_op == - 46 pop_jump_if_false +2 (to 48) - 47 jump +40 (to 87) - - 1064 48 load_type 0 - 49 load_type 0 - 50 load_var 2 (extra) - 51 call 35 ntypeargs=2 (baml.Map.keys) - 52 load_type 1 - 53 load_const 8 ("iter") - 54 virtual_call nargs=1 ntypeargs=0 - 55 store_var 9 (_28) - 56 load_var 9 (_28) - 57 load_type 3 - 58 load_const 9 ("next") - 59 virtual_call nargs=1 ntypeargs=0 - 60 store_var 10 (_29) - 61 load_var 10 (_29) - 62 is_type 5 - 63 pop_jump_if_false +2 (to 65) - 64 jump +23 (to 87) - 65 load_var 10 (_29) - 66 store_var 11 (name) - - 1065 67 load_var 11 (name) - 68 call 142 ntypeargs=0 (baml.String.to_lower_case) - 69 store_var 12 (_34) - 70 load_type 0 - 71 load_type 0 - 72 load_var2 2 11 - 73 call 38 ntypeargs=2 (baml.Map.get) - 74 store_var_load_var 13 (_36) - 75 load_const 6 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 10 ("") - 79 store_var 13 (_36) - 80 load_type 0 - 81 load_type 0 - 82 load_var2 3 12 - 83 load_var 13 (_36) - 84 call 37 ntypeargs=2 (baml.Map.set) - 85 pop 1 - 86 jump -30 (to 56) - - 1070 87 load_var 3 (out) - 88 return -} - -function aws.internal._prompt_content(message: ai.PromptMessage) -> aws.internal.ContentBlock[] { - 540 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (blocks) - - 541 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +74 (to 91) - 18 load_var 4 (_5) - 19 store_var 5 (part) - - 542 20 load_var 5 (part) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +51 (to 76) - 26 load_var 5 (part) - 27 store_var 9 (_17) - 28 load_var 9 (_17) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +37 (to 68) - 32 load_var 5 (part) - 33 store_var 11 (_23) - 34 load_var 11 (_23) - 35 narrow_bind 8 11 - 36 pop_jump_if_false +2 (to 38) - 37 jump +23 (to 60) - 38 load_var 5 (part) - 39 store_var 13 (_29) - 40 load_var 13 (_29) - 41 narrow_bind 9 13 - 42 pop_jump_if_false +2 (to 44) - 43 jump +9 (to 52) - 44 load_var 5 (part) - - 566 45 call 1302 ntypeargs=0 (aws.internal._document_block) - 46 store_var 15 (_37) - 47 load_type 0 - 48 load_var2 2 15 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -42 (to 9) - - 542 52 load_var 13 (_29) - - 562 53 call 1301 ntypeargs=0 (aws.internal._video_block) - 54 store_var 14 (_32) - 55 load_type 0 - 56 load_var2 2 14 - 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - 59 jump -50 (to 9) - - 542 60 load_var 11 (_23) - - 558 61 call 1303 ntypeargs=0 (aws.internal._audio_block) - 62 store_var 12 (_26) - 63 load_type 0 - 64 load_var2 2 12 - 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -58 (to 9) - - 542 68 load_var 9 (_17) - - 554 69 call 1300 ntypeargs=0 (aws.internal._image_block) - 70 store_var 10 (_20) - 71 load_type 0 - 72 load_var2 2 10 - 73 call 4 ntypeargs=1 (baml.Array.push) - 74 pop 1 - 75 jump -66 (to 9) - - 542 76 load_var 6 (_9) - 77 store_var 7 (text) - - 548 78 load_var 7 (text) - 79 call 144 ntypeargs=0 (baml.String.trim) - 80 load_const 10 ("") - 81 cmp_op != - 82 pop_jump_if_false -73 (to 9) - - 549 83 load_var 7 (text) - 84 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 85 store_var 8 (_14) - 86 load_type 0 - 87 load_var2 2 8 - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 571 91 load_var 2 (blocks) - 92 return -} - -function aws.internal._prompt_system(message: ai.PromptMessage) -> aws.internal.SystemContentBlock[] { - 577 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (blocks) - - 578 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +25 (to 42) - 18 load_var 4 (_5) - 19 store_var 5 (_9) - - 579 20 load_var 5 (_9) - 21 narrow_bind 6 5 - 22 pop_jump_if_false +2 (to 24) - 23 jump +4 (to 27) - - 589 24 load_const 7 ("Bedrock system messages do not support media content") - 25 call 1294 ntypeargs=0 (aws.internal._reject) - 26 throw - - 579 27 load_var 5 (_9) - 28 store_var 6 (text) - - 583 29 load_var 6 (text) - 30 call 144 ntypeargs=0 (baml.String.trim) - 31 load_const 8 ("") - 32 cmp_op != - 33 pop_jump_if_false -24 (to 9) - - 584 34 load_var 6 (text) - 35 call 1287 ntypeargs=0 (aws.internal.SystemContentBlock.of_text) - 36 store_var 7 (_14) - 37 load_type 0 - 38 load_var2 2 7 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -32 (to 9) - - 593 42 load_var 2 (blocks) - 43 return -} - -function aws.internal._prune_nulls(value: baml.json.json) -> baml.json.json { - 342 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +36 (to 41) - 6 load_var 1 (value) - 7 store_var 10 (_31) - 8 load_var 10 (_31) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 369 12 load_var 1 (value) - - 342 13 jump +85 (to 98) - - 363 14 load_type 2 - 15 alloc_array 0 - 16 store_var 11 (out) - - 342 17 load_var 10 (_31) - 18 load_type 3 - 19 load_const 4 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 12 (_35) - - 364 22 load_var 12 (_35) - 23 load_type 5 - 24 load_const 6 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 13 (_36) - 27 load_var 13 (_36) - 28 is_type 7 - 29 pop_jump_if_false +2 (to 31) - 30 jump +9 (to 39) - 31 load_var 13 (_36) - - 365 32 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - 33 store_var 14 (_41) - 34 load_type 2 - 35 load_var2 11 14 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -16 (to 22) - - 367 39 load_var 11 (out) - - 342 40 jump +58 (to 98) - 41 load_var 2 (_2) - 42 store_var 3 (object) - - 344 43 load_type 8 - 44 load_type 2 - 45 alloc_map 0 - 46 store_var 4 (out) - - 345 47 load_type 8 - 48 load_type 2 - 49 load_var 3 (object) - 50 call 35 ntypeargs=2 (baml.Map.keys) - 51 load_type 9 - 52 load_const 10 ("iter") - 53 virtual_call nargs=1 ntypeargs=0 - 54 store_var 5 (_8) - 55 load_var 5 (_8) - 56 load_type 11 - 57 load_const 12 ("next") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 6 (_9) - 60 load_var 6 (_9) - 61 is_type 7 - 62 pop_jump_if_false +2 (to 64) - 63 jump +34 (to 97) - 64 load_var 6 (_9) - 65 store_var 7 (key) - - 346 66 load_type 8 - 67 load_type 2 - 68 load_var2 3 7 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 8 (member) - - 347 71 load_var 8 (member) - 72 load_const 13 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump -20 (to 55) - - 350 76 load_var 7 (key) - 77 call 1292 ntypeargs=0 (aws.internal._is_opaque_key) - 78 pop_jump_if_false +2 (to 80) - 79 jump +11 (to 90) - - 354 80 load_var 8 (member) - 81 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - 82 store_var 9 (_27) - 83 load_type 8 - 84 load_type 2 - 85 load_var2 4 7 - 86 load_var 9 (_27) - 87 call 37 ntypeargs=2 (baml.Map.set) - 88 pop 1 - 89 jump -34 (to 55) - - 351 90 load_type 8 - 91 load_type 2 - 92 load_var2 4 7 - 93 load_var 8 (member) - 94 call 37 ntypeargs=2 (baml.Map.set) - 95 pop 1 - 96 jump -41 (to 55) - - 360 97 load_var 4 (out) - 98 return -} - -function aws.internal._push_tool_result(pending: aws.internal.PendingMessage[], id: string, output: string, is_error: bool, with_status: bool) -> void { - 734 0 load_var 5 (with_status) - 1 unary_op ! - 2 pop_jump_if_false +2 (to 4) - 3 jump +10 (to 13) - - 736 4 load_var 4 (is_error) - 5 pop_jump_if_false +2 (to 7) - 6 jump +4 (to 10) - - 739 7 load_const 0 ("success") - 8 store_var 6 (status) - - 736 9 jump +6 (to 15) - - 737 10 load_const 1 ("error") - 11 store_var 6 (status) - - 736 12 jump +3 (to 15) - - 735 13 load_const 2 (null) - 14 store_var 6 (status) - - 742 15 load_var2 2 3 - - 744 16 init_instance 0 (aws.internal.ToolResultContentBlock .text) - 17 load_type 3 - 18 alloc_array 1 - - 745 19 load_var 6 (status) - 20 init_instance 1 (aws.internal.ToolResultBlock .toolUseId, .content, .status) - - 741 21 call 1284 ntypeargs=0 (aws.internal.ContentBlock.of_tool_result) - 22 store_var 7 (block) - - 749 23 load_var 1 (pending) - 24 container_len - 25 store_var 8 (_15) - 26 load_type 4 - 27 load_var2 1 8 - 28 load_const 5 (1) - 29 sub_int - 30 call 3 ntypeargs=1 (baml.Array.at) - 31 store_var 9 (_17) - 32 load_var 9 (_17) - 33 narrow_bind 6 9 - 34 pop_jump_if_false +6 (to 40) - 35 load_var 9 (_17) - 36 store_var_load_var 10 (last) - - 750 37 load_field 1 (tool_results) - 38 pop_jump_if_false +2 (to 40) - 39 jump +13 (to 52) - - 755 40 load_type 4 - 41 load_var 1 (pending) - - 756 42 load_const 7 ("user") - 43 load_var 7 (block) - 44 load_type 8 - 45 alloc_array 1 - 46 init_instance 2 (aws.internal.Message .role, .content) - 47 load_const 9 (true) - 48 init_instance 3 (aws.internal.PendingMessage .message, .tool_results) - - 755 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump +8 (to 59) - - 751 52 load_type 8 - 53 load_var 10 (last) - 54 load_field 0 (message) - 55 load_field 1 (content) - 56 load_var 7 (block) - 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - - 733 59 load_const 2 (null) - 60 return -} - -function aws.internal._reject(detail: string) -> ai.errors.InvalidRequest { - 398 0 load_const 0 ("aws-bedrock") - 1 load_const 1 (null) - 2 load_var 1 (detail) - 3 load_const 1 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 return -} - -function aws.internal._supports_tool_result_status(model: string) -> bool { - 722 0 load_var 1 (model) - 1 call 142 ntypeargs=0 (baml.String.to_lower_case) - 2 store_var 2 (id) - - 723 3 load_var 2 (id) - 4 load_const 0 ("anthropic.claude") - 5 call 147 ntypeargs=0 (baml.String.includes) - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_var 2 (id) - 10 load_const 1 ("amazon.nova") - 11 call 147 ntypeargs=0 (baml.String.includes) - 12 return -} - -function aws.internal._system_as_user(system: aws.internal.SystemContentBlock[]) -> aws.internal.Message { - 905 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (content) - - 906 3 load_var 1 (system) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +23 (to 39) - 17 load_var 4 (_4) - 18 load_field 0 (text) - 19 store_var 5 (_9) - - 907 20 load_var 5 (_9) - 21 narrow_bind 6 5 - 22 pop_jump_if_false +2 (to 24) - 23 jump +8 (to 31) - - 911 24 call 1285 ntypeargs=0 (aws.internal.ContentBlock.of_cache_point) - 25 store_var 7 (_16) - 26 load_type 0 - 27 load_var2 2 7 - 28 call 4 ntypeargs=1 (baml.Array.push) - 29 pop 1 - 30 jump -22 (to 8) - - 907 31 load_var 5 (_9) - - 908 32 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 33 store_var 6 (_12) - 34 load_type 0 - 35 load_var2 2 6 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -30 (to 8) - - 915 39 load_const 7 ("user") - 40 load_var 2 (content) - 41 init_instance 0 (aws.internal.Message .role, .content) - 42 return -} - -function aws.internal._tool_choice(choice: string) -> aws.internal.ToolChoice { - 820 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (empty) - - 821 4 load_var 1 (choice) - 5 load_const 2 ("auto") - 6 cmp_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +27 (to 35) - 9 load_var 1 (choice) - 10 load_const 3 ("any") - 11 cmp_op == - 12 pop_jump_if_false +2 (to 14) - 13 jump +17 (to 30) - 14 load_var 1 (choice) - 15 load_const 4 ("required") - 16 cmp_op == - 17 pop_jump_if_false +2 (to 19) - 18 jump +7 (to 25) - - 824 19 load_const 5 (null) - 20 load_const 5 (null) - 21 load_var 1 (choice) - 22 init_instance 0 (aws.internal.SpecificToolChoice .name) - 23 init_instance 1 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 24 jump +15 (to 39) - - 823 25 load_const 5 (null) - 26 load_var 2 (empty) - 27 load_const 5 (null) - 28 init_instance 2 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 29 jump +10 (to 39) - - 823 30 load_const 5 (null) - 31 load_var 2 (empty) - 32 load_const 5 (null) - 33 init_instance 3 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 34 jump +5 (to 39) - - 822 35 load_var 2 (empty) - 36 load_const 5 (null) - 37 load_const 5 (null) - 38 init_instance 4 (aws.internal.ToolChoice .auto, .any, .tool) - 39 return -} - -function aws.internal._tool_config(toolbox: ai.tools.Toolbox, tool_choice: string | null, cache_tools: bool) -> aws.internal.ToolConfig | null { - 833 0 load_var 1 (toolbox) - 1 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 2 pop_jump_if_false +2 (to 4) - 3 jump +65 (to 68) - - 836 4 load_type 0 - 5 alloc_array 0 - 6 store_var 4 (entries) - - 837 7 load_var 1 (toolbox) - 8 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_7) - 13 load_var 5 (_7) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_8) - 18 load_var 6 (_8) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +25 (to 46) - 22 load_var 6 (_8) - 23 store_var 7 (tool) - - 841 24 load_var 7 (tool) - 25 load_field 0 (name) - 26 store_var 9 (_15) - - 842 27 load_var 7 (tool) - 28 load_field 1 (description) - 29 store_var 10 (_16) - - 843 30 load_type 6 - 31 load_var 7 (tool) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 store_var 11 (_18) - - 840 35 load_var2 9 10 - - 843 36 load_var 11 (_18) - 37 init_instance 0 (aws.internal.ToolInputSchema .json_schema) - 38 init_instance 1 (aws.internal.ToolSpec .name, .description, .inputSchema) - - 839 39 call 1290 ntypeargs=0 (aws.internal.ToolEntry.of_spec) - 40 store_var 8 (_13) - - 838 41 load_type 0 - 42 load_var2 4 8 - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -32 (to 13) - - 848 46 load_var 3 (cache_tools) - 47 pop_jump_if_false +7 (to 54) - - 849 48 call 1291 ntypeargs=0 (aws.internal.ToolEntry.of_cache_point) - 49 store_var 12 (_23) - 50 load_type 0 - 51 load_var2 4 12 - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - - 854 54 load_var 2 (tool_choice) - 55 load_const 7 (null) - 56 cmp_op == - 57 pop_jump_if_false +2 (to 59) - 58 jump +5 (to 63) - - 856 59 load_var 2 (tool_choice) - 60 call 1313 ntypeargs=0 (aws.internal._tool_choice) - 61 store_var 13 (selection) - 62 jump +3 (to 65) - - 855 63 load_const 7 (null) - 64 store_var 13 (selection) - - 858 65 load_var2 4 13 - 66 init_instance 2 (aws.internal.ToolConfig .tools, .toolChoice) - 67 jump +2 (to 69) - - 834 68 load_const 7 (null) - 69 return -} - -function aws.internal._video_block(video: baml.media.Video) -> aws.internal.ContentBlock { - 489 0 load_var 1 (video) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 2 (resolved) - - 492 4 load_var 2 (resolved) - 5 load_field 2 (mime_type) - 6 call 1297 ntypeargs=0 (aws.internal._video_format) - - 493 7 load_var 2 (resolved) - 8 load_const 1 ("video") - 9 call 1299 ntypeargs=0 (aws.internal._media_source) - - 491 10 init_instance 0 (aws.internal.VideoBlock .format, .source) - - 490 11 call 1280 ntypeargs=0 (aws.internal.ContentBlock.of_video) - 12 return -} - -function aws.internal._video_format(mime: string) -> string { - 424 0 load_var 1 (mime) - 1 load_const 0 ("video/mp4") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +80 (to 84) - 5 load_var 1 (mime) - 6 load_const 1 ("video/mpeg") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +73 (to 82) - 10 load_var 1 (mime) - 11 load_const 2 ("video/mpg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +66 (to 80) - 15 load_var 1 (mime) - 16 load_const 3 ("video/x-mpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +59 (to 78) - 20 load_var 1 (mime) - 21 load_const 4 ("video/x-ms-wmv") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +52 (to 76) - 25 load_var 1 (mime) - 26 load_const 5 ("video/wmv") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +45 (to 74) - 30 load_var 1 (mime) - 31 load_const 6 ("video/x-matroska") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +38 (to 72) - 35 load_var 1 (mime) - 36 load_const 7 ("video/quicktime") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +31 (to 70) - 40 load_var 1 (mime) - 41 load_const 8 ("video/x-flv") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +24 (to 68) - 45 load_var 1 (mime) - 46 load_const 9 ("video/webm") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +17 (to 66) - 50 load_var 1 (mime) - 51 load_const 10 ("video/3gpp") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +10 (to 64) - - 434 55 load_type 11 - 56 load_var 1 (mime) - 57 call 138 ntypeargs=1 (baml.String.from) - 58 store_var 2 (_15) - 59 load_const 12 ("unsupported video format for Bedrock: ") - 60 load_var 2 (_15) - 61 bin_op + - 62 call 1294 ntypeargs=0 (aws.internal._reject) - 63 throw - - 433 64 load_const 13 ("three_gp") - - 424 65 jump +20 (to 85) - - 432 66 load_const 14 ("webm") - - 424 67 jump +18 (to 85) - - 431 68 load_const 15 ("flv") - - 424 69 jump +16 (to 85) - - 430 70 load_const 16 ("mov") - - 424 71 jump +14 (to 85) - - 429 72 load_const 17 ("mkv") - - 424 73 jump +12 (to 85) - - 428 74 load_const 18 ("wmv") - - 424 75 jump +10 (to 85) - - 428 76 load_const 19 ("wmv") - - 424 77 jump +8 (to 85) - - 427 78 load_const 20 ("mpg") - - 424 79 jump +6 (to 85) - - 427 80 load_const 21 ("mpg") - - 424 81 jump +4 (to 85) - - 426 82 load_const 22 ("mpeg") - - 424 83 jump +2 (to 85) - - 425 84 load_const 23 ("mp4") - 85 return -} - -function aws.internal._wants_cache_point(message: ai.PromptMessage) -> bool { - 611 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (message) - 3 load_field 3 (metadata) - 4 load_const 2 ("cache_point") - 5 call 38 ntypeargs=2 (baml.Map.get) - 6 load_const 3 (null) - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 613 10 load_const 4 (true) - - 611 11 jump +2 (to 13) - - 612 12 load_const 5 (false) - 13 return -} - -function aws.internal.build_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> baml.http.Request { - 1101 0 load_var2 1 2 - 1 call 1318 ntypeargs=0 (aws.internal.converse_request) - 2 store_var 3 (_5) - 3 load_type 0 - 4 load_var 3 (_5) - 5 call 355 ntypeargs=1 (baml.json.to_json) - 6 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - - 1102 7 load_var 1 (client) - 8 load_field 15 (request_body) - 9 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 10 store_var 4 (merged) - - 1105 11 load_var 1 (client) - 12 call 1319 ntypeargs=0 (aws.internal.converse_url) - 13 load_var 1 (client) - 14 load_field 17 (query_params) - 15 call 1321 ntypeargs=0 (aws.internal._apply_query) - 16 store_var 5 (_10) - - 1107 17 load_const 1 ("application/json") - 18 load_const 2 ("application/json") - 19 load_const 3 ("content-type") - 20 load_const 4 ("accept") - 21 load_type 5 - 22 load_type 5 - 23 alloc_map 2 - - 1108 24 load_var 1 (client) - 25 load_field 16 (headers) - - 1106 26 call 1320 ntypeargs=0 (aws.internal._merge_headers) - 27 store_var 6 (_13) - - 1110 28 load_var 4 (merged) - 29 call 351 ntypeargs=0 (baml.json.stringify) - 30 store_var 7 (_16) - - 1103 31 load_const 6 ("POST") - 32 load_var2 5 6 - 33 load_var 7 (_16) - 34 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 35 return -} - -function aws.internal.converse_model_path(model_id: string) -> string { - 72 0 load_var 1 (model_id) - 1 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 2 store_var 3 (_4) - 3 load_type 0 - 4 load_var 3 (_4) - 5 call 138 ntypeargs=1 (baml.String.from) - 6 store_var 2 (_3) - 7 load_const 1 ("/model/") - 8 load_var 2 (_3) - 9 bin_op + - 10 load_const 2 ("/converse") - 11 bin_op + - 12 return -} - -function aws.internal.converse_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> aws.internal.ConverseRequest { - 951 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 4 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 4 (_5) - 7 call_indirect - 8 call 1308 ntypeargs=0 (aws.internal._lower_prompt) - 9 store_var 3 (prompt) - - 952 10 load_var 3 (prompt) - 11 load_field 0 (system) - 12 store_var 5 (system) - - 953 13 load_var 1 (client) - 14 load_field 12 (cache_system_prompt) - 15 jump_if_false +8 (to 23) - 16 pop 1 - 17 load_var 5 (system) - 18 container_len - 19 store_var 6 (_11) - 20 load_var 6 (_11) - 21 load_const 0 (0) - 22 cmp_int_op > - 23 pop_jump_if_false +7 (to 30) - - 954 24 call 1288 ntypeargs=0 (aws.internal.SystemContentBlock.of_cache_point) - 25 store_var 7 (_13) - 26 load_type 1 - 27 load_var2 5 7 - 28 call 4 ntypeargs=1 (baml.Array.push) - 29 pop 1 - - 956 30 load_var 3 (prompt) - 31 load_field 1 (messages) - 32 store_var 8 (messages) - - 958 33 load_var 2 (input) - 34 load_field 1 (journal) - 35 store_var 10 (_18) - 36 load_var 1 (client) - 37 load_type 2 - 38 load_const 3 ("id") - 39 virtual_call nargs=1 ntypeargs=0 - 40 store_var 11 (_19) - 41 load_var2 10 11 - 42 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 43 store_var 9 (_17) - - 959 44 load_var 1 (client) - 45 load_field 0 (model) - 46 call 1310 ntypeargs=0 (aws.internal._supports_tool_result_status) - 47 store_var 12 (_20) - - 957 48 load_var2 9 12 - 49 call 1312 ntypeargs=0 (aws.internal._lower_journal) - - 961 50 load_type 4 - 51 load_const 5 ("iter") - 52 virtual_call nargs=1 ntypeargs=0 - 53 store_var 13 (_23) - 54 load_var 13 (_23) - 55 load_type 6 - 56 load_const 7 ("next") - 57 virtual_call nargs=1 ntypeargs=0 - 58 store_var 14 (_24) - 59 load_var 14 (_24) - 60 is_type 8 - 61 pop_jump_if_false +2 (to 63) - 62 jump +6 (to 68) - - 962 63 load_type 9 - 64 load_var2 8 14 - 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -13 (to 54) - - 968 68 load_type 9 - 69 load_var 8 (messages) - 70 load_const 0 (0) - 71 call 3 ntypeargs=1 (baml.Array.at) - 72 load_const 10 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump +7 (to 82) - 76 load_type 9 - 77 load_var 8 (messages) - 78 load_const 0 (0) - 79 call 3 ntypeargs=1 (baml.Array.at) - 80 load_field 0 (0) - 81 jump +2 (to 83) - 82 load_const 10 (null) - 83 store_var_load_var 16 (_32) - 84 load_const 10 (null) - 85 cmp_op == - 86 pop_jump_if_false +3 (to 89) - 87 load_const 11 ("") - 88 store_var 16 (_32) - 89 load_var 16 (_32) - 90 store_var_load_var 15 (leading_role) - - 972 91 load_const 12 ("user") - 92 cmp_op != - 93 jump_if_false +3 (to 96) - 94 pop 1 - 95 jump +3 (to 98) - 96 store_var 17 (folded) - 97 jump +8 (to 105) - 98 load_var 5 (system) - 99 container_len - 100 store_var 18 (_43) - 101 load_var 18 (_43) - 102 load_const 0 (0) - 103 cmp_int_op > - 104 store_var 17 (folded) - - 976 105 load_var 8 (messages) - 106 container_len - 107 store_var 19 (_47) - 108 load_var 19 (_47) - 109 load_const 0 (0) - 110 cmp_int_op > - 111 jump_if_false +5 (to 116) - 112 pop 1 - 113 load_var 15 (leading_role) - 114 load_const 13 ("user") - 115 cmp_op != - 116 jump_if_false +8 (to 124) - 117 pop 1 - 118 load_var 5 (system) - 119 container_len - 120 store_var 20 (_49) - 121 load_var 20 (_49) - 122 load_const 0 (0) - 123 cmp_int_op == - - 978 124 load_var 17 (folded) - 125 pop_jump_if_false +2 (to 127) - 126 jump +19 (to 145) - - 980 127 pop_jump_if_false +2 (to 129) - 128 jump +3 (to 131) - - 985 129 load_var 8 (messages) - - 980 130 jump +24 (to 154) - - 981 131 load_const 14 ("(continue)") - 132 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 133 store_var 23 (_62) - 134 load_type 9 - 135 load_const 15 ("user") - 136 load_var 23 (_62) - 137 load_type 16 - 138 alloc_array 1 - 139 init_instance 0 (aws.internal.Message .role, .content) - 140 load_type 9 - 141 alloc_array 1 - - 982 142 load_var 8 (messages) - - 981 143 call 7 ntypeargs=1 (baml.Array.concat) - 144 jump +10 (to 154) - - 979 145 load_var 5 (system) - 146 call 1316 ntypeargs=0 (aws.internal._system_as_user) - 147 store_var 22 (_54) - 148 load_type 9 - 149 load_var 22 (_54) - 150 load_type 9 - 151 alloc_array 1 - 152 load_var 8 (messages) - 153 call 7 ntypeargs=1 (baml.Array.concat) - - 977 154 call 1317 ntypeargs=0 (aws.internal._merge_adjacent_roles) - 155 store_var 21 (wire_messages) - - 988 156 load_var 21 (wire_messages) - 157 container_len - 158 store_var 24 (_66) - 159 load_var 24 (_66) - 160 load_const 0 (0) - 161 cmp_int_op == - 162 pop_jump_if_false +2 (to 164) - 163 jump +34 (to 197) - - 991 164 load_var 17 (folded) - 165 jump_if_false +2 (to 167) - 166 jump +8 (to 174) - 167 pop 1 - 168 load_var 5 (system) - 169 container_len - 170 store_var 25 (_71) - 171 load_var 25 (_71) - 172 load_const 0 (0) - 173 cmp_int_op == - 174 pop_jump_if_false +2 (to 176) - 175 jump +3 (to 178) - - 994 176 load_var 5 (system) - - 991 177 jump +2 (to 179) - - 992 178 load_const 10 (null) - - 999 179 store_var 26 (_73) - - 1000 180 load_var 1 (client) - 181 call 1315 ntypeargs=0 (aws.internal._inference_config) - 182 store_var 27 (_74) - - 1001 183 load_var 2 (input) - 184 load_field 2 (toolbox) - 185 load_var 1 (client) - 186 load_field 11 (tool_choice) - 187 load_var 1 (client) - 188 load_field 13 (cache_tools) - 189 call 1314 ntypeargs=0 (aws.internal._tool_config) - 190 store_var 28 (_75) - - 998 191 load_var2 21 26 - 192 load_var2 27 28 - - 1002 193 load_var 1 (client) - 194 load_field 14 (additional_model_request_fields) - 195 init_instance 1 (aws.internal.ConverseRequest .messages, .system, .inferenceConfig, .toolConfig, .additionalModelRequestFields) - 196 return - - 989 197 load_const 17 ("the rendered prompt and journal produced no message content") - 198 call 1294 ntypeargs=0 (aws.internal._reject) - 199 throw -} - -function aws.internal.converse_url(client: aws.BedrockClient) -> string { - 1010 0 load_var 1 (client) - 1 load_field 0 (model) - 2 call 1277 ntypeargs=0 (aws.internal.converse_model_path) - 3 store_var 2 (path) - - 1011 4 load_var 1 (client) - 5 call 1272 ntypeargs=0 (aws.BedrockClient.resolved_endpoint_url) - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 narrow_bind 0 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +74 (to 84) - - 1023 11 load_var 1 (client) - 12 load_field 1 (region) - 13 store_var 9 (_18) - 14 load_var 9 (_18) - 15 narrow_bind 0 9 - 16 pop_jump_if_false +2 (to 18) - 17 jump +51 (to 68) - - 1029 18 load_const 1 (null) - 19 load_var 1 (client) - 20 load_field 2 (profile) - 21 call 1329 ntypeargs=0 (aws.internal.resolve_region) - 22 jump +19 (to 41) - 23 load_var 12 (e) - 24 throw_if_panic - - 1034 25 load_type 2 - 26 load_var 12 (e) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 14 (_34) - 29 load_type 3 - 30 load_var 14 (_34) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 13 (_33) - - 1031 33 load_const 4 ("aws-bedrock") - 34 load_const 1 (null) - - 1034 35 load_const 5 ("AWS region resolution failed: ") - 36 load_var 13 (_33) - 37 bin_op + - 38 load_const 1 (null) - 39 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 40 throw - - 1039 41 store_var 15 (_37) - 42 load_var 15 (_37) - 43 narrow_bind 0 15 - 44 pop_jump_if_false +2 (to 46) - 45 jump +7 (to 52) - - 1042 46 load_const 6 ("aws-bedrock") - 47 load_const 1 (null) - 48 load_const 7 ("no AWS region: set the client's `region` option, AWS_REGION, AWS_DEFAULT_REGION, or a `region` key on the active profile (or set `endpoint_url` to bypass region resolution)") - 49 load_const 1 (null) - 50 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 51 throw - - 1040 52 load_type 3 - - 1039 53 load_var 15 (_37) - - 1040 54 call 138 ntypeargs=1 (baml.String.from) - 55 store_var 16 (_41) - 56 load_type 3 - 57 load_var 2 (path) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 17 (_44) - 60 load_const 8 ("https://bedrock-runtime.") - 61 load_var 16 (_41) - 62 bin_op + - 63 load_const 9 (".amazonaws.com") - 64 bin_op + - 65 load_var 17 (_44) - 66 bin_op + - 67 jump +47 (to 114) - - 1024 68 load_type 3 - - 1023 69 load_var 9 (_18) - - 1024 70 call 138 ntypeargs=1 (baml.String.from) - 71 store_var 10 (_22) - 72 load_type 3 - 73 load_var 2 (path) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 11 (_25) - 76 load_const 10 ("https://bedrock-runtime.") - 77 load_var 10 (_22) - 78 bin_op + - 79 load_const 11 (".amazonaws.com") - 80 bin_op + - 81 load_var 11 (_25) - 82 bin_op + - 83 jump +31 (to 114) - - 1011 84 load_var 3 (_5) - 85 store_var 4 (endpoint) - - 1013 86 load_var 4 (endpoint) - 87 load_const 12 ("/") - 88 call 149 ntypeargs=0 (baml.String.ends_with) - 89 pop_jump_if_false +2 (to 91) - 90 jump +4 (to 94) - - 1016 91 load_var 4 (endpoint) - 92 store_var 5 (base) - - 1013 93 jump +11 (to 104) - - 1014 94 load_var 4 (endpoint) - 95 call 139 ntypeargs=0 (baml.String.length) - 96 store_var 6 (_10) - 97 load_var 4 (endpoint) - 98 load_const 13 (0) - 99 load_var 6 (_10) - 100 load_const 0 (1) - 101 sub_int - 102 call 153 ntypeargs=0 (baml.String.slice) - 103 store_var 5 (base) - - 1018 104 load_type 3 - 105 load_var 5 (base) - 106 call 138 ntypeargs=1 (baml.String.from) - 107 store_var 7 (_11) - 108 load_type 3 - 109 load_var 2 (path) - 110 call 138 ntypeargs=1 (baml.String.from) - 111 store_var 8 (_14) - 112 load_var2 7 8 - 113 bin_op + - 114 return -} - -function aws.internal.encode_path_label(value: string) -> string { - 58 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 59 3 load_var 1 (value) - 4 call 179 ntypeargs=0 (baml.String.to_utf8) - 5 call 194 ntypeargs=0 (baml.Uint8Array.to_array) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_6) - 10 load_var 3 (_6) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_7) - 15 load_var 4 (_7) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +56 (to 74) - 19 load_var 4 (_7) - 20 store_var_load_var 5 (byte) - - 60 21 call 1275 ntypeargs=0 (aws.internal._is_unreserved_byte) - 22 pop_jump_if_false +2 (to 24) - 23 jump +41 (to 64) - - 57 24 load_const 6 ("0123456789ABCDEF") - - 64 25 load_var 5 (byte) - 26 load_const 7 (16) - 27 div_int - 28 call 157 ntypeargs=0 (baml.String.at) - 29 store_var_load_var 8 (_23) - 30 load_const 8 (null) - 31 cmp_op == - 32 pop_jump_if_false +3 (to 35) - 33 load_const 9 ("") - 34 store_var 8 (_23) - 35 load_type 0 - 36 load_var 8 (_23) - 37 call 138 ntypeargs=1 (baml.String.from) - 38 store_var 7 (_21) - - 57 39 load_const 10 ("0123456789ABCDEF") - - 64 40 load_var 5 (byte) - 41 load_const 7 (16) - 42 mod_int - 43 call 157 ntypeargs=0 (baml.String.at) - 44 store_var_load_var 10 (_31) - 45 load_const 8 (null) - 46 cmp_op == - 47 pop_jump_if_false +3 (to 50) - 48 load_const 11 ("") - 49 store_var 10 (_31) - 50 load_type 0 - 51 load_var 10 (_31) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 9 (_29) - 54 load_type 0 - 55 load_var 2 (out) - 56 load_const 12 ("%") - 57 load_var 7 (_21) - 58 bin_op + - 59 load_var 9 (_29) - 60 bin_op + - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -53 (to 10) - - 61 64 load_var 5 (byte) - 65 load_type 13 - 66 alloc_array 1 - 67 call 182 ntypeargs=0 (baml.String.from_code_points) - 68 store_var 6 (_14) - 69 load_type 0 - 70 load_var2 2 6 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -63 (to 10) - - 67 74 load_type 0 - 75 load_var 2 (out) - 76 load_const 14 ("") - 77 call 15 ntypeargs=1 (baml.Array.join) - 78 return -} - -function aws.internal.invoke(client: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1328 0 load_var2 1 2 - 1 call 1322 ntypeargs=0 (aws.internal.build_request) - 2 store_var 4 (_4) - 3 load_var2 1 4 - 4 call 1323 ntypeargs=0 (aws.internal.sign) - 5 store_var 3 (request) - - 1329 6 load_type 0 - 7 load_var 3 (request) - 8 load_const 1 ("aws-bedrock") - 9 call 931 ntypeargs=1 (ai.wire.send_as) - 10 call 1326 ntypeargs=0 (aws.internal.parse_response) - 11 return -} - -function aws.internal.parse_response(response: aws.internal.ConverseResponse) -> ai.ModelTurn { - 1257 0 load_var 1 (response) - 1 load_field 1 (stopReason) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +5 (to 10) - 6 load_var 2 (_3) - - 1258 7 call 1324 ntypeargs=0 (aws.internal._is_malformed_stop) - 8 pop_jump_if_false +2 (to 10) - 9 jump +194 (to 203) - - 1265 10 load_var 1 (response) - 11 load_field 0 (output) - 12 load_const 1 (null) - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +6 (to 21) - 16 load_var 1 (response) - 17 load_field 0 (output) - 18 load_field 0 (0) - 19 store_var 4 (message) - 20 jump +3 (to 23) - 21 load_const 1 (null) - 22 store_var 4 (message) - - 1266 23 load_var 4 (message) - 24 load_const 1 (null) - 25 call 672 ntypeargs=0 (baml.ops.equals_equals) - 26 pop_jump_if_false +2 (to 28) - 27 jump +167 (to 194) - - 1272 28 load_type 2 - 29 alloc_array 0 - 30 store_var 6 (content) - - 1273 31 load_var 4 (message) - 32 load_field 1 (1) - 33 store_var_load_var 7 (_23) - 34 load_const 1 (null) - 35 cmp_op == - 36 pop_jump_if_false +4 (to 40) - 37 load_type 3 - 38 alloc_array 0 - 39 store_var 7 (_23) - 40 load_var 7 (_23) - 41 load_type 4 - 42 load_const 5 ("iter") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 8 (_27) - - 1274 45 load_var 8 (_27) - 46 load_type 6 - 47 load_const 7 ("next") - 48 virtual_call nargs=1 ntypeargs=0 - 49 store_var 9 (_28) - 50 load_var 9 (_28) - 51 is_type 8 - 52 pop_jump_if_false +2 (to 54) - 53 jump +88 (to 141) - 54 load_var 9 (_28) - 55 store_var_load_var 10 (block) - - 1275 56 load_field 0 (text) - 57 store_var 11 (_33) - 58 load_var 11 (_33) - 59 narrow_bind 0 11 - 60 pop_jump_if_false +2 (to 62) - 61 jump +74 (to 135) - - 1278 62 load_var 10 (block) - 63 load_field 1 (toolUse) - 64 store_var 12 (_40) - 65 load_var 12 (_40) - 66 narrow_bind 9 12 - 67 pop_jump_if_false +2 (to 69) - 68 jump +29 (to 97) - - 1288 69 load_var 10 (block) - 70 load_field 2 (reasoningContent) - 71 store_var 19 (_59) - 72 load_var 19 (_59) - 73 narrow_bind 10 19 - 74 pop_jump_if_false -29 (to 45) - 75 load_var 19 (_59) - 76 store_var_load_var 20 (reasoning) - - 1289 77 load_field 0 (reasoningText) - 78 load_const 1 (null) - 79 cmp_op == - 80 pop_jump_if_false +2 (to 82) - 81 jump +5 (to 86) - 82 load_var 20 (reasoning) - 83 load_field 0 (reasoningText) - 84 load_field 0 (0) - 85 jump +2 (to 87) - 86 load_const 1 (null) - 87 store_var 21 (_65) - 88 load_var 21 (_65) - 89 narrow_bind 0 21 - 90 pop_jump_if_false -45 (to 45) - - 1290 91 load_type 2 - 92 load_var2 6 21 - - 1289 93 init_instance 0 (ai.content.Reasoning .summary) - - 1290 94 call 4 ntypeargs=1 (baml.Array.push) - 95 pop 1 - 96 jump -51 (to 45) - - 1278 97 load_var 12 (_40) - 98 store_var_load_var 13 (use) - - 1282 99 load_field 0 (toolUseId) - 100 store_var_load_var 15 (_46) - 101 load_const 1 (null) - 102 cmp_op == - 103 pop_jump_if_false +3 (to 106) - 104 load_const 11 ("") - 105 store_var 15 (_46) - 106 load_var 15 (_46) - 107 store_var 14 (_45) - - 1283 108 load_var 13 (use) - 109 load_field 1 (name) - 110 store_var_load_var 17 (_50) - 111 load_const 1 (null) - 112 cmp_op == - 113 pop_jump_if_false +3 (to 116) - 114 load_const 12 ("") - 115 store_var 17 (_50) - 116 load_var 17 (_50) - 117 store_var 16 (_49) - - 1284 118 load_var 13 (use) - 119 load_field 2 (input) - 120 store_var_load_var 18 (_54) - 121 load_const 1 (null) - 122 cmp_op == - 123 pop_jump_if_false +5 (to 128) - - 1279 124 load_type 13 - 125 load_type 14 - 126 alloc_map 0 - 127 store_var 18 (_54) - - 1280 128 load_type 2 - 129 load_var2 6 14 - - 1281 130 load_var2 16 18 - - 1284 131 init_instance 1 (ai.content.ToolUse .id, .name, .args) - - 1280 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - 134 jump -89 (to 45) - - 1276 135 load_type 2 - 136 load_var2 6 11 - - 1275 137 init_instance 2 (ai.content.Text .text) - - 1276 138 call 4 ntypeargs=1 (baml.Array.push) - 139 pop 1 - 140 jump -95 (to 45) - - 1301 141 load_var 1 (response) - 142 load_field 1 (stopReason) - 143 store_var_load_var 23 (_72) - 144 load_const 1 (null) - 145 cmp_op == - 146 pop_jump_if_false +2 (to 148) - 147 jump +5 (to 152) - 148 load_var 23 (_72) - - 1303 149 call 1325 ntypeargs=0 (aws.internal.stop_reason) - 150 store_var 22 (stop) - 151 jump +4 (to 155) - - 1302 152 load_const 15 (ai.content.StopReason.Complete) - 153 alloc_variant 774 (ai.content.StopReason) - 154 store_var 22 (stop) - - 1306 155 load_var 1 (response) - 156 load_field 2 (usage) - 157 store_var_load_var 25 (_77) - 158 load_const 1 (null) - 159 cmp_op == - 160 pop_jump_if_false +2 (to 162) - 161 jump +27 (to 188) - 162 load_var 25 (_77) - 163 store_var_load_var 26 (reported) - - 1310 164 load_field 0 (inputTokens) - 165 store_var_load_var 28 (_81) - 166 load_const 1 (null) - 167 cmp_op == - 168 pop_jump_if_false +3 (to 171) - 169 load_const 15 (0) - 170 store_var 28 (_81) - 171 load_var 28 (_81) - 172 store_var 27 (_80) - - 1311 173 load_var 26 (reported) - 174 load_field 1 (outputTokens) - 175 store_var_load_var 29 (_85) - 176 load_const 1 (null) - 177 cmp_op == - 178 pop_jump_if_false +3 (to 181) - 179 load_const 15 (0) - 180 store_var 29 (_85) - - 1309 181 load_var2 27 29 - - 1312 182 load_var 26 (reported) - 183 load_field 3 (cacheReadInputTokens) - 184 load_const 1 (null) - 185 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 186 store_var 24 (usage) - - 1306 187 jump +3 (to 190) - - 1307 188 load_const 1 (null) - 189 store_var 24 (usage) - - 1320 190 load_var2 6 22 - 191 load_var 24 (usage) - 192 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) - 193 return - - 1269 194 load_type 16 - 195 load_var 1 (response) - 196 call 355 ntypeargs=1 (baml.json.to_json) - 197 call 351 ntypeargs=0 (baml.json.stringify) - 198 store_var 5 (_18) - - 1267 199 load_const 17 ("aws-bedrock") - 200 load_var 5 (_18) - 201 init_instance 5 (ai.errors.ParseFailed .provider, .raw_output) - 202 throw - - 1261 203 load_type 16 - 204 load_var 1 (response) - 205 call 355 ntypeargs=1 (baml.json.to_json) - 206 call 351 ntypeargs=0 (baml.json.stringify) - 207 store_var 3 (_8) - - 1259 208 load_const 18 ("aws-bedrock") - 209 load_var 3 (_8) - 210 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) - 211 throw -} - -function aws.internal.resolve_region(region: string | null, profile: string | null) -> string | null { - 61 0 load_var2 1 2 - 1 sys_op 984 (ai.internal._aws_resolve_region) - 2 return -} - -function aws.internal.sign(client: aws.BedrockClient, request: baml.http.Request) -> baml.http.Request { - 1117 0 load_var2 2 1 - - 1120 1 load_field 1 (region) - - 1121 2 load_var 1 (client) - 3 load_field 2 (profile) - - 1122 4 load_var 1 (client) - 5 load_field 3 (access_key_id) - - 1123 6 load_var 1 (client) - 7 load_field 4 (secret_access_key) - - 1124 8 load_var 1 (client) - 9 load_field 5 (session_token) - 10 load_const 0 ("bedrock") - 11 init_instance 0 (aws.internal.AwsSignOptions .region, .profile, .access_key_id, .secret_access_key, .session_token, .service) - - 1117 12 call 1328 ntypeargs=0 (aws.internal.sign_request) - 13 jump +19 (to 32) - 14 load_var 3 (e) - 15 throw_if_panic - - 1136 16 load_type 1 - 17 load_var 3 (e) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 5 (_13) - 20 load_type 2 - 21 load_var 5 (_13) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 4 (_12) - - 1133 24 load_const 3 ("aws-bedrock") - 25 load_const 4 (null) - - 1136 26 load_const 5 ("AWS SigV4 signing failed: ") - 27 load_var 4 (_12) - 28 bin_op + - 29 load_const 4 (null) - 30 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 31 throw - 32 return -} - -function aws.internal.sign_request(req: baml.http.Request, opts: aws.internal.AwsSignOptions) -> baml.http.Request { - 45 0 load_var2 1 2 - - 47 1 load_field 5 (service) - - 48 2 load_var 2 (opts) - 3 load_field 0 (region) - - 49 4 load_var 2 (opts) - 5 load_field 1 (profile) - - 50 6 load_var 2 (opts) - 7 load_field 2 (access_key_id) - - 51 8 load_var 2 (opts) - 9 load_field 3 (secret_access_key) - - 52 10 load_var 2 (opts) - 11 load_field 4 (session_token) - 12 sys_op 983 (ai.internal._aws_sign_request) - 13 return -} - -function aws.internal.stop_reason(raw: string) -> ai.content.StopReason { - 1230 0 load_var 1 (raw) - 1 load_const 0 ("tool_use") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +43 (to 47) - 5 load_var 1 (raw) - 6 load_const 1 ("max_tokens") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +35 (to 44) - 10 load_var 1 (raw) - 11 load_const 2 ("model_context_window_exceeded") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +27 (to 41) - 15 load_var 1 (raw) - 16 load_const 3 ("content_filtered") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +19 (to 38) - 20 load_var 1 (raw) - 21 load_const 4 ("guardrail_intervened") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +11 (to 35) - - 1240 25 load_var 1 (raw) - 26 call 1324 ntypeargs=0 (aws.internal._is_malformed_stop) - - 1230 27 pop_jump_if_false +2 (to 29) - 28 jump +4 (to 32) - - 1242 29 load_const 5 (ai.content.StopReason.Complete) - 30 alloc_variant 774 (ai.content.StopReason) - - 1230 31 jump +18 (to 49) - - 1240 32 load_const 6 (ai.content.StopReason.Refused) - 33 alloc_variant 774 (ai.content.StopReason) - - 1230 34 jump +15 (to 49) - - 1236 35 load_const 6 (ai.content.StopReason.Refused) - 36 alloc_variant 774 (ai.content.StopReason) - - 1230 37 jump +12 (to 49) - - 1236 38 load_const 6 (ai.content.StopReason.Refused) - 39 alloc_variant 774 (ai.content.StopReason) - - 1230 40 jump +9 (to 49) - - 1235 41 load_const 7 (ai.content.StopReason.MaxTokens) - 42 alloc_variant 774 (ai.content.StopReason) - - 1230 43 jump +6 (to 49) - - 1235 44 load_const 7 (ai.content.StopReason.MaxTokens) - 45 alloc_variant 774 (ai.content.StopReason) - - 1230 46 jump +3 (to 49) - - 1231 47 load_const 8 (ai.content.StopReason.ToolUse) - 48 alloc_variant 774 (ai.content.StopReason) - 49 return -} - -function boundary.LocalId.capture(self: boundary.LocalId, inputs: bool | null, output: bool | null, error: bool | null) -> boundary.LocalId { -} - -function boundary.id() -> boundary.LocalId { -} - -function boundary.id.current() -> string { -} - -function claude_code.ClaudeCodeClient.ai.Client.id(self: claude_code.ClaudeCodeClient) -> string { - 40 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 1 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("claude-code/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function claude_code.ClaudeCodeClient.ai.Client.invoke(self: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 44 0 load_var2 1 2 - 1 call 1363 ntypeargs=0 (claude_code.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 45 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function claude_code.ClaudeCodeClient.new(model: string, executable: string, cwd: string | null, timeout_ms: int, permission_mode: string, harness_tools: string[], mcp_servers: map | null) -> claude_code.ClaudeCodeClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 18 4 load_const 1 ("haiku") - 5 store_var 1 (model) - 6 load_var 2 (executable) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 19 10 load_const 2 ("claude") - 11 store_var 2 (executable) - 12 load_var 3 (cwd) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 20 16 load_const 3 (null) - 17 store_var 3 (cwd) - 18 load_var 4 (timeout_ms) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 21 22 load_const 4 (240000) - 23 store_var 4 (timeout_ms) - 24 load_var 5 (permission_mode) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 22 28 load_const 5 ("default") - 29 store_var 5 (permission_mode) - 30 load_var 6 (harness_tools) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +4 (to 37) - - 23 34 load_type 6 - 35 alloc_array 0 - 36 store_var 6 (harness_tools) - 37 load_var 7 (mcp_servers) - 38 load_const 0 () - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - - 24 41 load_const 3 (null) - 42 store_var 7 (mcp_servers) - - 34 43 load_var 7 (mcp_servers) - 44 store_var_load_var 8 (_17) - 45 load_const 3 (null) - 46 cmp_op == - 47 pop_jump_if_false +5 (to 52) - - 26 48 load_type 6 - 49 load_type 7 - 50 alloc_map 0 - 51 store_var 8 (_17) - - 27 52 load_var2 2 1 - 53 load_var2 3 4 - 54 load_var2 5 6 - - 34 55 load_var 8 (_17) - 56 init_instance 0 (claude_code.ClaudeCodeClient .executable, .model, .cwd, .timeout_ms, .permission_mode, .harness_tools, .mcp_servers) - 57 return -} - -function claude_code.internal._log_cc_event(raw: baml.json.json) -> void { - 163 0 load_type 0 - 1 load_var 1 (raw) - 2 load_const 1 (".type") - 3 load_const 2 ("?") - 4 call 364 ntypeargs=1 (baml.json.path_or) - 5 store_var 2 (kind) - - 164 6 load_var 2 (kind) - 7 load_const 3 ("system") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +331 (to 341) - 11 load_var 2 (kind) - 12 load_const 4 ("assistant") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +177 (to 192) - 16 load_var 2 (kind) - 17 load_const 5 ("user") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +23 (to 43) - 21 load_var 2 (kind) - 22 load_const 6 ("result") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +382 (to 407) - - 203 26 load_type 0 - 27 load_var 2 (kind) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 37 (_141) - 30 load_const 7 ("$baml_log") - 31 load_const 8 ("info") - 32 load_const 9 ("cc event: ") - 33 load_var 37 (_141) - 34 bin_op + - 35 load_const 10 ("level") - 36 load_const 11 ("data") - 37 load_type 0 - 38 load_type 12 - 39 alloc_map 2 - 40 send_event - 41 pop 1 - 42 jump +365 (to 407) - - 178 43 load_type 0 - 44 alloc_array 0 - 45 store_var 23 (parts) - - 179 46 load_type 13 - 47 load_var 1 (raw) - 48 load_const 14 (".message.content") - 49 load_type 15 - 50 alloc_array 0 - 51 call 364 ntypeargs=1 (baml.json.path_or) - - 180 52 load_type 16 - 53 load_const 17 ("iter") - 54 virtual_call nargs=1 ntypeargs=0 - 55 store_var 24 (_89) - 56 load_var 24 (_89) - 57 load_type 18 - 58 load_const 19 ("next") - 59 virtual_call nargs=1 ntypeargs=0 - 60 store_var 25 (_90) - 61 load_var 25 (_90) - 62 is_type 20 - 63 pop_jump_if_false +2 (to 65) - 64 jump +96 (to 160) - 65 load_var 25 (_90) - 66 store_var 26 (b) - - 181 67 load_type 0 - 68 load_var 26 (b) - 69 load_const 21 (".type") - 70 load_const 22 ("?") - 71 call 364 ntypeargs=1 (baml.json.path_or) - 72 store_var 27 (bt) - - 182 73 load_var 27 (bt) - 74 load_const 23 ("text") - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +64 (to 141) - 78 load_var 27 (bt) - 79 load_const 24 ("thinking") - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +40 (to 122) - 83 load_var 27 (bt) - 84 load_const 25 ("tool_use") - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +17 (to 104) - 88 load_var 27 (bt) - 89 load_const 26 ("tool_result") - 90 cmp_op == - 91 pop_jump_if_false +2 (to 93) - 92 jump +6 (to 98) - - 195 93 load_type 0 - 94 load_var2 23 27 - 95 call 4 ntypeargs=1 (baml.Array.push) - 96 pop 1 - 97 jump -41 (to 56) - - 194 98 load_type 0 - 99 load_var 23 (parts) - 100 load_const 27 ("tool_result") - 101 call 4 ntypeargs=1 (baml.Array.push) - 102 pop 1 - 103 jump -47 (to 56) - - 192 104 load_type 0 - 105 load_var 26 (b) - 106 load_const 28 (".name") - 107 load_const 29 ("?") - 108 call 364 ntypeargs=1 (baml.json.path_or) - 109 store_var 33 (_119) - 110 load_type 0 - 111 load_var 33 (_119) - 112 call 138 ntypeargs=1 (baml.String.from) - 113 store_var 32 (_118) - 114 load_type 0 - 115 load_var 23 (parts) - 116 load_const 30 ("tool_use: ") - 117 load_var 32 (_118) - 118 bin_op + - 119 call 4 ntypeargs=1 (baml.Array.push) - 120 pop 1 - 121 jump -65 (to 56) - - 188 122 load_type 0 - 123 load_var 26 (b) - 124 load_const 31 (".thinking") - 125 load_const 32 ("") - 126 call 364 ntypeargs=1 (baml.json.path_or) - 127 call 1359 ntypeargs=0 (claude_code.internal._preview) - 128 store_var 31 (_110) - 129 load_type 0 - 130 load_var 31 (_110) - 131 call 138 ntypeargs=1 (baml.String.from) - 132 store_var 30 (_109) - - 187 133 load_type 0 - 134 load_var 23 (parts) - - 188 135 load_const 33 ("thinking: ") - 136 load_var 30 (_109) - 137 bin_op + - - 187 138 call 4 ntypeargs=1 (baml.Array.push) - 139 pop 1 - 140 jump -84 (to 56) - - 184 141 load_type 0 - 142 load_var 26 (b) - 143 load_const 34 (".text") - 144 load_const 35 ("") - 145 call 364 ntypeargs=1 (baml.json.path_or) - 146 call 1359 ntypeargs=0 (claude_code.internal._preview) - 147 store_var 29 (_101) - 148 load_type 0 - 149 load_var 29 (_101) - 150 call 138 ntypeargs=1 (baml.String.from) - 151 store_var 28 (_100) - 152 load_type 0 - 153 load_var 23 (parts) - 154 load_const 36 ("text: ") - 155 load_var 28 (_100) - 156 bin_op + - 157 call 4 ntypeargs=1 (baml.Array.push) - 158 pop 1 - 159 jump -103 (to 56) - - 198 160 load_type 37 - 161 load_var 2 (kind) - 162 call 138 ntypeargs=1 (baml.String.from) - 163 store_var 34 (_132) - 164 load_type 0 - 165 load_var 23 (parts) - 166 load_const 38 (" | ") - 167 call 15 ntypeargs=1 (baml.Array.join) - 168 store_var 36 (_136) - 169 load_type 0 - 170 load_var 36 (_136) - 171 call 138 ntypeargs=1 (baml.String.from) - 172 store_var 35 (_135) - 173 load_const 39 ("$baml_log") - 174 load_const 40 ("info") - 175 load_const 41 ("cc event: ") - 176 load_var 34 (_132) - 177 bin_op + - 178 load_const 42 (" [") - 179 bin_op + - 180 load_var 35 (_135) - 181 bin_op + - 182 load_const 43 ("]") - 183 bin_op + - 184 load_const 44 ("level") - 185 load_const 45 ("data") - 186 load_type 0 - 187 load_type 12 - 188 alloc_map 2 - 189 send_event - 190 pop 1 - 191 jump +216 (to 407) - - 178 192 load_type 0 - 193 alloc_array 0 - 194 store_var 9 (parts) - - 179 195 load_type 13 - 196 load_var 1 (raw) - 197 load_const 46 (".message.content") - 198 load_type 15 - 199 alloc_array 0 - 200 call 364 ntypeargs=1 (baml.json.path_or) - - 180 201 load_type 16 - 202 load_const 47 ("iter") - 203 virtual_call nargs=1 ntypeargs=0 - 204 store_var 10 (_33) - 205 load_var 10 (_33) - 206 load_type 18 - 207 load_const 48 ("next") - 208 virtual_call nargs=1 ntypeargs=0 - 209 store_var 11 (_34) - 210 load_var 11 (_34) - 211 is_type 20 - 212 pop_jump_if_false +2 (to 214) - 213 jump +96 (to 309) - 214 load_var 11 (_34) - 215 store_var 12 (b) - - 181 216 load_type 0 - 217 load_var 12 (b) - 218 load_const 49 (".type") - 219 load_const 50 ("?") - 220 call 364 ntypeargs=1 (baml.json.path_or) - 221 store_var 13 (bt) - - 182 222 load_var 13 (bt) - 223 load_const 51 ("text") - 224 cmp_op == - 225 pop_jump_if_false +2 (to 227) - 226 jump +64 (to 290) - 227 load_var 13 (bt) - 228 load_const 52 ("thinking") - 229 cmp_op == - 230 pop_jump_if_false +2 (to 232) - 231 jump +40 (to 271) - 232 load_var 13 (bt) - 233 load_const 53 ("tool_use") - 234 cmp_op == - 235 pop_jump_if_false +2 (to 237) - 236 jump +17 (to 253) - 237 load_var 13 (bt) - 238 load_const 54 ("tool_result") - 239 cmp_op == - 240 pop_jump_if_false +2 (to 242) - 241 jump +6 (to 247) - - 195 242 load_type 0 - 243 load_var2 9 13 - 244 call 4 ntypeargs=1 (baml.Array.push) - 245 pop 1 - 246 jump -41 (to 205) - - 194 247 load_type 0 - 248 load_var 9 (parts) - 249 load_const 55 ("tool_result") - 250 call 4 ntypeargs=1 (baml.Array.push) - 251 pop 1 - 252 jump -47 (to 205) - - 192 253 load_type 0 - 254 load_var 12 (b) - 255 load_const 56 (".name") - 256 load_const 57 ("?") - 257 call 364 ntypeargs=1 (baml.json.path_or) - 258 store_var 19 (_63) - 259 load_type 0 - 260 load_var 19 (_63) - 261 call 138 ntypeargs=1 (baml.String.from) - 262 store_var 18 (_62) - 263 load_type 0 - 264 load_var 9 (parts) - 265 load_const 58 ("tool_use: ") - 266 load_var 18 (_62) - 267 bin_op + - 268 call 4 ntypeargs=1 (baml.Array.push) - 269 pop 1 - 270 jump -65 (to 205) - - 188 271 load_type 0 - 272 load_var 12 (b) - 273 load_const 59 (".thinking") - 274 load_const 60 ("") - 275 call 364 ntypeargs=1 (baml.json.path_or) - 276 call 1359 ntypeargs=0 (claude_code.internal._preview) - 277 store_var 17 (_54) - 278 load_type 0 - 279 load_var 17 (_54) - 280 call 138 ntypeargs=1 (baml.String.from) - 281 store_var 16 (_53) - - 187 282 load_type 0 - 283 load_var 9 (parts) - - 188 284 load_const 61 ("thinking: ") - 285 load_var 16 (_53) - 286 bin_op + - - 187 287 call 4 ntypeargs=1 (baml.Array.push) - 288 pop 1 - 289 jump -84 (to 205) - - 184 290 load_type 0 - 291 load_var 12 (b) - 292 load_const 62 (".text") - 293 load_const 63 ("") - 294 call 364 ntypeargs=1 (baml.json.path_or) - 295 call 1359 ntypeargs=0 (claude_code.internal._preview) - 296 store_var 15 (_45) - 297 load_type 0 - 298 load_var 15 (_45) - 299 call 138 ntypeargs=1 (baml.String.from) - 300 store_var 14 (_44) - 301 load_type 0 - 302 load_var 9 (parts) - 303 load_const 64 ("text: ") - 304 load_var 14 (_44) - 305 bin_op + - 306 call 4 ntypeargs=1 (baml.Array.push) - 307 pop 1 - 308 jump -103 (to 205) - - 198 309 load_type 37 - 310 load_var 2 (kind) - 311 call 138 ntypeargs=1 (baml.String.from) - 312 store_var 20 (_76) - 313 load_type 0 - 314 load_var 9 (parts) - 315 load_const 65 (" | ") - 316 call 15 ntypeargs=1 (baml.Array.join) - 317 store_var 22 (_80) - 318 load_type 0 - 319 load_var 22 (_80) - 320 call 138 ntypeargs=1 (baml.String.from) - 321 store_var 21 (_79) - 322 load_const 66 ("$baml_log") - 323 load_const 67 ("info") - 324 load_const 68 ("cc event: ") - 325 load_var 20 (_76) - 326 bin_op + - 327 load_const 69 (" [") - 328 bin_op + - 329 load_var 21 (_79) - 330 bin_op + - 331 load_const 70 ("]") - 332 bin_op + - 333 load_const 71 ("level") - 334 load_const 72 ("data") - 335 load_type 0 - 336 load_type 12 - 337 alloc_map 2 - 338 send_event - 339 pop 1 - 340 jump +67 (to 407) - - 166 341 load_type 0 - 342 load_var 1 (raw) - 343 load_const 73 (".subtype") - 344 load_const 74 ("?") - 345 call 364 ntypeargs=1 (baml.json.path_or) - 346 store_var 3 (subtype) - - 167 347 load_var 3 (subtype) - 348 load_const 75 ("thinking_tokens") - 349 cmp_op == - 350 pop_jump_if_false +2 (to 352) - 351 jump +32 (to 383) - - 173 352 load_type 0 - 353 load_var 1 (raw) - 354 load_const 76 (".model") - 355 load_const 77 ("?") - 356 call 364 ntypeargs=1 (baml.json.path_or) - 357 store_var 6 (model) - - 174 358 load_type 0 - 359 load_var 3 (subtype) - 360 call 138 ntypeargs=1 (baml.String.from) - 361 store_var 7 (_21) - 362 load_type 0 - 363 load_var 6 (model) - 364 call 138 ntypeargs=1 (baml.String.from) - 365 store_var 8 (_24) - 366 load_const 78 ("$baml_log") - 367 load_const 79 ("info") - 368 load_const 80 ("cc event: system/") - 369 load_var 7 (_21) - 370 bin_op + - 371 load_const 81 (" model=") - 372 bin_op + - 373 load_var 8 (_24) - 374 bin_op + - 375 load_const 82 ("level") - 376 load_const 83 ("data") - 377 load_type 0 - 378 load_type 12 - 379 alloc_map 2 - 380 send_event - 381 pop 1 - 382 jump +25 (to 407) - - 170 383 load_type 84 - 384 load_var 1 (raw) - 385 load_const 85 (".estimated_tokens") - 386 load_const 86 (0) - 387 call 364 ntypeargs=1 (baml.json.path_or) - 388 store_var 4 (estimated) - - 171 389 load_type 84 - 390 load_var 4 (estimated) - 391 call 138 ntypeargs=1 (baml.String.from) - 392 store_var 5 (_13) - 393 load_const 87 ("$baml_log") - 394 load_const 88 ("debug") - 395 load_const 89 ("cc event: thinking ~") - 396 load_var 5 (_13) - 397 bin_op + - 398 load_const 90 (" tokens") - 399 bin_op + - 400 load_const 91 ("level") - 401 load_const 92 ("data") - 402 load_type 0 - 403 load_type 12 - 404 alloc_map 2 - 405 send_event - 406 pop 1 - - 162 407 load_const 93 (null) - 408 return -} - -function claude_code.internal._preview(text: string) -> string { - 154 0 load_var 1 (text) - 1 call 139 ntypeargs=0 (baml.String.length) - 2 load_const 0 (120) - 3 cmp_int_op > - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 157 6 load_var 1 (text) - - 154 7 jump +11 (to 18) - - 155 8 load_var 1 (text) - 9 load_const 1 (0) - 10 load_const 0 (120) - 11 call 153 ntypeargs=0 (baml.String.slice) - 12 store_var 2 (_5) - 13 load_type 2 - 14 load_var 2 (_5) - 15 call 138 ntypeargs=1 (baml.String.from) - 16 load_const 3 ("...") - 17 bin_op + - 18 return -} - -function claude_code.internal._read_result(p: baml.sys.Process) -> baml.json.json { - 127 0 load_const 0 (null) - 1 store_var 2 (result) - - 128 2 load_var 1 (p) - 3 load_field 0 (stdout) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_5) - 13 load_var 4 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +33 (to 49) - 17 load_var 4 (_5) - - 129 18 call 144 ntypeargs=0 (baml.String.trim) - 19 store_var 5 (trimmed) - - 130 20 load_var 5 (trimmed) - 21 call 139 ntypeargs=0 (baml.String.length) - 22 load_const 6 (0) - 23 cmp_int_op > - 24 pop_jump_if_false -16 (to 8) - - 131 25 load_var 5 (trimmed) - 26 call 350 ntypeargs=0 (baml.json.parse) - 27 store_var 6 (raw) - 28 jump +7 (to 35) - 29 load_var 7 (e) - 30 throw_if_panic - - 133 31 load_const 7 ("claude-code") - 32 load_var 5 (trimmed) - 33 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 34 throw - - 136 35 load_var 6 (raw) - 36 call 1360 ntypeargs=0 (claude_code.internal._log_cc_event) - 37 pop 1 - - 137 38 load_type 8 - 39 load_var 6 (raw) - 40 load_const 9 (".type") - 41 load_const 10 ("") - 42 call 364 ntypeargs=1 (baml.json.path_or) - 43 load_const 11 ("result") - 44 cmp_op == - 45 pop_jump_if_false -37 (to 8) - - 138 46 load_var 6 (raw) - 47 store_var 2 (result) - - 137 48 jump -40 (to 8) - - 144 49 load_var 2 (result) - 50 load_const 0 (null) - 51 call 672 ntypeargs=0 (baml.ops.equals_equals) - 52 pop_jump_if_false +2 (to 54) - 53 jump +3 (to 56) - - 150 54 load_var 2 (result) - 55 return - - 145 56 load_const 12 ("claude-code") - 57 load_const 13 ("the Claude Code CLI stream ended without a result event") - 58 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 59 throw -} - -function claude_code.internal._type_schema(t: string) -> map { - 89 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (m) - - 90 4 load_type 0 - 5 load_type 1 - 6 load_var 2 (m) - 7 load_const 2 ("type") - 8 load_var 1 (t) - 9 call 37 ntypeargs=2 (baml.Map.set) - 10 pop 1 - - 91 11 load_var 2 (m) - 12 return -} - -function claude_code.internal.allowed_mcp_tools(c: claude_code.ClaudeCodeClient) -> string { - 223 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (c) - 3 load_field 6 (mcp_servers) - 4 call 35 ntypeargs=2 (baml.Map.keys) - 5 store_var 3 (_3) - 6 load_type 0 - 7 load_type 0 - 8 load_type 2 - 9 load_var 3 (_3) - - 224 10 make_closure 4219 0 - - 223 11 call 16 ntypeargs=3 (baml.Array.map) - 12 store_var 2 (_2) - 13 load_type 0 - 14 load_var 2 (_2) - 15 load_const 3 (",") - 16 call 15 ntypeargs=1 (baml.Array.join) - 17 return -} - -function claude_code.internal.envelope_schema(output_type: type) -> map { - 52 0 load_var 1 (output_type) - 1 sys_op 365 (baml.json.schema) - 2 store_var 3 (_3) - 3 load_type 0 - 4 load_var 3 (_3) - 5 call 358 ntypeargs=1 (baml.json.from_json) - 6 store_var 2 (final_root) - - 53 7 load_type 1 - 8 load_type 2 - 9 load_var 2 (final_root) - 10 load_const 3 ("$defs") - 11 call 39 ntypeargs=2 (baml.Map.delete) - 12 store_var 4 (definitions) - - 54 13 load_type 1 - 14 load_type 2 - 15 alloc_map 0 - 16 store_var 5 (call_props) - - 55 17 load_const 4 ("string") - 18 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 19 store_var 6 (_10) - 20 load_type 1 - 21 load_type 2 - 22 load_var 5 (call_props) - 23 load_const 5 ("id") - 24 load_var 6 (_10) - 25 call 37 ntypeargs=2 (baml.Map.set) - 26 pop 1 - - 56 27 load_const 6 ("string") - 28 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 29 store_var 7 (_14) - 30 load_type 1 - 31 load_type 2 - 32 load_var 5 (call_props) - 33 load_const 7 ("name") - 34 load_var 7 (_14) - 35 call 37 ntypeargs=2 (baml.Map.set) - 36 pop 1 - - 57 37 load_const 8 ("object") - 38 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 39 store_var 8 (_18) - 40 load_type 1 - 41 load_type 2 - 42 load_var 5 (call_props) - 43 load_const 9 ("args") - 44 load_var 8 (_18) - 45 call 37 ntypeargs=2 (baml.Map.set) - 46 pop 1 - - 58 47 load_type 1 - 48 load_type 2 - 49 alloc_map 0 - 50 store_var 9 (call_item) - - 59 51 load_type 1 - 52 load_type 2 - 53 load_var 9 (call_item) - 54 load_const 10 ("type") - 55 load_const 11 ("object") - 56 call 37 ntypeargs=2 (baml.Map.set) - 57 pop 1 - - 60 58 load_type 1 - 59 load_type 2 - 60 load_var 9 (call_item) - 61 load_const 12 ("properties") - 62 load_var 5 (call_props) - 63 call 37 ntypeargs=2 (baml.Map.set) - 64 pop 1 - - 61 65 load_type 1 - 66 load_type 2 - 67 load_var 9 (call_item) - 68 load_const 13 ("required") - 69 load_const 14 ("id") - 70 load_const 15 ("name") - 71 load_const 16 ("args") - 72 load_type 1 - 73 alloc_array 3 - 74 call 37 ntypeargs=2 (baml.Map.set) - 75 pop 1 - - 62 76 load_type 1 - 77 load_type 2 - 78 load_var 9 (call_item) - 79 load_const 17 ("additionalProperties") - 80 load_const 18 (false) - 81 call 37 ntypeargs=2 (baml.Map.set) - 82 pop 1 - - 63 83 load_type 1 - 84 load_type 2 - 85 alloc_map 0 - 86 store_var 10 (calls_array) - - 64 87 load_type 1 - 88 load_type 2 - 89 load_var 10 (calls_array) - 90 load_const 19 ("type") - 91 load_const 20 ("array") - 92 call 37 ntypeargs=2 (baml.Map.set) - 93 pop 1 - - 65 94 load_type 1 - 95 load_type 2 - 96 load_var 10 (calls_array) - 97 load_const 21 ("items") - 98 load_var 9 (call_item) - 99 call 37 ntypeargs=2 (baml.Map.set) - 100 pop 1 - - 66 101 load_type 1 - 102 load_type 2 - 103 alloc_map 0 - 104 store_var 11 (calls_props) - - 67 105 load_type 1 - 106 load_type 2 - 107 load_var 11 (calls_props) - 108 load_const 22 ("calls") - 109 load_var 10 (calls_array) - 110 call 37 ntypeargs=2 (baml.Map.set) - 111 pop 1 - - 68 112 load_type 1 - 113 load_type 2 - 114 alloc_map 0 - 115 store_var 12 (calls_schema) - - 69 116 load_type 1 - 117 load_type 2 - 118 load_var 12 (calls_schema) - 119 load_const 23 ("type") - 120 load_const 24 ("object") - 121 call 37 ntypeargs=2 (baml.Map.set) - 122 pop 1 - - 70 123 load_type 1 - 124 load_type 2 - 125 load_var 12 (calls_schema) - 126 load_const 25 ("properties") - 127 load_var 11 (calls_props) - 128 call 37 ntypeargs=2 (baml.Map.set) - 129 pop 1 - - 71 130 load_type 1 - 131 load_type 2 - 132 load_var 12 (calls_schema) - 133 load_const 26 ("required") - 134 load_const 27 ("calls") - 135 load_type 1 - 136 alloc_array 1 - 137 call 37 ntypeargs=2 (baml.Map.set) - 138 pop 1 - - 72 139 load_type 1 - 140 load_type 2 - 141 load_var 12 (calls_schema) - 142 load_const 28 ("additionalProperties") - 143 load_const 18 (false) - 144 call 37 ntypeargs=2 (baml.Map.set) - 145 pop 1 - - 73 146 load_type 1 - 147 load_type 2 - 148 alloc_map 0 - 149 store_var 13 (outcome) - - 74 150 load_type 0 - 151 load_var 2 (final_root) - 152 call 355 ntypeargs=1 (baml.json.to_json) - 153 store_var 14 (_67) - 154 load_type 0 - 155 load_var 12 (calls_schema) - 156 call 355 ntypeargs=1 (baml.json.to_json) - 157 store_var 15 (_70) - 158 load_type 1 - 159 load_type 2 - 160 load_var 13 (outcome) - 161 load_const 29 ("anyOf") - 162 load_var2 14 15 - 163 load_type 30 - 164 alloc_array 2 - 165 call 37 ntypeargs=2 (baml.Map.set) - 166 pop 1 - - 75 167 load_type 1 - 168 load_type 2 - 169 alloc_map 0 - 170 store_var 16 (props) - - 76 171 load_type 1 - 172 load_type 2 - 173 load_var 16 (props) - 174 load_const 31 ("outcome") - 175 load_var 13 (outcome) - 176 call 37 ntypeargs=2 (baml.Map.set) - 177 pop 1 - - 77 178 load_type 1 - 179 load_type 2 - 180 alloc_map 0 - 181 store_var 17 (envelope) - - 78 182 load_type 1 - 183 load_type 2 - 184 load_var 17 (envelope) - 185 load_const 32 ("type") - 186 load_const 33 ("object") - 187 call 37 ntypeargs=2 (baml.Map.set) - 188 pop 1 - - 79 189 load_type 1 - 190 load_type 2 - 191 load_var 17 (envelope) - 192 load_const 34 ("properties") - 193 load_var 16 (props) - 194 call 37 ntypeargs=2 (baml.Map.set) - 195 pop 1 - - 80 196 load_type 1 - 197 load_type 2 - 198 load_var 17 (envelope) - 199 load_const 35 ("required") - 200 load_const 36 ("outcome") - 201 load_type 1 - 202 alloc_array 1 - 203 call 37 ntypeargs=2 (baml.Map.set) - 204 pop 1 - - 81 205 load_type 1 - 206 load_type 2 - 207 load_var 17 (envelope) - 208 load_const 37 ("additionalProperties") - 209 load_const 18 (false) - 210 call 37 ntypeargs=2 (baml.Map.set) - 211 pop 1 - - 82 212 load_var 4 (definitions) - 213 load_const 38 (null) - 214 call 672 ntypeargs=0 (baml.ops.equals_equals) - 215 unary_op ! - 216 pop_jump_if_false +8 (to 224) - - 83 217 load_type 1 - 218 load_type 2 - 219 load_var 17 (envelope) - 220 load_const 39 ("$defs") - 221 load_var 4 (definitions) - 222 call 37 ntypeargs=2 (baml.Map.set) - 223 pop 1 - - 85 224 load_var 17 (envelope) - 225 return -} - -function claude_code.internal.invoke(c: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 237 0 load_const 0 ("") - 1 load_var 2 (input) - 2 load_field 0 (prompt) - 3 call_indirect - 4 call 909 ntypeargs=0 (ai.Prompt.text) - 5 store_var 4 (instructions) - - 238 6 load_var 2 (input) - 7 load_field 2 (toolbox) - 8 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 9 unary_op ! - 10 store_var_load_var 5 (has_tools) - - 239 11 pop_jump_if_false +2 (to 13) - 12 jump +6 (to 18) - - 242 13 load_var 2 (input) - 14 load_field 3 (output_type) - 15 sys_op 365 (baml.json.schema) - 16 store_var 6 (schema) - 17 jump +9 (to 26) - - 240 18 load_var 2 (input) - 19 load_field 3 (output_type) - 20 call 1355 ntypeargs=0 (claude_code.internal.envelope_schema) - 21 store_var 7 (_11) - 22 load_type 1 - 23 load_var 7 (_11) - 24 call 355 ntypeargs=1 (baml.json.to_json) - 25 store_var 6 (schema) - - 244 26 load_var 5 (has_tools) - 27 pop_jump_if_false +2 (to 29) - 28 jump +17 (to 45) - - 247 29 load_type 2 - 30 load_var 4 (instructions) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 14 (_29) - 33 load_var 2 (input) - 34 load_field 1 (journal) - 35 call 1354 ntypeargs=0 (claude_code.internal.transcript_text) - 36 store_var 16 (_33) - 37 load_type 2 - 38 load_var 16 (_33) - 39 call 138 ntypeargs=1 (baml.String.from) - 40 store_var 15 (_32) - 41 load_var2 14 15 - 42 bin_op + - 43 store_var 8 (prompt_text) - - 244 44 jump +26 (to 70) - - 245 45 load_type 2 - 46 load_var 4 (instructions) - 47 call 138 ntypeargs=1 (baml.String.from) - 48 store_var 9 (_18) - 49 load_var 2 (input) - 50 load_field 1 (journal) - 51 call 1354 ntypeargs=0 (claude_code.internal.transcript_text) - 52 store_var 11 (_22) - 53 load_type 2 - 54 load_var 11 (_22) - 55 call 138 ntypeargs=1 (baml.String.from) - 56 store_var 10 (_21) - 57 load_var 2 (input) - 58 load_field 2 (toolbox) - 59 call 1357 ntypeargs=0 (claude_code.internal.tool_protocol) - 60 store_var 13 (_26) - 61 load_type 2 - 62 load_var 13 (_26) - 63 call 138 ntypeargs=1 (baml.String.from) - 64 store_var 12 (_25) - 65 load_var2 9 10 - 66 bin_op + - 67 load_var 12 (_25) - 68 bin_op + - 69 store_var 8 (prompt_text) - - 251 70 load_type 2 - 71 load_var 1 (c) - 72 load_field 1 (model) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 17 (_41) - 75 load_var 8 (prompt_text) - 76 call 139 ntypeargs=0 (baml.String.length) - 77 store_var 19 (_45) - 78 load_type 3 - 79 load_var 19 (_45) - 80 call 138 ntypeargs=1 (baml.String.from) - 81 store_var 18 (_44) - 82 load_var 2 (input) - 83 load_field 2 (toolbox) - 84 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 85 container_len - 86 store_var 21 (_48) - 87 load_type 3 - 88 load_var 21 (_48) - 89 call 138 ntypeargs=1 (baml.String.from) - 90 store_var 20 (_47) - - 250 91 load_const 4 ("$baml_log") - 92 load_const 5 ("info") - - 251 93 load_const 6 ("claude-code invoke: model=") - 94 load_var 17 (_41) - 95 bin_op + - 96 load_const 7 (" prompt_chars=") - 97 bin_op + - 98 load_var 18 (_44) - 99 bin_op + - 100 load_const 8 (" baml_tools=") - 101 bin_op + - 102 load_var 20 (_47) - 103 bin_op + - 104 load_const 9 ("level") - 105 load_const 10 ("data") - 106 load_type 2 - 107 load_type 11 - 108 alloc_map 2 - - 250 109 send_event - 110 pop 1 - - 253 111 load_type 2 - 112 alloc_array 0 - 113 store_var 22 (args) - - 254 114 load_type 2 - 115 load_var 22 (args) - 116 load_const 12 ("-p") - 117 call 4 ntypeargs=1 (baml.Array.push) - 118 pop 1 - - 255 119 load_type 2 - 120 load_var 22 (args) - 121 load_const 13 ("--output-format") - 122 call 4 ntypeargs=1 (baml.Array.push) - 123 pop 1 - - 256 124 load_type 2 - 125 load_var 22 (args) - 126 load_const 14 ("stream-json") - 127 call 4 ntypeargs=1 (baml.Array.push) - 128 pop 1 - - 257 129 load_type 2 - 130 load_var 22 (args) - 131 load_const 15 ("--verbose") - 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - - 258 134 load_type 2 - 135 load_var 22 (args) - 136 load_const 16 ("--model") - 137 call 4 ntypeargs=1 (baml.Array.push) - 138 pop 1 - - 259 139 load_type 2 - 140 load_var2 22 1 - 141 load_field 1 (model) - 142 call 4 ntypeargs=1 (baml.Array.push) - 143 pop 1 - - 260 144 load_type 2 - 145 load_var 22 (args) - 146 load_const 17 ("--permission-mode") - 147 call 4 ntypeargs=1 (baml.Array.push) - 148 pop 1 - - 261 149 load_type 2 - 150 load_var2 22 1 - 151 load_field 4 (permission_mode) - 152 call 4 ntypeargs=1 (baml.Array.push) - 153 pop 1 - - 262 154 load_type 2 - 155 load_var 22 (args) - 156 load_const 18 ("--no-session-persistence") - 157 call 4 ntypeargs=1 (baml.Array.push) - 158 pop 1 - - 263 159 load_type 2 - 160 load_var 22 (args) - 161 load_const 19 ("--tools") - 162 call 4 ntypeargs=1 (baml.Array.push) - 163 pop 1 - - 264 164 load_type 2 - 165 load_var 1 (c) - 166 load_field 5 (harness_tools) - 167 load_const 20 (",") - 168 call 15 ntypeargs=1 (baml.Array.join) - 169 store_var 23 (_76) - 170 load_type 2 - 171 load_var2 22 23 - 172 call 4 ntypeargs=1 (baml.Array.push) - 173 pop 1 - - 271 174 load_var 1 (c) - 175 call 1361 ntypeargs=0 (claude_code.internal.mcp_config_json) - 176 store_var 24 (_81) - 177 load_var 24 (_81) - 178 narrow_bind 21 24 - 179 pop_jump_if_false +31 (to 210) - 180 load_var 24 (_81) - 181 store_var 25 (mcp) - - 272 182 load_type 2 - 183 load_var 22 (args) - 184 load_const 22 ("--mcp-config") - 185 call 4 ntypeargs=1 (baml.Array.push) - 186 pop 1 - - 273 187 load_type 2 - 188 load_var2 22 25 - 189 call 4 ntypeargs=1 (baml.Array.push) - 190 pop 1 - - 274 191 load_type 2 - 192 load_var 22 (args) - 193 load_const 23 ("--strict-mcp-config") - 194 call 4 ntypeargs=1 (baml.Array.push) - 195 pop 1 - - 275 196 load_var 1 (c) - 197 call 1362 ntypeargs=0 (claude_code.internal.allowed_mcp_tools) - 198 store_var 27 (_93) - 199 load_type 2 - 200 load_var 27 (_93) - 201 call 138 ntypeargs=1 (baml.String.from) - 202 store_var 26 (_92) - 203 load_type 2 - 204 load_var 22 (args) - 205 load_const 24 ("--allowedTools=") - 206 load_var 26 (_92) - 207 bin_op + - 208 call 4 ntypeargs=1 (baml.Array.push) - 209 pop 1 - - 277 210 load_type 2 - 211 load_var 22 (args) - 212 load_const 25 ("--json-schema") - 213 call 4 ntypeargs=1 (baml.Array.push) - 214 pop 1 - - 278 215 load_var 6 (schema) - 216 call 351 ntypeargs=0 (baml.json.stringify) - 217 store_var 28 (_99) - 218 load_type 2 - 219 load_var2 22 28 - 220 call 4 ntypeargs=1 (baml.Array.push) - 221 pop 1 - - 279 222 load_type 2 - 223 load_var2 22 8 - 224 call 4 ntypeargs=1 (baml.Array.push) - 225 pop 1 - - 282 226 load_var 1 (c) - 227 load_field 0 (executable) - - 283 228 load_var2 22 1 - - 284 229 load_field 2 (cwd) - 230 load_const 26 (null) - 231 load_var 1 (c) - 232 load_field 3 (timeout_ms) - 233 load_const 26 (null) - 234 load_const 26 (null) - 235 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) - 236 sys_op 273 (baml.sys.start_process) - 237 store_var 29 (p) - 238 jump +18 (to 256) - - 281 239 load_var 30 (e) - 240 throw_if_panic - - 289 241 load_type 27 - 242 load_var 30 (e) - 243 call 138 ntypeargs=1 (baml.String.from) - 244 store_var 32 (_115) - 245 load_type 2 - 246 load_var 32 (_115) - 247 call 138 ntypeargs=1 (baml.String.from) - 248 store_var 31 (_114) - - 287 249 load_const 28 ("claude-code") - - 289 250 load_const 29 ("the Claude Code CLI could not start: ") - 251 load_var 31 (_114) - 252 bin_op + - 253 load_const 26 (null) - 254 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 255 throw - - 298 256 load_var 29 (p) - 257 sys_op 268 (baml.sys.Process.close_stdin) - 258 pop 1 - 259 jump +3 (to 262) - 260 load_var 35 (e) - 261 throw_if_panic - - 303 262 load_var 29 (p) - 263 call 1358 ntypeargs=0 (claude_code.internal._read_result) - 264 store_var 36 (result) - - 304 265 load_var 29 (p) - 266 sys_op 269 (baml.sys.Process.wait) - 267 store_var 37 (exit) - 268 jump +18 (to 286) - 269 load_var 38 (e) - 270 throw_if_panic - - 308 271 load_type 30 - 272 load_var 38 (e) - 273 call 138 ntypeargs=1 (baml.String.from) - 274 store_var 40 (_129) - 275 load_type 2 - 276 load_var 40 (_129) - 277 call 138 ntypeargs=1 (baml.String.from) - 278 store_var 39 (_128) - - 306 279 load_const 31 ("claude-code") - - 308 280 load_const 32 ("the Claude Code CLI did not terminate cleanly: ") - 281 load_var 39 (_128) - 282 bin_op + - 283 load_const 26 (null) - 284 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 285 throw - - 313 286 load_var 37 (exit) - 287 call 262 ntypeargs=0 (baml.sys.ProcessExit.ok) - 288 unary_op ! - 289 pop_jump_if_false +2 (to 291) - 290 jump +251 (to 541) - - 322 291 load_type 33 - 292 load_var 36 (result) - 293 load_const 34 (".is_error") - 294 load_const 35 (false) - 295 call 364 ntypeargs=1 (baml.json.path_or) - 296 pop_jump_if_false +2 (to 298) - 297 jump +231 (to 528) - - 330 298 load_type 2 - 299 load_var 36 (result) - 300 load_const 36 (".subtype") - 301 load_const 37 ("?") - 302 call 364 ntypeargs=1 (baml.json.path_or) - 303 store_var 45 (_154) - 304 load_type 2 - 305 load_var 45 (_154) - 306 call 138 ntypeargs=1 (baml.String.from) - 307 store_var 44 (_153) - 308 load_type 38 - 309 load_var 36 (result) - 310 load_const 39 (".total_cost_usd") - 311 load_const 40 (0.0) - 312 call 364 ntypeargs=1 (baml.json.path_or) - 313 store_var 47 (_159) - 314 load_type 38 - 315 load_var 47 (_159) - 316 call 138 ntypeargs=1 (baml.String.from) - 317 store_var 46 (_158) - 318 load_type 2 - 319 load_var 36 (result) - 320 load_const 41 (".session_id") - 321 load_const 42 ("?") - 322 call 364 ntypeargs=1 (baml.json.path_or) - 323 store_var 49 (_164) - 324 load_type 2 - 325 load_var 49 (_164) - 326 call 138 ntypeargs=1 (baml.String.from) - 327 store_var 48 (_163) - - 329 328 load_const 43 ("$baml_log") - 329 load_const 44 ("info") - - 330 330 load_const 45 ("claude-code result: subtype=") - 331 load_var 44 (_153) - 332 bin_op + - 333 load_const 46 (" cost_usd=") - 334 bin_op + - 335 load_var 46 (_158) - 336 bin_op + - 337 load_const 47 (" session=") - 338 bin_op + - 339 load_var 48 (_163) - 340 bin_op + - 341 load_const 48 ("level") - 342 load_const 49 ("data") - 343 load_type 2 - 344 load_type 11 - 345 alloc_map 2 - - 329 346 send_event - 347 pop 1 - - 332 348 load_type 50 - 349 load_var 36 (result) - 350 load_const 51 (".structured_output") - 351 call 363 ntypeargs=1 (baml.json.path) - 352 store_var 50 (structured) - 353 jump +20 (to 373) - 354 load_var 51 (e) - 355 throw_if_panic - - 334 356 load_type 2 - 357 load_var 36 (result) - 358 load_const 52 (".result") - 359 load_const 53 ("") - 360 call 364 ntypeargs=1 (baml.json.path_or) - 361 call 350 ntypeargs=0 (baml.json.parse) - 362 store_var 50 (structured) - 363 jump +10 (to 373) - 364 load_var 52 (inner) - 365 throw_if_panic - - 338 366 load_var 36 (result) - 367 call 351 ntypeargs=0 (baml.json.stringify) - 368 store_var 53 (_177) - - 336 369 load_const 54 ("claude-code") - 370 load_var 53 (_177) - 371 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 372 throw - - 346 373 load_type 3 - 374 load_var 36 (result) - 375 load_const 55 (".usage.input_tokens") - 376 load_const 56 (0) - 377 call 364 ntypeargs=1 (baml.json.path_or) - 378 store_var 54 (_180) - - 347 379 load_type 3 - 380 load_var 36 (result) - 381 load_const 57 (".usage.output_tokens") - 382 load_const 56 (0) - 383 call 364 ntypeargs=1 (baml.json.path_or) - 384 store_var 55 (_183) - - 348 385 load_type 58 - 386 load_var 36 (result) - 387 load_const 59 (".usage.cache_read_input_tokens") - 388 load_const 26 (null) - 389 call 364 ntypeargs=1 (baml.json.path_or) - 390 store_var 56 (_186) - - 352 391 load_type 60 - 392 alloc_array 0 - 393 store_var 57 (content) - - 353 394 load_const 56 (ai.content.StopReason.Complete) - 395 alloc_variant 774 (ai.content.StopReason) - 396 store_var 58 (stop) - - 354 397 load_var 5 (has_tools) - 398 pop_jump_if_false +2 (to 400) - 399 jump +10 (to 409) - - 382 400 load_var 50 (structured) - 401 call 351 ntypeargs=0 (baml.json.stringify) - 402 store_var 74 (_247) - 403 load_type 60 - 404 load_var2 57 74 - 405 init_instance 4 (ai.content.Text .text) - 406 call 4 ntypeargs=1 (baml.Array.push) - 407 pop 1 - 408 jump +108 (to 516) - - 355 409 load_type 50 - 410 load_var 36 (result) - 411 load_const 61 (".structured_output.outcome") - 412 load_var 50 (structured) - 413 call 364 ntypeargs=1 (baml.json.path_or) - 414 store_var 59 (outcome) - - 356 415 load_type 62 - 416 load_var 59 (outcome) - 417 load_const 63 (".calls") - 418 load_const 26 (null) - 419 call 364 ntypeargs=1 (baml.json.path_or) - - 357 420 store_var 60 (_199) - 421 load_var 60 (_199) - 422 narrow_bind 64 60 - 423 pop_jump_if_false +2 (to 425) - 424 jump +10 (to 434) - - 379 425 load_var 59 (outcome) - 426 call 351 ntypeargs=0 (baml.json.stringify) - 427 store_var 73 (_242) - 428 load_type 60 - 429 load_var2 57 73 - 430 init_instance 5 (ai.content.Text .text) - 431 call 4 ntypeargs=1 (baml.Array.push) - 432 pop 1 - 433 jump +83 (to 516) - - 358 434 load_const 56 (0) - 435 store_var 61 (i) - - 357 436 load_var 60 (_199) - 437 load_type 65 - 438 load_const 66 ("iter") - 439 virtual_call nargs=1 ntypeargs=0 - 440 store_var 62 (_203) - - 359 441 load_var 62 (_203) - 442 load_type 67 - 443 load_const 68 ("next") - 444 virtual_call nargs=1 ntypeargs=0 - 445 store_var 63 (_204) - 446 load_var 63 (_204) - 447 is_type 69 - 448 pop_jump_if_false +2 (to 450) - 449 jump +64 (to 513) - 450 load_var 63 (_204) - 451 store_var 64 (raw_call) - - 363 452 load_var 2 (input) - 453 load_field 1 (journal) - 454 call 905 ntypeargs=0 (ai.Journal.entries) - 455 container_len - 456 store_var 67 (_214) - 457 load_type 3 - 458 load_var 67 (_214) - 459 call 138 ntypeargs=1 (baml.String.from) - 460 store_var 66 (_213) - 461 load_type 3 - 462 load_var 61 (i) - 463 call 138 ntypeargs=1 (baml.String.from) - 464 store_var 68 (_218) - - 360 465 load_type 2 - - 361 466 load_var 64 (raw_call) - 467 load_const 70 (".id") - - 363 468 load_const 71 ("cc_call_") - 469 load_var 66 (_213) - 470 bin_op + - 471 load_const 72 ("_") - 472 bin_op + - 473 load_var 68 (_218) - 474 bin_op + - - 360 475 call 364 ntypeargs=1 (baml.json.path_or) - 476 store_var 65 (id) - - 365 477 load_type 2 - 478 load_var 64 (raw_call) - 479 load_const 73 (".name") - 480 load_const 74 ("") - 481 call 364 ntypeargs=1 (baml.json.path_or) - 482 store_var 69 (name) - - 367 483 load_type 50 - 484 load_var 64 (raw_call) - 485 load_const 75 (".args") - 486 load_type 2 - 487 load_type 50 - 488 alloc_map 0 - 489 call 364 ntypeargs=1 (baml.json.path_or) - 490 store_var 72 (_227) - - 366 491 load_type 1 - 492 load_var 72 (_227) - 493 call 358 ntypeargs=1 (baml.json.from_json) - 494 store_var 70 (call_args) - 495 jump +7 (to 502) - 496 load_var 71 (e) - 497 throw_if_panic - - 370 498 load_type 2 - 499 load_type 11 - 500 alloc_map 0 - 501 store_var 70 (call_args) - - 374 502 load_type 60 - 503 load_var2 57 65 - 504 load_var2 69 70 - 505 init_instance 6 (ai.content.ToolUse .id, .name, .args) - 506 call 4 ntypeargs=1 (baml.Array.push) - 507 pop 1 - - 375 508 load_var 61 (i) - 509 load_const 21 (1) - 510 add_int - 511 store_var 61 (i) - - 359 512 jump -71 (to 441) - - 377 513 load_const 21 (ai.content.StopReason.ToolUse) - 514 alloc_variant 774 (ai.content.StopReason) - 515 store_var 58 (stop) - - 384 516 load_var2 57 58 - - 345 517 load_var2 54 55 - 518 load_var 56 (_186) - 519 load_const 26 (null) - 520 init_instance 7 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 521 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) - 522 store_var 3 (_0) - - 295 523 load_var 29 (p) - 524 sys_op 271 (baml.sys.Process.close) - 525 pop 1 - 526 load_var 3 (_0) - 527 return - - 325 528 load_type 2 - 529 load_var 36 (result) - 530 load_const 76 (".subtype") - 531 load_const 77 ("error") - 532 call 364 ntypeargs=1 (baml.json.path_or) - 533 store_var 42 (_143) - - 326 534 load_var 36 (result) - 535 call 351 ntypeargs=0 (baml.json.stringify) - 536 store_var 43 (_146) - - 323 537 load_const 78 ("claude-code") - 538 load_var2 42 43 - 539 init_instance 9 (ai.errors.Refused .provider, .reason, .raw_body) - 540 throw - - 317 541 load_type 3 - 542 load_var 37 (exit) - 543 load_field 0 (exit_code) - 544 call 138 ntypeargs=1 (baml.String.from) - 545 store_var 41 (_136) - 546 jump +6 (to 552) - - 295 547 load_var 29 (p) - 548 sys_op 271 (baml.sys.Process.close) - 549 pop 1 - - 231 550 load_var 33 (_118) - 551 rethrow - - 314 552 load_const 79 ("claude-code") - 553 load_const 26 (null) - - 317 554 load_const 80 ("the Claude Code CLI exited with code ") - 555 load_var 41 (_136) - 556 bin_op + - 557 load_const 26 (null) - 558 init_instance 10 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 559 throw -} - -function claude_code.internal.mcp_config_json(c: claude_code.ClaudeCodeClient) -> string | null { - 211 0 load_var 1 (c) - 1 load_field 6 (mcp_servers) - 2 container_len - 3 store_var 2 (_3) - 4 load_var 2 (_3) - 5 load_const 0 (0) - 6 cmp_int_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 214 9 load_type 1 - 10 load_type 2 - 11 alloc_map 0 - 12 store_var 3 (wrapper) - - 215 13 load_type 1 - 14 load_type 2 - 15 load_var 3 (wrapper) - 16 load_const 3 ("mcpServers") - 17 load_var 1 (c) - 18 load_field 6 (mcp_servers) - 19 call 37 ntypeargs=2 (baml.Map.set) - 20 pop 1 - - 216 21 load_type 4 - 22 load_var 3 (wrapper) - 23 call 355 ntypeargs=1 (baml.json.to_json) - 24 call 351 ntypeargs=0 (baml.json.stringify) - 25 jump +2 (to 27) - - 212 26 load_const 5 (null) - 27 return -} - -function claude_code.internal.tool_protocol(tb: ai.tools.Toolbox) -> string { - 99 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (catalog) - - 100 3 load_var 1 (tb) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +41 (to 58) - 18 load_var 4 (_5) - 19 store_var 5 (t) - - 102 20 load_type 0 - 21 load_var 5 (t) - 22 load_field 0 (name) - 23 call 138 ntypeargs=1 (baml.String.from) - 24 store_var 6 (_16) - 25 load_type 0 - 26 load_var 5 (t) - 27 load_field 1 (description) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 7 (_19) - 30 load_type 6 - 31 load_var 5 (t) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 call 351 ntypeargs=0 (baml.json.stringify) - 35 store_var 9 (_23) - 36 load_type 0 - 37 load_var 9 (_23) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 8 (_22) - - 101 40 load_type 0 - 41 load_var 2 (catalog) - - 102 42 load_const 7 ("{\"name\": \"") - 43 load_var 6 (_16) - 44 bin_op + - 45 load_const 8 ("\", \"description\": \"") - 46 bin_op + - 47 load_var 7 (_19) - 48 bin_op + - 49 load_const 9 ("\", \"parameters\": ") - 50 bin_op + - 51 load_var 8 (_22) - 52 bin_op + - 53 load_const 10 ("}") - 54 bin_op + - - 101 55 call 4 ntypeargs=1 (baml.Array.push) - 56 pop 1 - 57 jump -48 (to 9) - - 121 58 load_type 0 - 59 load_var 2 (catalog) - 60 load_const 11 (", ") - 61 call 15 ntypeargs=1 (baml.Array.join) - 62 store_var 11 (_31) - - 105 63 load_type 0 - 64 load_var 11 (_31) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 10 (_30) - 67 load_const 12 ("\n\nThe output contract is one object with an outcome field. Set outcome\nto either the final result or a tool request. The tools in the catalog\nbelow are NOT installed in your environment — never attempt to invoke\nthem directly; any such attempt fails. The ONLY way to run one is to\nfinish your reply with outcome set to\n{\"calls\": [{\"id\": \"\", \"name\": \"\", \"args\": {...}}]};\nthe caller executes the calls and re-invokes you with their results in\nthe conversation. If the Conversation so far section shows no tool\nresults yet, your outcome MUST be a calls request — never invent data a\ntool can provide. After tool results appear in the conversation, use\nthem; the Conversation so far section is authoritative. A tool result\nwith is_error=false means that call already ran — never repeat the same\nsuccessful tool call. Request only tools that are still necessary, or\nreturn the final result.\n\nApplication tool catalog (request via outcome.calls only):\n[") - 68 load_var 10 (_30) - 69 bin_op + - 70 load_const 13 ("]") - 71 bin_op + - 72 return -} - -function claude_code.internal.transcript_text(j: ai.Journal) -> string { - 7 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (lines) - - 8 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +168 (to 185) - 18 load_var 4 (_5) - 19 store_var 5 (e) - - 9 20 load_var 5 (e) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +147 (to 172) - 26 load_var 5 (e) - 27 store_var 8 (_17) - 28 load_var 8 (_17) - 29 narrow_bind 7 8 - 30 pop_jump_if_false +2 (to 32) - 31 jump +60 (to 91) - 32 load_var 5 (e) - 33 store_var 20 (_55) - 34 load_var 20 (_55) - 35 narrow_bind 8 20 - 36 pop_jump_if_false +2 (to 38) - 37 jump +30 (to 67) - 38 load_var 5 (e) - 39 store_var 24 (_68) - 40 load_var 24 (_68) - 41 narrow_bind 9 24 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 24 (_68) - 44 store_var 25 (failed) - - 34 45 load_type 0 - 46 load_var 25 (failed) - 47 load_field 0 (id) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 26 (_74) - 50 load_type 0 - 51 load_var 25 (failed) - 52 load_field 1 (message) - 53 call 138 ntypeargs=1 (baml.String.from) - 54 store_var 27 (_77) - 55 load_type 0 - 56 load_var 2 (lines) - 57 load_const 10 ("tool result id=") - 58 load_var 26 (_74) - 59 bin_op + - 60 load_const 11 (" is_error=true: ") - 61 bin_op + - 62 load_var 27 (_77) - 63 bin_op + - 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - 66 jump -57 (to 9) - - 9 67 load_var 20 (_55) - 68 store_var 21 (done) - - 31 69 load_type 0 - 70 load_var 21 (done) - 71 load_field 0 (id) - 72 call 138 ntypeargs=1 (baml.String.from) - 73 store_var 22 (_61) - 74 load_type 0 - 75 load_var 21 (done) - 76 load_field 1 (output) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 23 (_64) - 79 load_type 0 - 80 load_var 2 (lines) - 81 load_const 12 ("tool result id=") - 82 load_var 22 (_61) - 83 bin_op + - 84 load_const 13 (" is_error=false: ") - 85 bin_op + - 86 load_var 23 (_64) - 87 bin_op + - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 9 91 load_var 8 (_17) - 92 load_field 0 (content) - 93 load_type 14 - 94 load_const 15 ("iter") - 95 virtual_call nargs=1 ntypeargs=0 - 96 store_var 9 (_20) - - 14 97 load_var 9 (_20) - 98 load_type 16 - 99 load_const 17 ("next") - 100 virtual_call nargs=1 ntypeargs=0 - 101 store_var 10 (_21) - 102 load_var 10 (_21) - 103 is_type 5 - 104 pop_jump_if_false +2 (to 106) - 105 jump -96 (to 9) - 106 load_var 10 (_21) - 107 store_var 11 (b) - - 15 108 load_var 11 (b) - 109 store_var 12 (_25) - 110 load_var 12 (_25) - 111 narrow_bind 18 12 - 112 pop_jump_if_false +2 (to 114) - 113 jump +46 (to 159) - 114 load_var 11 (b) - 115 store_var 14 (_33) - 116 load_var 14 (_33) - 117 narrow_bind 19 14 - 118 pop_jump_if_false -21 (to 97) - 119 load_var 14 (_33) - 120 store_var 15 (c) - - 21 121 load_type 0 - 122 load_var 15 (c) - 123 load_field 0 (id) - 124 call 138 ntypeargs=1 (baml.String.from) - 125 store_var 16 (_42) - 126 load_type 0 - 127 load_var 15 (c) - 128 load_field 1 (name) - 129 call 138 ntypeargs=1 (baml.String.from) - 130 store_var 17 (_45) - 131 load_type 20 - 132 load_var 15 (c) - 133 load_field 2 (args) - 134 call 355 ntypeargs=1 (baml.json.to_json) - 135 call 351 ntypeargs=0 (baml.json.stringify) - 136 store_var 19 (_49) - 137 load_type 0 - 138 load_var 19 (_49) - 139 call 138 ntypeargs=1 (baml.String.from) - 140 store_var 18 (_48) - - 20 141 load_type 0 - 142 load_var 2 (lines) - - 21 143 load_const 21 ("assistant tool_call: {\"id\": \"") - 144 load_var 16 (_42) - 145 bin_op + - 146 load_const 22 ("\", \"name\": \"") - 147 bin_op + - 148 load_var 17 (_45) - 149 bin_op + - 150 load_const 23 ("\", \"args\": ") - 151 bin_op + - 152 load_var 18 (_48) - 153 bin_op + - 154 load_const 24 ("}") - 155 bin_op + - - 20 156 call 4 ntypeargs=1 (baml.Array.push) - 157 pop 1 - 158 jump -61 (to 97) - - 17 159 load_type 0 - - 15 160 load_var 12 (_25) - 161 load_field 0 (text) - - 17 162 call 138 ntypeargs=1 (baml.String.from) - 163 store_var 13 (_29) - 164 load_type 0 - 165 load_var 2 (lines) - 166 load_const 25 ("assistant: ") - 167 load_var 13 (_29) - 168 bin_op + - 169 call 4 ntypeargs=1 (baml.Array.push) - 170 pop 1 - 171 jump -74 (to 97) - - 11 172 load_type 0 - - 9 173 load_var 6 (_9) - 174 load_field 0 (content) - - 11 175 call 138 ntypeargs=1 (baml.String.from) - 176 store_var 7 (_13) - 177 load_type 0 - 178 load_var 2 (lines) - 179 load_const 26 ("user: ") - 180 load_var 7 (_13) - 181 bin_op + - 182 call 4 ntypeargs=1 (baml.Array.push) - 183 pop 1 - 184 jump -175 (to 9) - - 41 185 load_var 2 (lines) - 186 container_len - 187 store_var 28 (_82) - 188 load_var 28 (_82) - 189 load_const 27 (0) - 190 cmp_int_op == - 191 pop_jump_if_false +2 (to 193) - 192 jump +14 (to 206) - - 44 193 load_type 0 - 194 load_var 2 (lines) - 195 load_const 28 ("\n") - 196 call 15 ntypeargs=1 (baml.Array.join) - 197 store_var 30 (_84) - 198 load_type 0 - 199 load_var 30 (_84) - 200 call 138 ntypeargs=1 (baml.String.from) - 201 store_var 29 (_83) - 202 load_const 29 ("\n\nConversation so far:\n") - 203 load_var 29 (_83) - 204 bin_op + - - 41 205 jump +2 (to 207) - - 42 206 load_const 30 ("") - 207 return -} - -function google.GoogleClient.ai.Client.id(self: google.GoogleClient) -> string { - 125 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("google/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function google.GoogleClient.ai.Client.invoke(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 129 0 load_var2 1 2 - 1 call 1246 ntypeargs=0 (google.internal.gemini_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 130 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.GoogleClient.ai.stream.StreamingClient.invoke_stream(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 137 0 load_var2 1 2 - 1 call 1248 ntypeargs=0 (google.internal.gemini_invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 138 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.GoogleClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.GoogleClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 70 4 load_const 1 ("gemini-2.5-flash") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 71 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 72 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (request_body) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 73 22 load_const 2 (null) - 23 store_var 4 (request_body) - 24 load_var 5 (headers) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 74 28 load_const 2 (null) - 29 store_var 5 (headers) - 30 load_var 6 (query_params) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 75 34 load_const 2 (null) - 35 store_var 6 (query_params) - 36 load_var 7 (temperature) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 76 40 load_const 2 (null) - 41 store_var 7 (temperature) - 42 load_var 8 (max_output_tokens) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 77 46 load_const 2 (null) - 47 store_var 8 (max_output_tokens) - 48 load_var 9 (top_p) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 78 52 load_const 2 (null) - 53 store_var 9 (top_p) - 54 load_var 10 (top_k) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 79 58 load_const 2 (null) - 59 store_var 10 (top_k) - 60 load_var 11 (stop_sequences) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 80 64 load_const 2 (null) - 65 store_var 11 (stop_sequences) - 66 load_var 12 (response_modalities) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 81 70 load_const 2 (null) - 71 store_var 12 (response_modalities) - 72 load_var 13 (safety_settings) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 82 76 load_const 2 (null) - 77 store_var 13 (safety_settings) - - 84 78 load_var2 1 2 - 79 load_var2 3 4 - 80 load_var2 5 6 - 81 load_var2 7 8 - 82 load_var2 9 10 - 83 load_var2 11 12 - 84 load_var 13 (safety_settings) - 85 init_instance 0 (google.GoogleClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings) - 86 return -} - -function google.GoogleClient.resolved_api_key(self: google.GoogleClient) -> string { - 107 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("GOOGLE_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 113 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("GOOGLE_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 3 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - - 110 18 load_const 4 ("google") - 19 load_const 5 (null) - - 113 20 load_const 6 ("google needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 21 load_var 3 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 107 26 load_var 2 (_4) - 27 return -} - -function google.GoogleClient.resolved_base_url(self: google.GoogleClient) -> string | null { - 120 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.SafetySetting.new(category: string, threshold: string) -> google.SafetySetting { - 22 0 load_var2 1 2 - 1 init_instance 0 (google.SafetySetting .category, .threshold) - 2 return -} - -function google.VertexClient.ai.Client.id(self: google.VertexClient) -> string { - 109 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("vertex/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function google.VertexClient.ai.Client.invoke(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 113 0 load_var2 1 2 - 1 call 1265 ntypeargs=0 (google.internal.vertex_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 114 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.VertexClient.ai.stream.StreamingClient.invoke_stream(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 121 0 load_var2 1 2 - 1 call 1267 ntypeargs=0 (google.internal.vertex_invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 122 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.VertexClient.new(model: string, project_id: string | null, location: string | null, credentials_json: string | null, credentials_file: string | null, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.VertexClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 57 4 load_const 1 ("gemini-2.5-flash") - 5 store_var 1 (model) - 6 load_var 2 (project_id) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 58 10 load_const 2 (null) - 11 store_var 2 (project_id) - 12 load_var 3 (location) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 59 16 load_const 2 (null) - 17 store_var 3 (location) - 18 load_var 4 (credentials_json) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 60 22 load_const 2 (null) - 23 store_var 4 (credentials_json) - 24 load_var 5 (credentials_file) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 61 28 load_const 2 (null) - 29 store_var 5 (credentials_file) - 30 load_var 6 (api_key) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 62 34 load_const 2 (null) - 35 store_var 6 (api_key) - 36 load_var 7 (base_url) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 63 40 load_const 2 (null) - 41 store_var 7 (base_url) - 42 load_var 8 (request_body) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 64 46 load_const 2 (null) - 47 store_var 8 (request_body) - 48 load_var 9 (headers) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 65 52 load_const 2 (null) - 53 store_var 9 (headers) - 54 load_var 10 (query_params) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 66 58 load_const 2 (null) - 59 store_var 10 (query_params) - 60 load_var 11 (temperature) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 67 64 load_const 2 (null) - 65 store_var 11 (temperature) - 66 load_var 12 (max_output_tokens) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 68 70 load_const 2 (null) - 71 store_var 12 (max_output_tokens) - 72 load_var 13 (top_p) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 69 76 load_const 2 (null) - 77 store_var 13 (top_p) - 78 load_var 14 (top_k) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 70 82 load_const 2 (null) - 83 store_var 14 (top_k) - 84 load_var 15 (stop_sequences) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 71 88 load_const 2 (null) - 89 store_var 15 (stop_sequences) - 90 load_var 16 (response_modalities) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 72 94 load_const 2 (null) - 95 store_var 16 (response_modalities) - 96 load_var 17 (safety_settings) - 97 load_const 0 () - 98 cmp_op == - 99 pop_jump_if_false +3 (to 102) - - 73 100 load_const 2 (null) - 101 store_var 17 (safety_settings) - - 75 102 load_var2 1 2 - 103 load_var2 3 4 - 104 load_var2 5 6 - 105 load_var2 7 8 - 106 load_var2 9 10 - 107 load_var2 11 12 - 108 load_var2 13 14 - 109 load_var2 15 16 - 110 load_var 17 (safety_settings) - 111 init_instance 0 (google.VertexClient .model, .project_id, .location, .credentials_json, .credentials_file, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings) - 112 return -} - -function google.VertexClient.resolved_api_key(self: google.VertexClient) -> string | null { - 99 0 load_var 1 (self) - 1 load_field 5 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.VertexClient.resolved_base_url(self: google.VertexClient) -> string | null { - 104 0 load_var 1 (self) - 1 load_field 6 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.internal.GmPart.of_file_data(data: google.internal.GmFileData) -> google.internal.GmPart { - 86 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_var 1 (data) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 return -} - -function google.internal.GmPart.of_function_call(call: google.internal.GmFunctionCall, signature: string | null) -> google.internal.GmPart { - 100 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_var 1 (call) - 4 load_const 0 (null) - 5 load_var 2 (signature) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 return -} - -function google.internal.GmPart.of_function_response(response: google.internal.GmFunctionResponse) -> google.internal.GmPart { - 111 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_var 1 (response) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 return -} - -function google.internal.GmPart.of_inline_data(data: google.internal.GmInlineData) -> google.internal.GmPart { - 75 0 load_const 0 (null) - 1 load_var 1 (data) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 return -} - -function google.internal.GmPart.of_text(text: string) -> google.internal.GmPart { - 64 0 load_var 1 (text) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 return -} - -function google.internal._gm_apply_headers(headers: map, extra: map | null) -> map { - 339 0 load_var 2 (extra) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 345 6 load_var 1 (headers) - - 339 7 jump +43 (to 50) - 8 load_var 3 (_3) - 9 store_var 4 (items) - - 340 10 load_type 1 - 11 load_type 1 - 12 load_var 4 (items) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_8) - 18 load_var 5 (_8) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 6 (_9) - 23 load_var 6 (_9) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +23 (to 49) - 27 load_var 6 (_9) - 28 store_var 7 (name) - - 341 29 load_var 7 (name) - 30 call 142 ntypeargs=0 (baml.String.to_lower_case) - 31 store_var 8 (_14) - 32 load_type 1 - 33 load_type 1 - 34 load_var2 4 7 - 35 call 38 ntypeargs=2 (baml.Map.get) - 36 store_var_load_var 9 (_16) - 37 load_const 7 (null) - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - 40 load_const 8 ("") - 41 store_var 9 (_16) - 42 load_type 1 - 43 load_type 1 - 44 load_var2 1 8 - 45 load_var 9 (_16) - 46 call 37 ntypeargs=2 (baml.Map.set) - 47 pop 1 - 48 jump -30 (to 18) - - 343 49 load_var 1 (headers) - 50 return -} - -function google.internal._gm_apply_query(url: string, params: map | null) -> string { - 316 0 load_var 2 (params) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 328 6 load_var 1 (url) - - 316 7 jump +77 (to 84) - 8 load_var 3 (_3) - 9 store_var 4 (items) - - 317 10 load_var 1 (url) - 11 store_var 5 (out) - - 318 12 load_type 1 - 13 load_type 1 - 14 load_var 4 (items) - 15 call 35 ntypeargs=2 (baml.Map.keys) - 16 load_type 2 - 17 load_const 3 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 6 (_9) - 20 load_var 6 (_9) - 21 load_type 4 - 22 load_const 5 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 7 (_10) - 25 load_var 7 (_10) - 26 is_type 6 - 27 pop_jump_if_false +2 (to 29) - 28 jump +55 (to 83) - 29 load_var 7 (_10) - 30 store_var 8 (name) - - 319 31 load_var 5 (out) - 32 load_const 7 ("?") - 33 call 147 ntypeargs=0 (baml.String.includes) - 34 pop_jump_if_false +2 (to 36) - 35 jump +4 (to 39) - - 322 36 load_const 8 ("?") - 37 store_var 9 (separator) - - 319 38 jump +3 (to 41) - - 320 39 load_const 9 ("&") - 40 store_var 9 (separator) - - 324 41 load_type 1 - 42 load_var 5 (out) - 43 call 138 ntypeargs=1 (baml.String.from) - 44 store_var 10 (_19) - 45 load_type 1 - 46 load_var 9 (separator) - 47 call 138 ntypeargs=1 (baml.String.from) - 48 store_var 11 (_22) - 49 load_var 8 (name) - 50 call 1220 ntypeargs=0 (google.internal._gm_encode_query) - 51 store_var 13 (_26) - 52 load_type 1 - 53 load_var 13 (_26) - 54 call 138 ntypeargs=1 (baml.String.from) - 55 store_var 12 (_25) - 56 load_type 1 - 57 load_type 1 - 58 load_var2 4 8 - 59 call 38 ntypeargs=2 (baml.Map.get) - 60 store_var_load_var 16 (_32) - 61 load_const 10 (null) - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - 64 load_const 11 ("") - 65 store_var 16 (_32) - 66 load_var 16 (_32) - 67 call 1220 ntypeargs=0 (google.internal._gm_encode_query) - 68 store_var 15 (_30) - 69 load_type 1 - 70 load_var 15 (_30) - 71 call 138 ntypeargs=1 (baml.String.from) - 72 store_var 14 (_29) - 73 load_var2 10 11 - 74 bin_op + - 75 load_var 12 (_25) - 76 bin_op + - 77 load_const 12 ("=") - 78 bin_op + - 79 load_var 14 (_29) - 80 bin_op + - 81 store_var 5 (out) - - 318 82 jump -62 (to 20) - - 326 83 load_var 5 (out) - 84 return -} - -function google.internal._gm_call_id_signature(id: string) -> string | null { - 549 0 call 1230 ntypeargs=0 (google.internal._gm_sig_marker) - 1 store_var 2 (marker) - - 550 2 load_var2 1 2 - 3 call 155 ntypeargs=0 (baml.String.index_of) - 4 store_var 3 (_5) - 5 load_var 3 (_5) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +3 (to 11) - - 553 9 load_const 1 (null) - - 550 10 jump +14 (to 24) - 11 load_var 3 (_5) - 12 store_var 5 (_8) - - 551 13 load_var 2 (marker) - 14 call 139 ntypeargs=0 (baml.String.length) - 15 load_var 5 (_8) - 16 add_int - 17 store_var 4 (_7) - 18 load_var 1 (id) - 19 call 139 ntypeargs=0 (baml.String.length) - 20 store_var 6 (_10) - 21 load_var2 1 4 - 22 load_var 6 (_10) - 23 call 153 ntypeargs=0 (baml.String.slice) - 24 return -} - -function google.internal._gm_decode_batch(batch: string, provider: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 973 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 974 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +267 (to 284) - 18 load_var 5 (_6) - 19 load_field 1 (data) - 20 store_var_load_var 7 (_12) - - 975 21 load_const 6 (null) - 22 cmp_op == - 23 pop_jump_if_false +3 (to 26) - 24 load_const 7 ("") - 25 store_var 7 (_12) - 26 load_var 7 (_12) - 27 call 144 ntypeargs=0 (baml.String.trim) - 28 store_var 6 (payload) - - 978 29 load_var 6 (payload) - 30 load_const 8 ("") - 31 cmp_op == - 32 jump_if_false +2 (to 34) - 33 jump +5 (to 38) - 34 pop 1 - 35 load_var 6 (payload) - 36 load_const 9 ("[DONE]") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump -30 (to 9) - - 981 40 load_type 10 - 41 load_var 6 (payload) - 42 call 357 ntypeargs=1 (baml.json.from_string) - 43 store_var 8 (resp) - 44 jump +6 (to 50) - 45 load_var 9 (e) - 46 throw_if_panic - - 983 47 load_var2 2 6 - 48 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 49 throw - - 989 50 load_var 8 (resp) - 51 load_field 5 (error) - 52 store_var 10 (_26) - 53 load_var 10 (_26) - 54 narrow_bind 11 10 - 55 pop_jump_if_false +2 (to 57) - 56 jump +204 (to 260) - - 992 57 load_var 8 (resp) - 58 load_field 0 (candidates) - 59 load_const 6 (null) - 60 cmp_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +8 (to 70) - 63 load_const 12 (0) - 64 load_var 8 (resp) - 65 load_field 0 (candidates) - 66 make_bound_method 3 - 67 call_indirect - 68 store_var 15 (cand) - 69 jump +3 (to 72) - 70 load_const 6 (null) - 71 store_var 15 (cand) - - 993 72 load_var 15 (cand) - 73 load_const 6 (null) - 74 cmp_op == - 75 pop_jump_if_false +2 (to 77) - 76 jump +16 (to 92) - 77 load_var 15 (cand) - 78 load_field 0 (0) - 79 load_const 6 (null) - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +10 (to 92) - 83 load_var 15 (cand) - 84 load_const 6 (null) - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +5 (to 92) - 88 load_var 15 (cand) - 89 load_field 0 (0) - 90 load_field 1 (1) - 91 jump +2 (to 93) - 92 load_const 6 (null) - 93 store_var_load_var 16 (_43) - 94 load_const 6 (null) - 95 cmp_op == - 96 pop_jump_if_false +4 (to 100) - 97 load_type 13 - 98 alloc_array 0 - 99 store_var 16 (_43) - 100 load_var 16 (_43) - 101 load_type 14 - 102 load_const 15 ("iter") - 103 virtual_call nargs=1 ntypeargs=0 - 104 store_var 17 (_56) - - 994 105 load_var 17 (_56) - 106 load_type 16 - 107 load_const 17 ("next") - 108 virtual_call nargs=1 ntypeargs=0 - 109 store_var 18 (_57) - 110 load_var 18 (_57) - 111 is_type 5 - 112 pop_jump_if_false +2 (to 114) - 113 jump +27 (to 140) - 114 load_var 18 (_57) - 115 store_var_load_var 19 (p) - - 995 116 load_field 0 (text) - 117 store_var 20 (_62) - 118 load_var 20 (_62) - 119 narrow_bind 18 20 - 120 pop_jump_if_false -15 (to 105) - 121 load_var 20 (_62) - 122 store_var 21 (t) - - 996 123 load_var 19 (p) - 124 load_field 1 (thought) - 125 store_var_load_var 22 (_65) - 126 load_const 6 (null) - 127 cmp_op == - 128 pop_jump_if_false +3 (to 131) - 129 load_const 19 (false) - 130 store_var 22 (_65) - 131 load_var 22 (_65) - 132 pop_jump_if_false +2 (to 134) - 133 jump -28 (to 105) - - 999 134 load_type 0 - 135 load_var2 3 21 - 136 init_instance 1 (ai.stream.TextDelta .text) - 137 call 4 ntypeargs=1 (baml.Array.push) - 138 pop 1 - 139 jump -34 (to 105) - - 1006 140 load_var 15 (cand) - 141 load_const 6 (null) - 142 cmp_op == - 143 pop_jump_if_false +2 (to 145) - 144 jump +4 (to 148) - 145 load_var 15 (cand) - 146 load_field 1 (1) - 147 jump +2 (to 149) - 148 load_const 6 (null) - 149 store_var_load_var 24 (_73) - 150 load_const 6 (null) - 151 cmp_op == - 152 pop_jump_if_false +3 (to 155) - 153 load_const 20 ("") - 154 store_var 24 (_73) - 155 load_var 24 (_73) - 156 store_var 23 (finish) - - 1007 157 load_var 8 (resp) - 158 load_field 2 (promptFeedback) - 159 load_const 6 (null) - 160 cmp_op == - 161 pop_jump_if_false +2 (to 163) - 162 jump +5 (to 167) - 163 load_var 8 (resp) - 164 load_field 2 (promptFeedback) - 165 load_field 0 (0) - 166 jump +2 (to 168) - 167 load_const 6 (null) - 168 load_const 6 (null) - 169 call 672 ntypeargs=0 (baml.ops.equals_equals) - 170 store_var 25 (_84) - - 1008 171 load_var 23 (finish) - 172 load_const 21 ("MAX_TOKENS") - 173 cmp_op == - 174 pop_jump_if_false +2 (to 176) - 175 jump +26 (to 201) - - 1007 176 load_var 25 (_84) - 177 unary_op ! - 178 jump_if_false +2 (to 180) - 179 jump +4 (to 183) - 180 pop 1 - - 1010 181 load_var 23 (finish) - 182 call 1238 ntypeargs=0 (google.internal._gm_is_blocked) - 183 pop_jump_if_false +2 (to 185) - 184 jump +13 (to 197) - - 1012 185 load_var 23 (finish) - 186 load_const 22 ("") - 187 cmp_op != - 188 pop_jump_if_false +2 (to 190) - 189 jump +4 (to 193) - - 1015 190 load_const 6 (null) - 191 store_var 26 (stop) - - 1012 192 jump +12 (to 204) - - 1013 193 load_const 12 (ai.content.StopReason.Complete) - 194 alloc_variant 774 (ai.content.StopReason) - 195 store_var 26 (stop) - - 1012 196 jump +8 (to 204) - - 1011 197 load_const 23 (ai.content.StopReason.Refused) - 198 alloc_variant 774 (ai.content.StopReason) - 199 store_var 26 (stop) - - 1010 200 jump +4 (to 204) - - 1009 201 load_const 24 (ai.content.StopReason.MaxTokens) - 202 alloc_variant 774 (ai.content.StopReason) - 203 store_var 26 (stop) - - 1017 204 load_var 8 (resp) - 205 load_field 1 (usageMetadata) - 206 store_var 27 (usage) - - 1018 207 load_var 26 (stop) - 208 load_const 6 (null) - 209 call 672 ntypeargs=0 (baml.ops.equals_equals) - 210 unary_op ! - 211 jump_if_false +2 (to 213) - 212 jump +6 (to 218) - 213 pop 1 - 214 load_var 27 (usage) - 215 load_const 6 (null) - 216 call 672 ntypeargs=0 (baml.ops.equals_equals) - 217 unary_op ! - 218 pop_jump_if_false +31 (to 249) - - 1021 219 load_var 26 (stop) - 220 store_var 28 (_102) - - 1022 221 load_var 27 (usage) - 222 load_const 6 (null) - 223 cmp_op == - 224 pop_jump_if_false +2 (to 226) - 225 jump +5 (to 230) - 226 load_var 27 (usage) - 227 load_field 0 (0) - 228 store_var 29 (_103) - 229 jump +3 (to 232) - 230 load_const 6 (null) - 231 store_var 29 (_103) - - 1023 232 load_var 27 (usage) - 233 load_const 6 (null) - 234 cmp_op == - 235 pop_jump_if_false +2 (to 237) - 236 jump +5 (to 241) - 237 load_var 27 (usage) - 238 load_field 1 (1) - 239 store_var 30 (_107) - 240 jump +3 (to 243) - 241 load_const 6 (null) - 242 store_var 30 (_107) - - 1019 243 load_type 0 - 244 load_var2 3 28 - - 1020 245 load_var2 29 30 - 246 init_instance 2 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1019 247 call 4 ntypeargs=1 (baml.Array.push) - 248 pop 1 - - 1033 249 load_var 26 (stop) - 250 load_const 6 (null) - 251 call 672 ntypeargs=0 (baml.ops.equals_equals) - 252 unary_op ! - 253 pop_jump_if_false -244 (to 9) - - 1034 254 load_type 0 - 255 load_var 3 (out) - 256 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 257 call 4 ntypeargs=1 (baml.Array.push) - 258 pop 1 - 259 jump -250 (to 9) - - 989 260 load_var 10 (_26) - 261 store_var_load_var 11 (err) - - 990 262 load_field 0 (code) - 263 store_var_load_var 13 (_30) - 264 load_const 6 (null) - 265 cmp_op == - 266 pop_jump_if_false +3 (to 269) - 267 load_const 12 (0) - 268 store_var 13 (_30) - 269 load_var 13 (_30) - 270 store_var 12 (_29) - 271 load_var 11 (err) - 272 load_field 1 (message) - 273 store_var_load_var 14 (_34) - 274 load_const 6 (null) - 275 cmp_op == - 276 pop_jump_if_false +3 (to 279) - 277 load_var 6 (payload) - 278 store_var 14 (_34) - 279 load_var2 2 12 - 280 load_var 14 (_34) - 281 load_const 25 () - 282 call 977 ntypeargs=0 (ai.errors.classify_http) - 283 throw - - 1042 284 load_var 3 (out) - 285 return -} - -function google.internal._gm_encode_call_id(id: string, signature: string | null) -> string { - 540 0 load_var 2 (signature) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 543 6 load_var 1 (id) - - 540 7 jump +21 (to 28) - 8 load_var 3 (_3) - 9 store_var 4 (sig) - - 541 10 load_type 1 - 11 load_var 1 (id) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 5 (_6) - 14 call 1230 ntypeargs=0 (google.internal._gm_sig_marker) - 15 store_var 7 (_9) - 16 load_type 1 - 17 load_var 7 (_9) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 6 (_8) - 20 load_type 1 - 21 load_var 4 (sig) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 8 (_11) - 24 load_var2 5 6 - 25 bin_op + - 26 load_var 8 (_11) - 27 bin_op + - 28 return -} - -function google.internal._gm_encode_query(value: string) -> string { - 299 0 load_var 1 (value) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("\"") - 8 load_const 5 ("%22") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("#") - 11 load_const 7 ("%23") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("&") - 14 load_const 9 ("%26") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("+") - 17 load_const 11 ("%2B") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - 19 load_const 12 ("/") - 20 load_const 13 ("%2F") - 21 call 160 ntypeargs=0 (baml.String.replace_all) - 22 load_const 14 ("<") - 23 load_const 15 ("%3C") - 24 call 160 ntypeargs=0 (baml.String.replace_all) - 25 load_const 16 ("=") - 26 load_const 17 ("%3D") - 27 call 160 ntypeargs=0 (baml.String.replace_all) - 28 load_const 18 (">") - 29 load_const 19 ("%3E") - 30 call 160 ntypeargs=0 (baml.String.replace_all) - 31 load_const 20 ("?") - 32 load_const 21 ("%3F") - 33 call 160 ntypeargs=0 (baml.String.replace_all) - 34 return -} - -function google.internal._gm_generation_config(temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null) -> google.internal.GmGenerationConfig | null { - 360 0 load_var 1 (temperature) - 1 load_const 0 (null) - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 jump_if_false +5 (to 8) - 4 pop 1 - - 361 5 load_var 2 (max_output_tokens) - 6 load_const 0 (null) - 7 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 8 jump_if_false +5 (to 13) - 9 pop 1 - - 362 10 load_var 3 (top_p) - 11 load_const 0 (null) - 12 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 13 jump_if_false +5 (to 18) - 14 pop 1 - - 363 15 load_var 4 (top_k) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 18 jump_if_false +5 (to 23) - 19 pop 1 - - 364 20 load_var 5 (stop_sequences) - 21 load_const 0 (null) - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 23 jump_if_false +5 (to 28) - 24 pop 1 - - 365 25 load_var 6 (response_modalities) - 26 load_const 0 (null) - 27 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 359 28 pop_jump_if_false +2 (to 30) - 29 jump +6 (to 35) - - 369 30 load_var2 1 2 - 31 load_var2 3 4 - 32 load_var2 5 6 - 33 init_instance 0 (google.internal.GmGenerationConfig .temperature, .maxOutputTokens, .topP, .topK, .stopSequences, .responseModalities) - - 359 34 jump +2 (to 36) - - 367 35 load_const 0 (null) - 36 return -} - -function google.internal._gm_is_blocked(finish: string) -> bool { - 801 0 load_var 1 (finish) - 1 load_const 0 ("SAFETY") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 802 6 load_var 1 (finish) - 7 load_const 1 ("RECITATION") - 8 cmp_op == - - 801 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 803 12 load_var 1 (finish) - 13 load_const 2 ("PROHIBITED_CONTENT") - 14 cmp_op == - - 801 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 804 18 load_var 1 (finish) - 19 load_const 3 ("BLOCKLIST") - 20 cmp_op == - - 801 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 805 24 load_var 1 (finish) - 25 load_const 4 ("SPII") - 26 cmp_op == - - 801 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 806 30 load_var 1 (finish) - 31 load_const 5 ("IMAGE_SAFETY") - 32 cmp_op == - 33 return -} - -function google.internal._gm_is_opaque_key(key: string) -> bool { - 263 0 load_var 1 (key) - 1 load_const 0 ("args") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("response") - 8 cmp_op == - 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - 12 load_var 1 (key) - 13 load_const 2 ("parametersJsonSchema") - 14 cmp_op == - 15 return -} - -function google.internal._gm_is_provider_uri(url: string) -> bool { - 399 0 load_var 1 (url) - 1 load_const 0 ("gs://") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 400 6 load_var 1 (url) - 7 load_const 1 ("://generativelanguage.googleapis.com/v1beta/files/") - 8 call 147 ntypeargs=0 (baml.String.includes) - - 399 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 401 12 load_var 1 (url) - 13 load_const 2 ("://www.youtube.com/") - 14 call 147 ntypeargs=0 (baml.String.includes) - - 399 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 402 18 load_var 1 (url) - 19 load_const 3 ("://youtube.com/") - 20 call 147 ntypeargs=0 (baml.String.includes) - - 399 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 403 24 load_var 1 (url) - 25 load_const 4 ("://m.youtube.com/") - 26 call 147 ntypeargs=0 (baml.String.includes) - - 399 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 404 30 load_var 1 (url) - 31 load_const 5 ("://youtu.be/") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 return -} - -function google.internal._gm_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> google.internal.GmPart { - 431 0 load_var 1 (media) - 1 call 1224 ntypeargs=0 (google.internal._gm_media_url) - - 432 2 store_var 4 (_5) - 3 load_var 4 (_5) - 4 narrow_bind 0 4 - 5 pop_jump_if_false +2 (to 7) - 6 jump +4 (to 10) - - 435 7 load_const 1 (false) - 8 store_var 3 (passthrough) - - 432 9 jump +4 (to 13) - 10 load_var 4 (_5) - - 433 11 call 1225 ntypeargs=0 (google.internal._gm_is_provider_uri) - 12 store_var 3 (passthrough) - - 437 13 load_var 2 (fetch_url) - 14 jump_if_false +3 (to 17) - 15 pop 1 - 16 jump +3 (to 19) - 17 store_var 6 (_9) - 18 jump +4 (to 22) - 19 load_var 3 (passthrough) - 20 unary_op ! - 21 store_var 6 (_9) - 22 load_var2 1 6 - 23 call 933 ntypeargs=0 (ai.wire.resolve_media) - 24 store_var 5 (resolved) - - 438 25 load_var 5 (resolved) - 26 load_field 0 (url) - 27 store_var 7 (_12) - 28 load_var 7 (_12) - 29 narrow_bind 0 7 - 30 pop_jump_if_false +2 (to 32) - 31 jump +16 (to 47) - - 444 32 load_var 5 (resolved) - 33 load_field 2 (mime_type) - 34 store_var 9 (_20) - 35 load_var 5 (resolved) - 36 load_field 1 (base64) - 37 store_var_load_var 10 (_22) - 38 load_const 2 (null) - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - 41 load_const 3 ("") - 42 store_var 10 (_22) - 43 load_var2 9 10 - 44 init_instance 0 (google.internal.GmInlineData .mimeType, .data) - - 443 45 call 1214 ntypeargs=0 (google.internal.GmPart.of_inline_data) - 46 jump +9 (to 55) - - 438 47 load_var 7 (_12) - 48 store_var_load_var 8 (url) - - 440 49 load_var 5 (resolved) - 50 load_field 2 (mime_type) - 51 call 1226 ntypeargs=0 (google.internal._gm_mime_for_uri) - 52 load_var 8 (url) - 53 init_instance 1 (google.internal.GmFileData .mimeType, .fileUri) - - 439 54 call 1215 ntypeargs=0 (google.internal.GmPart.of_file_data) - 55 return -} - -function google.internal._gm_media_url(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> string | null { - 385 0 load_var 1 (media) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +22 (to 27) - 6 load_var 1 (media) - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 narrow_bind 1 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +13 (to 24) - 12 load_var 1 (media) - 13 store_var 4 (_6) - 14 load_var 4 (_6) - 15 narrow_bind 2 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +4 (to 21) - - 389 18 load_var 1 (media) - 19 call 322 ntypeargs=0 (baml.media.Pdf.url) - 20 jump +9 (to 29) - - 385 21 load_var 4 (_6) - - 388 22 call 336 ntypeargs=0 (baml.media.Video.url) - 23 jump +6 (to 29) - - 385 24 load_var 3 (_4) - - 387 25 call 329 ntypeargs=0 (baml.media.Audio.url) - 26 jump +3 (to 29) - - 385 27 load_var 2 (_2) - - 386 28 call 343 ntypeargs=0 (baml.media.Image.url) - 29 return -} - -function google.internal._gm_mime_for_uri(url: string, mime: string) -> string | null { - 411 0 load_var 1 (url) - 1 load_const 0 ("gs://") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +10 (to 14) - - 413 5 load_var 1 (url) - 6 load_const 1 ("youtu") - 7 call 147 ntypeargs=0 (baml.String.includes) - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 416 10 load_var 2 (mime) - - 413 11 jump +4 (to 15) - - 414 12 load_const 2 (null) - - 413 13 jump +2 (to 15) - - 412 14 load_var 2 (mime) - 15 return -} - -function google.internal._gm_open_sse(req: baml.http.Request, provider: string) -> baml.http.SseStream { - 952 0 load_var 1 (req) - 1 sys_op 252 (baml.http.fetch_sse) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 953 5 load_var2 2 3 - 6 call 1241 ntypeargs=0 (google.internal._gm_sse_failure) - 7 throw - 8 return -} - -function google.internal._gm_output_media(mime: string, data: string) -> ai.content.Media { - 785 0 load_var 1 (mime) - 1 load_const 0 ("audio/") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +20 (to 24) - - 787 5 load_var 1 (mime) - 6 load_const 1 ("video/") - 7 call 148 ntypeargs=0 (baml.String.starts_with) - 8 pop_jump_if_false +2 (to 10) - 9 jump +12 (to 21) - - 789 10 load_var 1 (mime) - 11 load_const 2 ("application/pdf") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +4 (to 18) - - 792 15 load_var2 2 1 - 16 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 17 jump +9 (to 26) - - 790 18 load_var2 2 1 - 19 call 328 ntypeargs=0 (baml.media.Pdf.from_base64) - 20 jump +6 (to 26) - - 788 21 load_var2 2 1 - 22 call 342 ntypeargs=0 (baml.media.Video.from_base64) - 23 jump +3 (to 26) - - 786 24 load_var2 2 1 - 25 call 335 ntypeargs=0 (baml.media.Audio.from_base64) - - 794 26 load_const 3 () - 27 load_const 3 () - 28 call 904 ntypeargs=0 (ai.content.Media.new) - 29 return -} - -function google.internal._gm_prompt_parts(message: ai.PromptMessage, fetch_url: bool) -> google.internal.GmPart[] { - 450 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (parts) - - 451 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +67 (to 84) - 18 load_var 5 (_6) - 19 store_var 6 (part) - - 452 20 load_var 6 (part) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +51 (to 76) - 26 load_var 6 (part) - 27 store_var 9 (_16) - 28 load_var 9 (_16) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +37 (to 68) - 32 load_var 6 (part) - 33 store_var 11 (_22) - 34 load_var 11 (_22) - 35 narrow_bind 8 11 - 36 pop_jump_if_false +2 (to 38) - 37 jump +23 (to 60) - 38 load_var 6 (part) - 39 store_var 13 (_28) - 40 load_var 13 (_28) - 41 narrow_bind 9 13 - 42 pop_jump_if_false +2 (to 44) - 43 jump +9 (to 52) - 44 load_var2 6 2 - - 470 45 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 46 store_var 15 (_36) - 47 load_type 0 - 48 load_var2 3 15 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -42 (to 9) - - 452 52 load_var2 13 2 - - 466 53 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 54 store_var 14 (_31) - 55 load_type 0 - 56 load_var2 3 14 - 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - 59 jump -50 (to 9) - - 452 60 load_var2 11 2 - - 462 61 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 62 store_var 12 (_25) - 63 load_type 0 - 64 load_var2 3 12 - 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -58 (to 9) - - 452 68 load_var2 9 2 - - 458 69 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 70 store_var 10 (_19) - 71 load_type 0 - 72 load_var2 3 10 - 73 call 4 ntypeargs=1 (baml.Array.push) - 74 pop 1 - 75 jump -66 (to 9) - - 452 76 load_var 7 (_10) - - 454 77 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 78 store_var 8 (_13) - 79 load_type 0 - 80 load_var2 3 8 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -74 (to 9) - - 475 84 load_var 3 (parts) - 85 return -} - -function google.internal._gm_sig_marker() -> string { - 536 0 load_const 0 ("~gts~") - 1 return -} - -function google.internal._gm_sse_failure(provider: string, error: unknown) -> ai.errors.Failure { - 923 0 load_var 2 (error) - 1 store_var 5 (_5) - 2 load_var 5 (_5) - 3 narrow_bind 0 5 - 4 pop_jump_if_false +2 (to 6) - 5 jump +6 (to 11) - - 925 6 load_type 1 - 7 load_var 2 (error) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 4 (_4) - 10 jump +4 (to 14) - - 923 11 load_var 5 (_5) - 12 load_field 0 (message) - 13 store_var 4 (_4) - 14 load_var 4 (_4) - 15 call 929 ntypeargs=0 (ai.wire.redact_url_secrets) - 16 store_var 3 (text) - - 928 17 load_var 3 (text) - - 927 18 load_const 2 ("failed with status ") - - 928 19 call 155 ntypeargs=0 (baml.String.index_of) - 20 store_var 6 (_11) - 21 load_var 6 (_11) - 22 narrow_bind 3 6 - 23 pop_jump_if_false +43 (to 66) - 24 load_var 6 (_11) - 25 store_var 9 (_15) - - 927 26 load_const 4 ("failed with status ") - - 929 27 call 139 ntypeargs=0 (baml.String.length) - 28 load_var 9 (_15) - 29 add_int - 30 store_var 8 (_14) - 31 load_var 3 (text) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 store_var 10 (_17) - 34 load_var2 3 8 - 35 load_var 10 (_17) - 36 call 153 ntypeargs=0 (baml.String.slice) - 37 store_var 7 (rest) - - 930 38 load_var 7 (rest) - 39 load_const 5 (":") - 40 call 150 ntypeargs=0 (baml.String.split) - 41 store_var 12 (_21) - 42 load_type 6 - 43 load_var 12 (_21) - 44 load_const 3 (0) - 45 call 3 ntypeargs=1 (baml.Array.at) - 46 store_var_load_var 11 (_19) - 47 load_const 7 (null) - 48 cmp_op == - 49 pop_jump_if_false +3 (to 52) - 50 load_const 8 ("") - 51 store_var 11 (_19) - 52 load_var 11 (_19) - - 931 53 call 144 ntypeargs=0 (baml.String.trim) - 54 call 81 ntypeargs=0 (baml.Int.parse) - 55 store_var 13 (status) - 56 jump +5 (to 61) - 57 load_var 14 (e) - 58 throw_if_panic - - 932 59 load_const 3 (0) - 60 store_var 13 (status) - - 934 61 load_var 13 (status) - 62 load_const 3 (0) - 63 cmp_int_op > - 64 pop_jump_if_false +2 (to 66) - 65 jump +12 (to 77) - - 945 66 load_type 6 - 67 load_var 3 (text) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 19 (_40) - - 943 70 load_var 1 (provider) - - 945 71 load_const 9 ("transport failed before a response arrived: ") - 72 load_var 19 (_40) - 73 bin_op + - 74 load_const 7 (null) - 75 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 76 jump +28 (to 104) - - 935 77 load_var 7 (rest) - 78 load_const 10 (":") - 79 call 155 ntypeargs=0 (baml.String.index_of) - 80 store_var 16 (_31) - 81 load_var 16 (_31) - 82 narrow_bind 3 16 - 83 pop_jump_if_false +2 (to 85) - 84 jump +4 (to 88) - - 938 85 load_const 11 ("") - 86 store_var 15 (body) - - 935 87 jump +13 (to 100) - 88 load_var 16 (_31) - 89 load_const 12 (1) - 90 add_int - 91 store_var 17 (_34) - - 936 92 load_var 7 (rest) - 93 call 139 ntypeargs=0 (baml.String.length) - 94 store_var 18 (_36) - 95 load_var2 7 17 - 96 load_var 18 (_36) - 97 call 153 ntypeargs=0 (baml.String.slice) - 98 call 144 ntypeargs=0 (baml.String.trim) - 99 store_var 15 (body) - - 940 100 load_var2 1 13 - 101 load_var 15 (body) - 102 load_const 13 () - 103 call 977 ntypeargs=0 (ai.errors.classify_http) - 104 return -} - -function google.internal._gm_strip_nulls(value: baml.json.json, opaque: bool) -> baml.json.json { - 271 0 load_var 2 (opaque) - 1 pop_jump_if_false +2 (to 3) - 2 jump +72 (to 74) - - 274 3 load_var 1 (value) - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +16 (to 24) - 9 load_var 1 (value) - 10 store_var 12 (_27) - 11 load_var 12 (_27) - 12 narrow_bind 1 12 - 13 pop_jump_if_false +2 (to 15) - 14 jump +3 (to 17) - - 290 15 load_var 1 (value) - - 274 16 jump +59 (to 75) - - 289 17 load_type 2 - 18 load_type 2 - 19 load_type 3 - - 274 20 load_var 12 (_27) - - 289 21 make_closure 3397 0 - 22 call 16 ntypeargs=3 (baml.Array.map) - 23 jump +52 (to 75) - - 274 24 load_var 3 (_3) - 25 store_var 4 (object) - - 276 26 load_type 4 - 27 load_type 2 - 28 alloc_map 0 - 29 store_var 5 (out) - - 277 30 load_type 4 - 31 load_type 2 - 32 load_var 4 (object) - 33 call 35 ntypeargs=2 (baml.Map.keys) - 34 load_type 5 - 35 load_const 6 ("iter") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 6 (_9) - 38 load_var 6 (_9) - 39 load_type 7 - 40 load_const 8 ("next") - 41 virtual_call nargs=1 ntypeargs=0 - 42 store_var 7 (_10) - 43 load_var 7 (_10) - 44 is_type 9 - 45 pop_jump_if_false +2 (to 47) - 46 jump +26 (to 72) - 47 load_var 7 (_10) - 48 store_var 8 (key) - - 278 49 load_type 4 - 50 load_type 2 - 51 load_var2 4 8 - 52 call 38 ntypeargs=2 (baml.Map.get) - 53 store_var 9 (entry) - - 279 54 load_var 9 (entry) - 55 load_const 10 (null) - 56 cmp_op == - 57 pop_jump_if_false +2 (to 59) - 58 jump -20 (to 38) - - 282 59 load_var 8 (key) - 60 call 1218 ntypeargs=0 (google.internal._gm_is_opaque_key) - 61 store_var 11 (_23) - 62 load_var2 9 11 - 63 call 1219 ntypeargs=0 (google.internal._gm_strip_nulls) - 64 store_var 10 (_21) - 65 load_type 4 - 66 load_type 2 - 67 load_var2 5 8 - 68 load_var 10 (_21) - 69 call 37 ntypeargs=2 (baml.Map.set) - 70 pop 1 - 71 jump -33 (to 38) - - 287 72 load_var 5 (out) - - 274 73 jump +2 (to 75) - - 272 74 load_var 1 (value) - 75 return -} - -function google.internal._gm_tool_name_for(j: ai.Journal, id: string) -> string { - 560 0 load_const 0 ("") - 1 store_var 3 (name) - - 561 2 load_var 1 (j) - 3 call 905 ntypeargs=0 (ai.Journal.entries) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_5) - 8 load_var 4 (_5) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_6) - 13 load_var 5 (_6) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +36 (to 52) - 17 load_var 5 (_6) - 18 store_var 6 (_10) - - 562 19 load_var 6 (_10) - 20 narrow_bind 6 6 - 21 pop_jump_if_false -13 (to 8) - 22 load_var 6 (_10) - 23 load_field 0 (content) - 24 load_type 7 - 25 load_const 8 ("iter") - 26 virtual_call nargs=1 ntypeargs=0 - 27 store_var 7 (_13) - - 564 28 load_var 7 (_13) - 29 load_type 9 - 30 load_const 10 ("next") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 8 (_14) - 33 load_var 8 (_14) - 34 is_type 5 - 35 pop_jump_if_false +2 (to 37) - 36 jump -28 (to 8) - 37 load_var 8 (_14) - 38 store_var 9 (_18) - - 565 39 load_var 9 (_18) - 40 narrow_bind 11 9 - 41 pop_jump_if_false -13 (to 28) - 42 load_var 9 (_18) - 43 store_var_load_var 10 (u) - - 567 44 load_field 0 (id) - 45 load_var 2 (id) - 46 cmp_op == - 47 pop_jump_if_false -19 (to 28) - - 568 48 load_var 10 (u) - 49 load_field 1 (name) - 50 store_var 3 (name) - - 567 51 jump -23 (to 28) - - 582 52 load_var 3 (name) - 53 return -} - -function google.internal._gm_usage(usage: google.internal.GmUsageMetadata | null) -> ai.events.Usage | null { - 810 0 load_var 1 (usage) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 821 6 load_const 1 (null) - - 810 7 jump +26 (to 33) - 8 load_var 2 (_2) - 9 store_var_load_var 3 (um) - - 812 10 load_field 0 (promptTokenCount) - 11 store_var_load_var 5 (_5) - 12 load_const 1 (null) - 13 cmp_op == - 14 pop_jump_if_false +3 (to 17) - 15 load_const 2 (0) - 16 store_var 5 (_5) - 17 load_var 5 (_5) - 18 store_var 4 (_4) - - 816 19 load_var 3 (um) - 20 load_field 1 (candidatesTokenCount) - 21 store_var_load_var 6 (_9) - 22 load_const 1 (null) - 23 cmp_op == - 24 pop_jump_if_false +3 (to 27) - 25 load_const 2 (0) - 26 store_var 6 (_9) - - 811 27 load_var2 4 6 - - 817 28 load_var 3 (um) - 29 load_field 2 (cachedContentTokenCount) - - 818 30 load_var 3 (um) - 31 load_field 3 (thoughtsTokenCount) - 32 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 33 return -} - -function google.internal._google_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1097 0 load_var 1 (batch) - 1 load_const 0 ("google") - 2 call 1243 ntypeargs=0 (google.internal._gm_decode_batch) - 3 return -} - -function google.internal._google_request(c: google.GoogleClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 1062 0 load_var 1 (c) - 1 load_type 0 - 2 load_const 1 ("id") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 5 (_5) - - 1064 5 load_var 1 (c) - 6 load_field 6 (temperature) - - 1065 7 load_var 1 (c) - 8 load_field 7 (max_output_tokens) - - 1066 9 load_var 1 (c) - 10 load_field 8 (top_p) - - 1067 11 load_var 1 (c) - 12 load_field 9 (top_k) - - 1068 13 load_var 1 (c) - 14 load_field 10 (stop_sequences) - - 1069 15 load_var 1 (c) - 16 load_field 11 (response_modalities) - - 1063 17 call 1223 ntypeargs=0 (google.internal._gm_generation_config) - 18 store_var 6 (_6) - - 1060 19 load_var2 2 5 - 20 load_var2 6 1 - - 1071 21 load_field 12 (safety_settings) - - 1072 22 load_var 1 (c) - 23 load_field 3 (request_body) - 24 load_const 2 () - - 1060 25 call 1235 ntypeargs=0 (google.internal.gemini_build_body) - 26 store_var 4 (body) - - 1074 27 load_var 1 (c) - 28 call 1203 ntypeargs=0 (google.GoogleClient.resolved_base_url) - 29 store_var_load_var 7 (_16) - 30 load_const 3 (null) - 31 cmp_op == - 32 pop_jump_if_false +3 (to 35) - 33 load_const 4 ("https://generativelanguage.googleapis.com/v1beta") - 34 store_var 7 (_16) - - 1076 35 load_type 5 - - 1074 36 load_var 7 (_16) - - 1076 37 call 138 ntypeargs=1 (baml.String.from) - 38 store_var 9 (_23) - 39 load_type 5 - 40 load_var 1 (c) - 41 load_field 0 (model) - 42 call 138 ntypeargs=1 (baml.String.from) - 43 store_var 10 (_26) - 44 load_var 3 (stream) - 45 call 1236 ntypeargs=0 (google.internal.gemini_method) - 46 store_var 12 (_30) - 47 load_type 5 - 48 load_var 12 (_30) - 49 call 138 ntypeargs=1 (baml.String.from) - 50 store_var 11 (_29) - 51 load_var 9 (_23) - 52 load_const 6 ("/models/") - 53 bin_op + - 54 load_var 10 (_26) - 55 bin_op + - 56 load_var 11 (_29) - 57 bin_op + - - 1077 58 load_var 1 (c) - 59 load_field 5 (query_params) - - 1075 60 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 61 store_var 8 (url) - - 1079 62 load_const 7 ("application/json") - 63 load_const 8 ("content-type") - 64 load_type 5 - 65 load_type 5 - 66 alloc_map 1 - - 1080 67 load_var 1 (c) - 68 load_field 4 (headers) - 69 call 1222 ntypeargs=0 (google.internal._gm_apply_headers) - 70 store_var 13 (with_user) - - 1081 71 load_var 1 (c) - 72 call 1202 ntypeargs=0 (google.GoogleClient.resolved_api_key) - 73 store_var 14 (_38) - 74 load_type 5 - 75 load_type 5 - 76 load_var 13 (with_user) - 77 load_const 9 ("x-goog-api-key") - 78 load_var 14 (_38) - 79 call 37 ntypeargs=2 (baml.Map.set) - 80 pop 1 - - 1082 81 load_const 10 ("POST") - 82 load_var2 8 13 - 83 load_var 4 (body) - 84 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 85 return -} - -function google.internal._vertex_anthropic_body(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> string { - 246 0 load_var 1 (c) - 1 load_field 0 (model) - 2 store_var 4 (_6) - - 247 3 load_var 1 (c) - 4 load_field 11 (max_output_tokens) - 5 store_var_load_var 6 (_8) - 6 load_const 0 (null) - 7 cmp_op == - 8 pop_jump_if_false +3 (to 11) - 9 load_const 1 (8192) - 10 store_var 6 (_8) - 11 load_var 6 (_8) - 12 store_var 5 (_7) - - 248 13 load_var 1 (c) - 14 load_field 10 (temperature) - 15 store_var 7 (_11) - - 249 16 load_var 1 (c) - 17 load_field 12 (top_p) - 18 store_var 8 (_12) - - 250 19 load_var 1 (c) - 20 load_field 13 (top_k) - 21 store_var 9 (_13) - - 251 22 load_var 1 (c) - 23 load_field 14 (stop_sequences) - 24 store_var 10 (_14) - - 241 25 load_const 2 ("vertex-2023-10-16") - 26 load_const 0 (null) - 27 load_const 3 ("anthropic_version") - 28 load_const 4 ("model") - 29 load_type 5 - 30 load_type 6 - 31 alloc_map 2 - - 256 32 load_var 1 (c) - 33 load_field 7 (request_body) - 34 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 35 store_var 11 (_15) - - 257 36 load_var 1 (c) - 37 load_type 7 - 38 load_const 8 ("id") - 39 virtual_call nargs=1 ntypeargs=0 - 40 store_var 12 (_18) - - 245 41 load_var2 4 5 - 42 load_var2 7 8 - 43 load_var2 9 10 - 44 load_const 0 (null) - 45 load_const 0 (null) - 46 load_var2 11 12 - 47 init_instance 0 (anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id) - 48 load_var2 2 3 - - 259 49 call 1185 ntypeargs=0 (anthropic.internal.anthropic_messages_body) - 50 return -} - -function google.internal._vertex_credentials(c: google.VertexClient) -> string | null { - 49 0 load_var 1 (c) - 1 load_field 3 (credentials_json) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +59 (to 65) - - 52 7 load_var 1 (c) - 8 load_field 4 (credentials_file) - 9 store_var 3 (_7) - 10 load_var 3 (_7) - 11 narrow_bind 0 3 - 12 pop_jump_if_false +2 (to 14) - 13 jump +20 (to 33) - - 65 14 load_const 1 ("GOOGLE_APPLICATION_CREDENTIALS_CONTENT") - 15 sys_op 226 (baml.env.get) - 16 store_var 9 (_25) - 17 load_var 9 (_25) - 18 narrow_bind 0 9 - 19 pop_jump_if_false +9 (to 28) - 20 load_var 9 (_25) - 21 store_var 10 (from_env) - - 66 22 load_var 10 (from_env) - 23 call 144 ntypeargs=0 (baml.String.trim) - 24 load_const 2 ("") - 25 cmp_op != - 26 pop_jump_if_false +2 (to 28) - 27 jump +3 (to 30) - - 70 28 load_const 3 (null) - 29 jump +38 (to 67) - - 67 30 load_var 10 (from_env) - 31 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 32 jump +35 (to 67) - - 52 33 load_var 3 (_7) - 34 store_var_load_var 4 (path) - - 53 35 sys_op 293 (baml.fs.read) - 36 jump +27 (to 63) - 37 load_var 5 (e) - 38 throw_if_panic - - 58 39 load_type 4 - 40 load_var 4 (path) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 6 (_16) - 43 load_type 5 - 44 load_var 5 (e) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 8 (_20) - 47 load_type 4 - 48 load_var 8 (_20) - 49 call 138 ntypeargs=1 (baml.String.from) - 50 store_var 7 (_19) - - 55 51 load_const 6 ("vertex") - 52 load_const 3 (null) - - 58 53 load_const 7 ("Vertex AI credentials file ") - 54 load_var 6 (_16) - 55 bin_op + - 56 load_const 8 (" could not be read: ") - 57 bin_op + - 58 load_var 7 (_19) - 59 bin_op + - 60 load_const 3 (null) - 61 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 62 throw - - 63 63 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 64 jump +3 (to 67) - - 49 65 load_var 2 (_3) - - 50 66 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 67 return -} - -function google.internal._vertex_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 342 0 load_var 1 (batch) - 1 load_const 0 ("vertex") - 2 call 1243 ntypeargs=0 (google.internal._gm_decode_batch) - 3 return -} - -function google.internal._vertex_express_key(c: google.VertexClient) -> string | null { - 77 0 load_var 1 (c) - 1 call 1208 ntypeargs=0 (google.VertexClient.resolved_api_key) - 2 return -} - -function google.internal._vertex_is_express(c: google.VertexClient) -> bool { - 87 0 load_var 1 (c) - 1 call 1252 ntypeargs=0 (google.internal._vertex_express_key) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 unary_op ! - 5 jump_if_false +2 (to 7) - 6 jump +4 (to 10) - 7 pop 1 - 8 load_var 1 (c) - 9 call 1253 ntypeargs=0 (google.internal._vertex_key_in_query) - 10 return -} - -function google.internal._vertex_is_multi_region(location: string) -> bool { - 160 0 load_var 1 (location) - 1 load_const 0 ("us") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (location) - 7 load_const 1 ("eu") - 8 cmp_op == - 9 return -} - -function google.internal._vertex_key_in_query(c: google.VertexClient) -> bool { - 83 0 load_var 1 (c) - 1 load_field 9 (query_params) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +8 (to 13) - 6 load_const 1 ("key") - 7 load_var 1 (c) - 8 load_field 9 (query_params) - 9 make_bound_method 38 - 10 call_indirect - 11 store_var 2 (_2) - 12 jump +3 (to 15) - 13 load_const 0 (null) - 14 store_var 2 (_2) - 15 load_var 2 (_2) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 unary_op ! - 19 return -} - -function google.internal._vertex_method(c: google.VertexClient, stream: bool) -> string { - 202 0 load_var 1 (c) - 1 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 2 load_const 0 ("anthropic") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +4 (to 9) - - 209 6 load_var 2 (stream) - 7 call 1236 ntypeargs=0 (google.internal.gemini_method) - 8 jump +7 (to 15) - - 203 9 load_var 2 (stream) - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 206 12 load_const 1 (":rawPredict") - - 203 13 jump +2 (to 15) - - 204 14 load_const 2 (":streamRawPredict") - 15 return -} - -function google.internal._vertex_models_base(c: google.VertexClient) -> string { - 168 0 load_var 1 (c) - 1 call 1209 ntypeargs=0 (google.VertexClient.resolved_base_url) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +99 (to 105) - - 171 7 load_var 1 (c) - 8 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 9 store_var 3 (publisher) - - 172 10 load_var 1 (c) - 11 call 1255 ntypeargs=0 (google.internal.vertex_location) - 12 store_var 4 (location) - - 173 13 load_var 4 (location) - 14 load_const 1 ("global") - 15 cmp_op == - 16 pop_jump_if_false +2 (to 18) - 17 jump +23 (to 40) - - 175 18 load_var 4 (location) - 19 call 1258 ntypeargs=0 (google.internal._vertex_is_multi_region) - 20 pop_jump_if_false +2 (to 22) - 21 jump +8 (to 29) - - 180 22 load_type 2 - 23 load_var 4 (location) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 load_const 3 ("-aiplatform.googleapis.com") - 26 bin_op + - 27 store_var 5 (host) - - 175 28 jump +14 (to 42) - - 178 29 load_type 2 - 30 load_var 4 (location) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 6 (_13) - 33 load_const 4 ("aiplatform.") - 34 load_var 6 (_13) - 35 bin_op + - 36 load_const 5 (".rep.googleapis.com") - 37 bin_op + - 38 store_var 5 (host) - - 175 39 jump +3 (to 42) - - 174 40 load_const 6 ("aiplatform.googleapis.com") - 41 store_var 5 (host) - - 182 42 load_var 1 (c) - 43 call 1256 ntypeargs=0 (google.internal.vertex_project_id) - - 183 44 store_var 7 (_20) - 45 load_var 7 (_20) - 46 narrow_bind 0 7 - 47 pop_jump_if_false +2 (to 49) - 48 jump +21 (to 69) - - 185 49 load_var 1 (c) - 50 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 51 pop_jump_if_false +2 (to 53) - 52 jump +7 (to 59) - - 190 53 load_const 7 ("vertex") - 54 load_const 8 (null) - 55 load_const 9 ("Could not resolve project_id for Vertex AI. Set the client's project_id option, the GOOGLE_CLOUD_PROJECT env var, or supply credentials that carry a project_id.") - 56 load_const 8 (null) - 57 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 58 throw - - 188 59 load_type 2 - 60 load_var 3 (publisher) - 61 call 138 ntypeargs=1 (baml.String.from) - 62 store_var 13 (_43) - 63 load_const 10 ("https://aiplatform.googleapis.com/v1/publishers/") - 64 load_var 13 (_43) - 65 bin_op + - 66 load_const 11 ("/models") - 67 bin_op + - - 185 68 jump +38 (to 106) - - 183 69 load_var 7 (_20) - 70 store_var 8 (resolved) - - 184 71 load_type 2 - 72 load_var 5 (host) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 9 (_29) - 75 load_type 2 - 76 load_var 8 (resolved) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 10 (_32) - 79 load_type 2 - 80 load_var 4 (location) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 11 (_35) - 83 load_type 2 - 84 load_var 3 (publisher) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 12 (_38) - 87 load_const 12 ("https://") - 88 load_var 9 (_29) - 89 bin_op + - 90 load_const 13 ("/v1/projects/") - 91 bin_op + - 92 load_var 10 (_32) - 93 bin_op + - 94 load_const 14 ("/locations/") - 95 bin_op + - 96 load_var 11 (_35) - 97 bin_op + - 98 load_const 15 ("/publishers/") - 99 bin_op + - 100 load_var 12 (_38) - 101 bin_op + - 102 load_const 16 ("/models") - 103 bin_op + - - 183 104 jump +2 (to 106) - - 168 105 load_var 2 (_3) - 106 return -} - -function google.internal._vertex_publisher(c: google.VertexClient) -> string { - 149 0 load_var 1 (c) - 1 load_field 0 (model) - 2 load_const 0 ("claude") - 3 call 148 ntypeargs=0 (baml.String.starts_with) - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 152 6 load_const 1 ("google") - - 149 7 jump +2 (to 9) - - 150 8 load_const 2 ("anthropic") - 9 return -} - -function google.internal._vertex_request(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 274 0 load_var 1 (c) - 1 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 2 load_const 0 ("anthropic") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +29 (to 34) - - 279 6 load_var 1 (c) - 7 load_type 1 - 8 load_const 2 ("id") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 5 (_7) - - 281 11 load_var 1 (c) - 12 load_field 10 (temperature) - - 282 13 load_var 1 (c) - 14 load_field 11 (max_output_tokens) - - 283 15 load_var 1 (c) - 16 load_field 12 (top_p) - - 284 17 load_var 1 (c) - 18 load_field 13 (top_k) - - 285 19 load_var 1 (c) - 20 load_field 14 (stop_sequences) - - 286 21 load_var 1 (c) - 22 load_field 15 (response_modalities) - - 280 23 call 1223 ntypeargs=0 (google.internal._gm_generation_config) - 24 store_var 6 (_8) - - 277 25 load_var2 2 5 - 26 load_var2 6 1 - - 288 27 load_field 16 (safety_settings) - - 289 28 load_var 1 (c) - 29 load_field 7 (request_body) - 30 load_const 3 (false) - - 277 31 call 1235 ntypeargs=0 (google.internal.gemini_build_body) - 32 store_var 4 (body) - 33 jump +5 (to 38) - - 275 34 load_var2 1 2 - 35 load_var 3 (stream) - 36 call 1262 ntypeargs=0 (google.internal._vertex_anthropic_body) - 37 store_var 4 (body) - - 297 38 load_var2 1 3 - 39 call 1261 ntypeargs=0 (google.internal.vertex_url) - 40 store_var 7 (url) - - 298 41 load_const 4 ("application/json") - 42 load_const 5 ("content-type") - 43 load_type 6 - 44 load_type 6 - 45 alloc_map 1 - - 299 46 load_var 1 (c) - 47 load_field 8 (headers) - 48 call 1222 ntypeargs=0 (google.internal._gm_apply_headers) - 49 store_var 8 (with_user) - - 300 50 load_var 1 (c) - 51 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 52 pop_jump_if_false +2 (to 54) - 53 jump +62 (to 115) - - 304 54 load_var 1 (c) - 55 call 1251 ntypeargs=0 (google.internal._vertex_credentials) - 56 store_var 9 (credentials) - - 305 57 call 1249 ntypeargs=0 (google.internal._vertex_scope) - 58 store_var 12 (_27) - 59 load_var2 9 12 - 60 call 1268 ntypeargs=0 (google.internal.gcp_access_token) - 61 store_var 10 (token) - 62 jump +19 (to 81) - 63 load_var 11 (e) - 64 throw_if_panic - - 310 65 load_type 7 - 66 load_var 11 (e) - 67 call 138 ntypeargs=1 (baml.String.from) - 68 store_var 14 (_31) - 69 load_type 6 - 70 load_var 14 (_31) - 71 call 138 ntypeargs=1 (baml.String.from) - 72 store_var 13 (_30) - - 307 73 load_const 8 ("vertex") - 74 load_const 9 (null) - - 310 75 load_const 10 ("Vertex AI authentication failed: ") - 76 load_var 13 (_30) - 77 bin_op + - 78 load_const 9 (null) - 79 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 80 throw - - 315 81 load_type 6 - 82 load_var 10 (token) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 15 (_36) - 85 load_type 6 - 86 load_type 6 - 87 load_var 8 (with_user) - 88 load_const 11 ("authorization") - 89 load_const 12 ("Bearer ") - 90 load_var 15 (_36) - 91 bin_op + - 92 call 37 ntypeargs=2 (baml.Map.set) - 93 pop 1 - - 318 94 load_type 6 - 95 load_type 6 - 96 load_var 8 (with_user) - 97 load_const 13 ("x-goog-user-project") - 98 call 38 ntypeargs=2 (baml.Map.get) - 99 load_const 9 (null) - 100 call 672 ntypeargs=0 (baml.ops.equals_equals) - 101 pop_jump_if_false +14 (to 115) - - 319 102 load_var 9 (credentials) - 103 call 1270 ntypeargs=0 (google.internal.gcp_quota_project_id) - 104 store_var 16 (_47) - 105 load_var 16 (_47) - 106 narrow_bind 14 16 - 107 pop_jump_if_false +8 (to 115) - - 320 108 load_type 6 - 109 load_type 6 - 110 load_var 8 (with_user) - 111 load_const 15 ("x-goog-user-project") - - 319 112 load_var 16 (_47) - - 320 113 call 37 ntypeargs=2 (baml.Map.set) - 114 pop 1 - - 325 115 load_const 16 ("POST") - 116 load_var2 7 8 - 117 load_var 4 (body) - 118 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 119 return -} - -function google.internal._vertex_scope() -> string { - 25 0 load_const 0 ("https://www.googleapis.com/auth/cloud-platform") - 1 return -} - -function google.internal._vertex_unwrap_json(document: string) -> string { - 32 0 load_var 1 (document) - 1 call 144 ntypeargs=0 (baml.String.trim) - 2 store_var 2 (trimmed) - - 33 3 load_var 2 (trimmed) - 4 load_const 0 ("\"") - 5 call 148 ntypeargs=0 (baml.String.starts_with) - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - - 38 8 load_var 1 (document) - - 33 9 jump +8 (to 17) - - 34 10 load_type 1 - 11 load_var 2 (trimmed) - 12 call 357 ntypeargs=1 (baml.json.from_string) - 13 jump +4 (to 17) - 14 load_var 3 (e) - 15 throw_if_panic - - 35 16 load_var 1 (document) - 17 return -} - -function google.internal.gcp_access_token(credentials_json: string | null, scope: string) -> string { - 25 0 load_var2 1 2 - 1 sys_op 980 (ai.internal._gcp_access_token) - 2 return -} - -function google.internal.gcp_project_id(credentials_json: string | null) -> string | null { - 33 0 load_var 1 (credentials_json) - 1 sys_op 981 (ai.internal._gcp_project_id) - 2 return -} - -function google.internal.gcp_quota_project_id(credentials_json: string | null) -> string | null { - 40 0 load_var 1 (credentials_json) - 1 sys_op 982 (ai.internal._gcp_quota_project_id) - 2 return -} - -function google.internal.gemini_build_body(input: ai.ModelTurnInput, client_id: string, generation_config: google.internal.GmGenerationConfig | null, safety_settings: google.SafetySetting[] | null, request_body: baml.json.json | null, fetch_url: bool) -> string { - 0 load_var 6 (fetch_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 696 4 load_const 1 (true) - 5 store_var 6 (fetch_url) - - 698 6 load_var 1 (input) - 7 load_field 0 (prompt) - 8 store_var 7 (_9) - 9 load_var 1 (input) - 10 load_field 3 (output_type) - 11 call 932 ntypeargs=0 (ai.wire.render_output_format) - 12 load_var 7 (_9) - 13 call_indirect - - 699 14 load_var 6 (fetch_url) - 15 call 1229 ntypeargs=0 (google.internal.google_lower_prompt) - 16 store_var 8 (lowered) - - 700 17 load_var 8 (lowered) - 18 load_field 1 (contents) - 19 store_var 9 (contents) - - 701 20 load_var 1 (input) - 21 load_field 1 (journal) - 22 load_var 2 (client_id) - 23 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 702 24 call 1234 ntypeargs=0 (google.internal.google_lower_journal) - 25 load_type 2 - 26 load_const 3 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 10 (_19) - 29 load_var 10 (_19) - 30 load_type 4 - 31 load_const 5 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 11 (_20) - 34 load_var 11 (_20) - 35 is_type 6 - 36 pop_jump_if_false +2 (to 38) - 37 jump +6 (to 43) - - 703 38 load_type 7 - 39 load_var2 9 11 - 40 call 4 ntypeargs=1 (baml.Array.push) - 41 pop 1 - 42 jump -13 (to 29) - - 710 43 load_const 8 (null) - 44 store_var 12 (system) - - 711 45 load_type 7 - 46 load_var 9 (contents) - 47 load_const 9 (0) - 48 call 3 ntypeargs=1 (baml.Array.at) - 49 load_const 8 (null) - 50 cmp_op == - 51 pop_jump_if_false +2 (to 53) - 52 jump +7 (to 59) - 53 load_type 7 - 54 load_var 9 (contents) - 55 load_const 9 (0) - 56 call 3 ntypeargs=1 (baml.Array.at) - 57 load_field 0 (0) - 58 jump +2 (to 60) - 59 load_const 8 (null) - 60 store_var_load_var 13 (_29) - 61 load_const 8 (null) - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - 64 load_const 10 ("") - 65 store_var 13 (_29) - 66 load_var 13 (_29) - 67 load_const 11 ("user") - 68 cmp_op != - 69 jump_if_false +9 (to 78) - 70 pop 1 - - 712 71 load_var 8 (lowered) - 72 load_field 0 (system_parts) - 73 container_len - 74 store_var 14 (_40) - 75 load_var 14 (_40) - 76 load_const 9 (0) - 77 cmp_int_op > - 78 pop_jump_if_false +2 (to 80) - 79 jump +15 (to 94) - - 715 80 load_var 8 (lowered) - 81 load_field 0 (system_parts) - 82 container_len - 83 store_var 15 (_48) - 84 load_var 15 (_48) - 85 load_const 9 (0) - 86 cmp_int_op > - 87 pop_jump_if_false +17 (to 104) - - 716 88 load_const 8 (null) - 89 load_var 8 (lowered) - 90 load_field 0 (system_parts) - 91 init_instance 0 (google.internal.GmContent .role, .parts) - 92 store_var 12 (system) - - 715 93 jump +11 (to 104) - - 713 94 load_type 7 - 95 load_const 12 ("user") - 96 load_var 8 (lowered) - 97 load_field 0 (system_parts) - 98 init_instance 1 (google.internal.GmContent .role, .parts) - 99 load_type 7 - 100 alloc_array 1 - 101 load_var 9 (contents) - 102 call 7 ntypeargs=1 (baml.Array.concat) - 103 store_var 9 (contents) - - 725 104 load_var 9 (contents) - 105 container_len - 106 store_var 16 (_52) - 107 load_var 16 (_52) - 108 load_const 9 (0) - 109 cmp_int_op == - 110 pop_jump_if_false +2 (to 112) - 111 jump +63 (to 174) - - 734 112 load_const 8 (null) - 113 store_var 17 (tools) - - 735 114 load_const 8 (null) - 115 store_var 18 (tool_config) - - 736 116 load_var 1 (input) - 117 load_field 2 (toolbox) - 118 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 119 unary_op ! - 120 pop_jump_if_false +42 (to 162) - - 737 121 load_type 13 - 122 alloc_array 0 - 123 store_var 19 (declarations) - - 738 124 load_var 1 (input) - 125 load_field 2 (toolbox) - 126 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 127 load_type 14 - 128 load_const 15 ("iter") - 129 virtual_call nargs=1 ntypeargs=0 - 130 store_var 20 (_62) - 131 load_var 20 (_62) - 132 load_type 16 - 133 load_const 17 ("next") - 134 virtual_call nargs=1 ntypeargs=0 - 135 store_var 21 (_63) - 136 load_var 21 (_63) - 137 is_type 6 - 138 pop_jump_if_false +2 (to 140) - 139 jump +14 (to 153) - 140 load_var 21 (_63) - 141 store_var 22 (t) - - 739 142 load_type 13 - 143 load_var2 19 22 - - 741 144 load_field 0 (name) - - 742 145 load_var 22 (t) - 146 load_field 1 (description) - - 743 147 load_var 22 (t) - 148 load_field 2 (input_schema) - 149 init_instance 2 (google.internal.GmFunctionDeclaration .name, .description, .parametersJsonSchema) - - 739 150 call 4 ntypeargs=1 (baml.Array.push) - 151 pop 1 - 152 jump -21 (to 131) - - 747 153 load_var 19 (declarations) - 154 init_instance 3 (google.internal.GmTool .functionDeclarations) - 155 load_type 18 - 156 alloc_array 1 - 157 store_var 17 (tools) - - 749 158 load_const 19 ("AUTO") - 159 init_instance 4 (google.internal.GmFunctionCallingConfig .mode) - 160 init_instance 5 (google.internal.GmToolConfig .functionCallingConfig) - 161 store_var 18 (tool_config) - - 764 162 load_type 20 - - 757 163 load_var2 9 12 - - 759 164 load_var2 17 18 - - 760 165 load_var2 3 4 - 166 init_instance 6 (google.internal.GmGenerateContentRequest .contents, .systemInstruction, .tools, .toolConfig, .generationConfig, .safetySettings) - - 764 167 call 355 ntypeargs=1 (baml.json.to_json) - 168 load_const 21 (false) - 169 call 1219 ntypeargs=0 (google.internal._gm_strip_nulls) - - 765 170 load_var 5 (request_body) - 171 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 172 call 351 ntypeargs=0 (baml.json.stringify) - 173 return - - 726 174 load_const 22 ("google") - 175 load_const 8 (null) - 176 load_const 23 ("the rendered prompt and journal produced no message content") - 177 load_const 8 (null) - 178 init_instance 7 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 179 throw -} - -function google.internal.gemini_invoke(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1090 0 load_var 2 (input) - 1 load_field 1 (journal) - 2 call 905 ntypeargs=0 (ai.Journal.entries) - 3 container_len - 4 store_var 3 (seq) - - 1091 5 load_var2 1 2 - 6 call 1244 ntypeargs=0 (google.internal.google_render) - 7 store_var 4 (req) - - 1092 8 load_type 0 - 9 load_var 4 (req) - 10 load_const 1 ("google") - 11 call 931 ntypeargs=1 (ai.wire.send_as) - - 1093 12 load_var 3 (seq) - 13 load_const 2 () - 14 call 1240 ntypeargs=0 (google.internal.google_parse) - 15 return -} - -function google.internal.gemini_invoke_stream(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 1106 0 load_var2 1 2 - 1 load_const 0 (true) - 2 call 1245 ntypeargs=0 (google.internal._google_request) - - 1110 3 load_const 1 ("google") - 4 call 1242 ntypeargs=0 (google.internal._gm_open_sse) - - 1109 5 load_const 2 (google.internal._google_decode_batch) - 6 load_const 3 ("google") - 7 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 8 return -} - -function google.internal.gemini_method(stream: bool) -> string { - 770 0 load_var 1 (stream) - 1 pop_jump_if_false +2 (to 3) - 2 jump +3 (to 5) - - 773 3 load_const 0 (":generateContent") - - 770 4 jump +2 (to 6) - - 771 5 load_const 1 (":streamGenerateContent?alt=sse") - 6 return -} - -function google.internal.google_lower_journal(j: ai.Journal) -> google.internal.GmContent[] { - 590 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (contents) - - 591 3 load_type 1 - 4 alloc_array 0 - 5 store_var 3 (pending) - - 592 6 load_var 1 (j) - 7 call 905 ntypeargs=0 (ai.Journal.entries) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_6) - 17 load_var 5 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +204 (to 224) - 21 load_var 5 (_6) - 22 store_var 6 (e) - - 593 23 load_var 6 (e) - 24 store_var 7 (_10) - 25 load_var 7 (_10) - 26 narrow_bind 7 7 - 27 pop_jump_if_false +2 (to 29) - 28 jump +163 (to 191) - 29 load_var 6 (e) - 30 store_var 11 (_24) - 31 load_var 11 (_24) - 32 narrow_bind 8 11 - 33 pop_jump_if_false +2 (to 35) - 34 jump +64 (to 98) - 35 load_var 6 (e) - 36 store_var 26 (_61) - 37 load_var 26 (_61) - 38 narrow_bind 9 26 - 39 pop_jump_if_false +2 (to 41) - 40 jump +32 (to 72) - 41 load_var 6 (e) - 42 store_var 30 (_75) - 43 load_var 30 (_75) - 44 narrow_bind 10 30 - 45 pop_jump_if_false -33 (to 12) - 46 load_var 30 (_75) - 47 store_var 31 (f) - - 658 48 load_type 11 - 49 load_type 12 - 50 alloc_map 0 - 51 store_var 32 (response) - - 659 52 load_type 11 - 53 load_type 12 - 54 load_var 32 (response) - 55 load_const 13 ("error") - 56 load_var 31 (f) - 57 load_field 1 (message) - 58 call 37 ntypeargs=2 (baml.Map.set) - 59 pop 1 - - 662 60 load_var2 1 31 - 61 load_field 0 (id) - 62 call 1233 ntypeargs=0 (google.internal._gm_tool_name_for) - 63 load_var 32 (response) - 64 init_instance 0 (google.internal.GmFunctionResponse .name, .response) - - 661 65 call 1217 ntypeargs=0 (google.internal.GmPart.of_function_response) - 66 store_var 33 (_83) - - 660 67 load_type 1 - 68 load_var2 3 33 - 69 call 4 ntypeargs=1 (baml.Array.push) - 70 pop 1 - 71 jump -59 (to 12) - - 593 72 load_var 26 (_61) - 73 store_var 27 (c) - - 648 74 load_type 11 - 75 load_type 12 - 76 alloc_map 0 - 77 store_var 28 (response) - - 649 78 load_type 11 - 79 load_type 12 - 80 load_var 28 (response) - 81 load_const 14 ("result") - 82 load_var 27 (c) - 83 load_field 1 (output) - 84 call 37 ntypeargs=2 (baml.Map.set) - 85 pop 1 - - 652 86 load_var2 1 27 - 87 load_field 0 (id) - 88 call 1233 ntypeargs=0 (google.internal._gm_tool_name_for) - 89 load_var 28 (response) - 90 init_instance 1 (google.internal.GmFunctionResponse .name, .response) - - 651 91 call 1217 ntypeargs=0 (google.internal.GmPart.of_function_response) - 92 store_var 29 (_69) - - 650 93 load_type 1 - 94 load_var2 3 29 - 95 call 4 ntypeargs=1 (baml.Array.push) - 96 pop 1 - 97 jump -85 (to 12) - - 593 98 load_var 11 (_24) - 99 store_var 12 (a) - - 606 100 load_var 3 (pending) - 101 container_len - 102 store_var 13 (_27) - 103 load_var 13 (_27) - 104 load_const 15 (0) - 105 cmp_int_op > - 106 pop_jump_if_false +11 (to 117) - - 607 107 load_type 0 - 108 load_var 2 (contents) - 109 load_const 16 ("user") - 110 load_var 3 (pending) - 111 init_instance 2 (google.internal.GmContent .role, .parts) - 112 call 4 ntypeargs=1 (baml.Array.push) - 113 pop 1 - - 608 114 load_type 1 - 115 alloc_array 0 - 116 store_var 3 (pending) - - 613 117 load_type 1 - 118 alloc_array 0 - 119 store_var 14 (parts) - - 614 120 load_var 12 (a) - 121 load_field 0 (content) - 122 load_type 17 - 123 load_const 18 ("iter") - 124 virtual_call nargs=1 ntypeargs=0 - 125 store_var 15 (_34) - 126 load_var 15 (_34) - 127 load_type 19 - 128 load_const 20 ("next") - 129 virtual_call nargs=1 ntypeargs=0 - 130 store_var 16 (_35) - 131 load_var 16 (_35) - 132 is_type 6 - 133 pop_jump_if_false +2 (to 135) - 134 jump +42 (to 176) - 135 load_var 16 (_35) - 136 store_var 17 (b) - - 615 137 load_var 17 (b) - 138 store_var 18 (_39) - 139 load_var 18 (_39) - 140 narrow_bind 21 18 - 141 pop_jump_if_false +2 (to 143) - 142 jump +25 (to 167) - 143 load_var 17 (b) - 144 store_var 20 (_45) - 145 load_var 20 (_45) - 146 narrow_bind 22 20 - 147 pop_jump_if_false -21 (to 126) - 148 load_var 20 (_45) - 149 store_var_load_var 21 (use) - - 626 150 load_field 1 (name) - 151 load_var 21 (use) - 152 load_field 2 (args) - 153 init_instance 3 (google.internal.GmFunctionCall .name, .args) - 154 store_var 23 (_49) - - 627 155 load_var 21 (use) - 156 load_field 0 (id) - 157 call 1232 ntypeargs=0 (google.internal._gm_call_id_signature) - 158 store_var 24 (_52) - - 625 159 load_var2 23 24 - 160 call 1216 ntypeargs=0 (google.internal.GmPart.of_function_call) - 161 store_var 22 (_48) - - 624 162 load_type 1 - 163 load_var2 14 22 - 164 call 4 ntypeargs=1 (baml.Array.push) - 165 pop 1 - 166 jump -40 (to 126) - - 615 167 load_var 18 (_39) - 168 load_field 0 (text) - - 617 169 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 170 store_var 19 (_42) - 171 load_type 1 - 172 load_var2 14 19 - 173 call 4 ntypeargs=1 (baml.Array.push) - 174 pop 1 - 175 jump -49 (to 126) - - 639 176 load_var 14 (parts) - 177 container_len - 178 store_var 25 (_56) - 179 load_var 25 (_56) - 180 load_const 15 (0) - 181 cmp_int_op > - 182 pop_jump_if_false -170 (to 12) - - 640 183 load_type 0 - 184 load_var 2 (contents) - 185 load_const 23 ("model") - 186 load_var 14 (parts) - 187 init_instance 4 (google.internal.GmContent .role, .parts) - 188 call 4 ntypeargs=1 (baml.Array.push) - 189 pop 1 - 190 jump -178 (to 12) - - 593 191 load_var 7 (_10) - 192 store_var 8 (u) - - 595 193 load_var 3 (pending) - 194 container_len - 195 store_var 9 (_13) - 196 load_var 9 (_13) - 197 load_const 15 (0) - 198 cmp_int_op > - 199 pop_jump_if_false +11 (to 210) - - 596 200 load_type 0 - 201 load_var 2 (contents) - 202 load_const 24 ("user") - 203 load_var 3 (pending) - 204 init_instance 5 (google.internal.GmContent .role, .parts) - 205 call 4 ntypeargs=1 (baml.Array.push) - 206 pop 1 - - 597 207 load_type 1 - 208 alloc_array 0 - 209 store_var 3 (pending) - - 602 210 load_var 8 (u) - 211 load_field 0 (content) - 212 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 213 store_var 10 (_21) - 214 load_type 0 - 215 load_var 2 (contents) - 216 load_const 25 ("user") - 217 load_var 10 (_21) - 218 load_type 1 - 219 alloc_array 1 - 220 init_instance 6 (google.internal.GmContent .role, .parts) - 221 call 4 ntypeargs=1 (baml.Array.push) - 222 pop 1 - 223 jump -211 (to 12) - - 670 224 load_var 3 (pending) - 225 container_len - 226 store_var 34 (_90) - 227 load_var 34 (_90) - 228 load_const 15 (0) - 229 cmp_int_op > - 230 pop_jump_if_false +8 (to 238) - - 671 231 load_type 0 - 232 load_var 2 (contents) - 233 load_const 26 ("user") - 234 load_var 3 (pending) - 235 init_instance 7 (google.internal.GmContent .role, .parts) - 236 call 4 ntypeargs=1 (baml.Array.push) - 237 pop 1 - - 676 238 load_var 2 (contents) - 239 return -} - -function google.internal.google_lower_prompt(prompt: ai.Prompt, fetch_url: bool) -> google.internal.GooglePrompt { - 0 load_var 2 (fetch_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 489 4 load_const 1 (true) - 5 store_var 2 (fetch_url) - - 490 6 load_type 2 - 7 alloc_array 0 - 8 store_var 3 (system_parts) - - 491 9 load_type 3 - 10 alloc_array 0 - 11 store_var 4 (contents) - - 492 12 load_var 1 (prompt) - 13 call 910 ntypeargs=0 (ai.Prompt.messages) - 14 load_type 4 - 15 load_const 5 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_7) - 18 load_var 5 (_7) - 19 load_type 6 - 20 load_const 7 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 6 (_8) - 23 load_var 6 (_8) - 24 is_type 8 - 25 pop_jump_if_false +2 (to 27) - 26 jump +49 (to 75) - 27 load_var 6 (_8) - 28 store_var_load_var 7 (message) - - 493 29 load_var 2 (fetch_url) - 30 call 1228 ntypeargs=0 (google.internal._gm_prompt_parts) - 31 store_var 8 (parts) - - 494 32 load_var 7 (message) - 33 load_field 0 (role) - 34 load_const 9 ("system") - 35 cmp_op == - 36 pop_jump_if_false +2 (to 38) - 37 jump +19 (to 56) - - 500 38 load_var 7 (message) - 39 load_field 0 (role) - 40 load_const 10 ("assistant") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +4 (to 47) - - 503 44 load_const 11 ("user") - 45 store_var 11 (role) - - 500 46 jump +3 (to 49) - - 501 47 load_const 12 ("model") - 48 store_var 11 (role) - - 505 49 load_type 3 - 50 load_var2 4 11 - 51 load_var 8 (parts) - 52 init_instance 0 (google.internal.GmContent .role, .parts) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -37 (to 18) - - 495 56 load_var 8 (parts) - 57 load_type 13 - 58 load_const 14 ("iter") - 59 virtual_call nargs=1 ntypeargs=0 - 60 store_var 9 (_17) - 61 load_var 9 (_17) - 62 load_type 15 - 63 load_const 16 ("next") - 64 virtual_call nargs=1 ntypeargs=0 - 65 store_var 10 (_18) - 66 load_var 10 (_18) - 67 is_type 8 - 68 pop_jump_if_false +2 (to 70) - 69 jump -51 (to 18) - - 496 70 load_type 2 - 71 load_var2 3 10 - 72 call 4 ntypeargs=1 (baml.Array.push) - 73 pop 1 - 74 jump -13 (to 61) - - 509 75 load_var2 3 4 - 76 init_instance 1 (google.internal.GooglePrompt .system_parts, .contents) - 77 return -} - -function google.internal.google_parse(resp: google.internal.GmResponse, seq: int, provider: string) -> ai.ModelTurn { - 0 load_var 3 (provider) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 834 4 load_const 1 ("google") - 5 store_var 3 (provider) - - 838 6 load_var 1 (resp) - 7 load_field 5 (error) - 8 store_var 4 (_6) - 9 load_var 4 (_6) - 10 narrow_bind 2 4 - 11 pop_jump_if_false +2 (to 13) - 12 jump +279 (to 291) - - 845 13 load_type 3 - 14 alloc_array 0 - 15 store_var 9 (content) - - 846 16 load_const 4 (false) - 17 store_var 10 (has_call) - - 847 18 load_const 5 (0) - 19 store_var 11 (call_index) - - 848 20 load_var 1 (resp) - 21 load_field 0 (candidates) - 22 load_const 6 (null) - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +8 (to 33) - 26 load_const 5 (0) - 27 load_var 1 (resp) - 28 load_field 0 (candidates) - 29 make_bound_method 3 - 30 call_indirect - 31 store_var 12 (cand) - 32 jump +3 (to 35) - 33 load_const 6 (null) - 34 store_var 12 (cand) - - 849 35 load_var 12 (cand) - 36 load_const 6 (null) - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +4 (to 43) - 40 load_var 12 (cand) - 41 load_field 1 (1) - 42 jump +2 (to 44) - 43 load_const 6 (null) - 44 store_var_load_var 14 (_28) - 45 load_const 6 (null) - 46 cmp_op == - 47 pop_jump_if_false +3 (to 50) - 48 load_const 7 ("") - 49 store_var 14 (_28) - 50 load_var 14 (_28) - 51 store_var 13 (finish) - - 850 52 load_var 12 (cand) - 53 load_const 6 (null) - 54 cmp_op == - 55 pop_jump_if_false +2 (to 57) - 56 jump +16 (to 72) - 57 load_var 12 (cand) - 58 load_field 0 (0) - 59 load_const 6 (null) - 60 cmp_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +10 (to 72) - 63 load_var 12 (cand) - 64 load_const 6 (null) - 65 cmp_op == - 66 pop_jump_if_false +2 (to 68) - 67 jump +5 (to 72) - 68 load_var 12 (cand) - 69 load_field 0 (0) - 70 load_field 1 (1) - 71 jump +2 (to 73) - 72 load_const 6 (null) - 73 store_var_load_var 15 (_35) - 74 load_const 6 (null) - 75 cmp_op == - 76 pop_jump_if_false +4 (to 80) - 77 load_type 8 - 78 alloc_array 0 - 79 store_var 15 (_35) - 80 load_var 15 (_35) - 81 load_type 9 - 82 load_const 10 ("iter") - 83 virtual_call nargs=1 ntypeargs=0 - 84 store_var 16 (_48) - - 851 85 load_var 16 (_48) - 86 load_type 11 - 87 load_const 12 ("next") - 88 virtual_call nargs=1 ntypeargs=0 - 89 store_var 17 (_49) - 90 load_var 17 (_49) - 91 is_type 13 - 92 pop_jump_if_false +2 (to 94) - 93 jump +122 (to 215) - 94 load_var 17 (_49) - 95 store_var_load_var 18 (p) - - 852 96 load_field 3 (functionCall) - 97 store_var 19 (_54) - 98 load_var 19 (_54) - 99 narrow_bind 14 19 - 100 pop_jump_if_false +2 (to 102) - 101 jump +66 (to 167) - - 867 102 load_var 18 (p) - 103 load_field 4 (inlineData) - 104 store_var 26 (_76) - 105 load_var 26 (_76) - 106 narrow_bind 15 26 - 107 pop_jump_if_false +2 (to 109) - 108 jump +32 (to 140) - - 874 109 load_var 18 (p) - 110 load_field 0 (text) - 111 store_var 32 (_90) - 112 load_var 32 (_90) - 113 narrow_bind 16 32 - 114 pop_jump_if_false -29 (to 85) - 115 load_var 32 (_90) - 116 store_var 33 (t) - - 875 117 load_var 18 (p) - 118 load_field 1 (thought) - 119 store_var_load_var 34 (_93) - 120 load_const 6 (null) - 121 cmp_op == - 122 pop_jump_if_false +3 (to 125) - 123 load_const 4 (false) - 124 store_var 34 (_93) - 125 load_var 34 (_93) - 126 pop_jump_if_false +2 (to 128) - 127 jump +7 (to 134) - - 879 128 load_type 3 - 129 load_var2 9 33 - 130 init_instance 0 (ai.content.Text .text) - 131 call 4 ntypeargs=1 (baml.Array.push) - 132 pop 1 - 133 jump -48 (to 85) - - 876 134 load_type 3 - 135 load_var2 9 33 - 136 init_instance 1 (ai.content.Reasoning .summary) - 137 call 4 ntypeargs=1 (baml.Array.push) - 138 pop 1 - 139 jump -54 (to 85) - - 867 140 load_var 26 (_76) - 141 store_var_load_var 27 (inline) - - 870 142 load_field 0 (mimeType) - 143 store_var_load_var 30 (_81) - 144 load_const 6 (null) - 145 cmp_op == - 146 pop_jump_if_false +3 (to 149) - 147 load_const 17 ("image/png") - 148 store_var 30 (_81) - 149 load_var 30 (_81) - 150 store_var 29 (_80) - 151 load_var 27 (inline) - 152 load_field 1 (data) - 153 store_var_load_var 31 (_85) - 154 load_const 6 (null) - 155 cmp_op == - 156 pop_jump_if_false +3 (to 159) - 157 load_const 18 ("") - 158 store_var 31 (_85) - 159 load_var2 29 31 - 160 call 1237 ntypeargs=0 (google.internal._gm_output_media) - 161 store_var 28 (_79) - - 869 162 load_type 3 - 163 load_var2 9 28 - 164 call 4 ntypeargs=1 (baml.Array.push) - 165 pop 1 - 166 jump -81 (to 85) - - 852 167 load_var 19 (_54) - 168 store_var 20 (fc) - - 853 169 load_type 19 - 170 load_type 20 - 171 alloc_map 0 - 172 store_var 21 (args) - - 854 173 load_var 20 (fc) - 174 load_field 1 (args) - 175 store_var 22 (_58) - 176 load_var 22 (_58) - 177 narrow_bind 21 22 - 178 pop_jump_if_false +3 (to 181) - 179 load_var 22 (_58) - 180 store_var 21 (args) - - 859 181 load_type 22 - 182 load_var 2 (seq) - 183 call 138 ntypeargs=1 (baml.String.from) - 184 store_var 24 (_66) - 185 load_type 22 - 186 load_var 11 (call_index) - 187 call 138 ntypeargs=1 (baml.String.from) - 188 store_var 25 (_68) - 189 load_const 23 ("call_") - 190 load_var 24 (_66) - 191 bin_op + - 192 load_const 24 ("_") - 193 bin_op + - 194 load_var 25 (_68) - 195 bin_op + - 196 load_var 18 (p) - 197 load_field 2 (thoughtSignature) - 198 call 1231 ntypeargs=0 (google.internal._gm_encode_call_id) - 199 store_var 23 (_62) - - 857 200 load_type 3 - 201 load_var2 9 23 - - 860 202 load_var 20 (fc) - 203 load_field 0 (name) - - 861 204 load_var 21 (args) - 205 init_instance 2 (ai.content.ToolUse .id, .name, .args) - - 857 206 call 4 ntypeargs=1 (baml.Array.push) - 207 pop 1 - - 864 208 load_var 11 (call_index) - 209 load_const 16 (1) - 210 add_int - 211 store_var 11 (call_index) - - 865 212 load_const 25 (true) - 213 store_var 10 (has_call) - - 852 214 jump -129 (to 85) - - 887 215 load_var 1 (resp) - 216 load_field 2 (promptFeedback) - 217 load_const 6 (null) - 218 cmp_op == - 219 pop_jump_if_false +2 (to 221) - 220 jump +5 (to 225) - 221 load_var 1 (resp) - 222 load_field 2 (promptFeedback) - 223 load_field 0 (0) - 224 jump +2 (to 226) - 225 load_const 6 (null) - 226 load_const 6 (null) - 227 call 672 ntypeargs=0 (baml.ops.equals_equals) - 228 unary_op ! - 229 store_var 35 (blocked) - - 893 230 load_var 9 (content) - 231 container_len - 232 store_var 36 (_113) - 233 load_var 36 (_113) - 234 load_const 5 (0) - 235 cmp_int_op == - 236 jump_if_false +5 (to 241) - 237 pop 1 - 238 load_var 13 (finish) - 239 load_const 26 ("") - 240 cmp_op == - 241 jump_if_false +4 (to 245) - 242 pop 1 - 243 load_var 35 (blocked) - 244 unary_op ! - 245 pop_jump_if_false +2 (to 247) - 246 jump +37 (to 283) - - 899 247 load_var 10 (has_call) - 248 pop_jump_if_false +2 (to 250) - 249 jump +23 (to 272) - - 901 250 load_var 13 (finish) - 251 load_const 27 ("MAX_TOKENS") - 252 cmp_op == - 253 pop_jump_if_false +2 (to 255) - 254 jump +15 (to 269) - - 903 255 load_var 35 (blocked) - 256 jump_if_false +2 (to 258) - 257 jump +4 (to 261) - 258 pop 1 - 259 load_var 13 (finish) - 260 call 1238 ntypeargs=0 (google.internal._gm_is_blocked) - 261 pop_jump_if_false +2 (to 263) - 262 jump +4 (to 266) - - 906 263 load_const 5 (ai.content.StopReason.Complete) - 264 alloc_variant 774 (ai.content.StopReason) - - 903 265 jump +9 (to 274) - - 904 266 load_const 28 (ai.content.StopReason.Refused) - 267 alloc_variant 774 (ai.content.StopReason) - - 903 268 jump +6 (to 274) - - 902 269 load_const 29 (ai.content.StopReason.MaxTokens) - 270 alloc_variant 774 (ai.content.StopReason) - - 901 271 jump +3 (to 274) - - 900 272 load_const 16 (ai.content.StopReason.ToolUse) - 273 alloc_variant 774 (ai.content.StopReason) - - 908 274 store_var 38 (_128) - 275 load_var 1 (resp) - 276 load_field 1 (usageMetadata) - 277 call 1239 ntypeargs=0 (google.internal._gm_usage) - 278 store_var 39 (_129) - 279 load_var2 9 38 - 280 load_var 39 (_129) - 281 init_instance 3 (ai.ModelTurn .content, .stop_reason, .usage) - 282 return - - 896 283 load_type 30 - 284 load_var 1 (resp) - 285 call 355 ntypeargs=1 (baml.json.to_json) - 286 call 351 ntypeargs=0 (baml.json.stringify) - 287 store_var 37 (_117) - - 894 288 load_var2 3 37 - 289 init_instance 4 (ai.errors.ParseFailed .provider, .raw_output) - 290 throw - - 838 291 load_var 4 (_6) - 292 store_var_load_var 5 (err) - - 841 293 load_field 0 (code) - 294 store_var_load_var 7 (_10) - 295 load_const 6 (null) - 296 cmp_op == - 297 pop_jump_if_false +3 (to 300) - 298 load_const 5 (0) - 299 store_var 7 (_10) - 300 load_var 7 (_10) - 301 store_var 6 (_9) - - 842 302 load_var 5 (err) - 303 load_field 1 (message) - 304 store_var_load_var 8 (_14) - 305 load_const 6 (null) - 306 cmp_op == - 307 pop_jump_if_false +6 (to 313) - 308 load_type 30 - 309 load_var 1 (resp) - 310 call 355 ntypeargs=1 (baml.json.to_json) - 311 call 351 ntypeargs=0 (baml.json.stringify) - 312 store_var 8 (_14) - - 839 313 load_var2 3 6 - - 842 314 load_var 8 (_14) - 315 load_const 0 () - - 839 316 call 977 ntypeargs=0 (ai.errors.classify_http) - 317 throw -} - -function google.internal.google_render(c: google.GoogleClient, input: ai.ModelTurnInput) -> baml.http.Request { - 1050 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1245 ntypeargs=0 (google.internal._google_request) - 3 return -} - -function google.internal.vertex_invoke(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 331 0 load_var2 1 2 - 1 call 1263 ntypeargs=0 (google.internal.vertex_render) - 2 store_var 3 (req) - - 332 3 load_var 1 (c) - 4 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 5 load_const 0 ("anthropic") - 6 cmp_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +14 (to 22) - - 336 9 load_var 2 (input) - 10 load_field 1 (journal) - 11 call 905 ntypeargs=0 (ai.Journal.entries) - 12 container_len - 13 store_var 4 (seq) - - 337 14 load_type 1 - 15 load_var 3 (req) - 16 load_const 2 ("vertex") - 17 call 931 ntypeargs=1 (ai.wire.send_as) - - 338 18 load_var 4 (seq) - 19 load_const 3 ("vertex") - 20 call 1240 ntypeargs=0 (google.internal.google_parse) - 21 jump +6 (to 27) - - 333 22 load_type 4 - 23 load_var 3 (req) - 24 load_const 5 ("vertex") - 25 call 931 ntypeargs=1 (ai.wire.send_as) - - 334 26 call 1191 ntypeargs=0 (anthropic.internal.anthropic_parse) - 27 return -} - -function google.internal.vertex_invoke_stream(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 4 - 1 make_cell - 2 store_var 4 - - 353 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1264 ntypeargs=0 (google.internal._vertex_request) - - 354 6 load_const 1 ("vertex") - 7 call 1242 ntypeargs=0 (google.internal._gm_open_sse) - 8 store_var 3 (sse) - - 359 9 load_var 1 (c) - 10 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 11 load_const 2 ("anthropic") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +6 (to 20) - - 369 15 load_var 3 (sse) - 16 load_const 3 (google.internal._vertex_decode_batch) - 17 load_const 4 ("vertex") - 18 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 19 jump +7 (to 26) - - 360 20 call 1193 ntypeargs=0 (anthropic.internal.AnthStreamState.new) - 21 store_deref 4 - - 362 22 load_var2 3 4 - - 363 23 make_closure 3637 1 - 24 load_const 5 ("vertex") - - 361 25 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 26 return -} - -function google.internal.vertex_location(c: google.VertexClient) -> string { - 98 0 load_var 1 (c) - 1 load_field 2 (location) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +37 (to 43) - - 101 7 load_const 1 ("GOOGLE_CLOUD_LOCATION") - 8 sys_op 226 (baml.env.get) - 9 store_var 3 (_6) - 10 load_var 3 (_6) - 11 narrow_bind 0 3 - 12 pop_jump_if_false +9 (to 21) - 13 load_var 3 (_6) - 14 store_var 4 (from_env) - - 102 15 load_var 4 (from_env) - 16 call 144 ntypeargs=0 (baml.String.trim) - 17 load_const 2 ("") - 18 cmp_op != - 19 pop_jump_if_false +2 (to 21) - 20 jump +20 (to 40) - - 106 21 load_const 3 ("GOOGLE_CLOUD_REGION") - 22 sys_op 226 (baml.env.get) - 23 store_var 5 (_11) - 24 load_var 5 (_11) - 25 narrow_bind 0 5 - 26 pop_jump_if_false +9 (to 35) - 27 load_var 5 (_11) - 28 store_var 6 (from_region) - - 107 29 load_var 6 (from_region) - 30 call 144 ntypeargs=0 (baml.String.trim) - 31 load_const 4 ("") - 32 cmp_op != - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - - 111 35 load_const 5 ("global") - 36 jump +8 (to 44) - - 108 37 load_var 6 (from_region) - 38 call 144 ntypeargs=0 (baml.String.trim) - 39 jump +5 (to 44) - - 103 40 load_var 4 (from_env) - 41 call 144 ntypeargs=0 (baml.String.trim) - 42 jump +2 (to 44) - - 98 43 load_var 2 (_3) - 44 return -} - -function google.internal.vertex_project_id(c: google.VertexClient) -> string | null { - 127 0 load_var 1 (c) - 1 load_field 1 (project_id) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +45 (to 51) - - 130 7 load_var 1 (c) - 8 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 9 pop_jump_if_false +2 (to 11) - 10 jump +39 (to 49) - - 133 11 load_const 1 ("GOOGLE_CLOUD_PROJECT") - 12 sys_op 226 (baml.env.get) - 13 store_var 3 (_7) - 14 load_var 3 (_7) - 15 narrow_bind 0 3 - 16 pop_jump_if_false +9 (to 25) - 17 load_var 3 (_7) - 18 store_var 4 (from_env) - - 134 19 load_var 4 (from_env) - 20 call 144 ntypeargs=0 (baml.String.trim) - 21 load_const 2 ("") - 22 cmp_op != - 23 pop_jump_if_false +2 (to 25) - 24 jump +22 (to 46) - - 138 25 load_const 3 ("GCLOUD_PROJECT") - 26 sys_op 226 (baml.env.get) - 27 store_var 5 (_12) - 28 load_var 5 (_12) - 29 narrow_bind 0 5 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 5 (_12) - 32 store_var 6 (legacy) - - 139 33 load_var 6 (legacy) - 34 call 144 ntypeargs=0 (baml.String.trim) - 35 load_const 4 ("") - 36 cmp_op != - 37 pop_jump_if_false +2 (to 39) - 38 jump +5 (to 43) - - 143 39 load_var 1 (c) - 40 call 1251 ntypeargs=0 (google.internal._vertex_credentials) - 41 call 1269 ntypeargs=0 (google.internal.gcp_project_id) - 42 jump +10 (to 52) - - 140 43 load_var 6 (legacy) - 44 call 144 ntypeargs=0 (baml.String.trim) - 45 jump +7 (to 52) - - 135 46 load_var 4 (from_env) - 47 call 144 ntypeargs=0 (baml.String.trim) - 48 jump +4 (to 52) - - 131 49 load_const 5 (null) - 50 jump +2 (to 52) - - 127 51 load_var 2 (_3) - 52 return -} - -function google.internal.vertex_render(c: google.VertexClient, input: ai.ModelTurnInput) -> baml.http.Request { - 264 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1264 ntypeargs=0 (google.internal._vertex_request) - 3 return -} - -function google.internal.vertex_url(c: google.VertexClient, stream: bool) -> string { - 216 0 load_var 1 (c) - 1 call 1259 ntypeargs=0 (google.internal._vertex_models_base) - 2 store_var 5 (_8) - 3 load_type 0 - 4 load_var 5 (_8) - 5 call 138 ntypeargs=1 (baml.String.from) - 6 store_var 4 (_7) - 7 load_type 0 - 8 load_var 1 (c) - 9 load_field 0 (model) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 6 (_10) - 12 load_var2 1 2 - 13 call 1260 ntypeargs=0 (google.internal._vertex_method) - 14 store_var 8 (_14) - 15 load_type 0 - 16 load_var 8 (_14) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 7 (_13) - 19 load_var 4 (_7) - 20 load_const 1 ("/") - 21 bin_op + - 22 load_var 6 (_10) - 23 bin_op + - 24 load_var 7 (_13) - 25 bin_op + - - 217 26 load_var 1 (c) - 27 load_field 9 (query_params) - - 215 28 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 29 store_var 3 (with_params) - - 219 30 load_var 1 (c) - 31 call 1252 ntypeargs=0 (google.internal._vertex_express_key) - 32 store_var 9 (_18) - 33 load_var 9 (_18) - 34 narrow_bind 2 9 - 35 pop_jump_if_false +2 (to 37) - 36 jump +3 (to 39) - - 223 37 load_var 3 (with_params) - - 219 38 jump +7 (to 45) - - 221 39 load_var2 3 9 - - 219 40 load_const 3 ("key") - 41 load_type 0 - 42 load_type 0 - 43 alloc_map 1 - - 221 44 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 45 return -} - -function openai.AzureClient.ai.Client.id(self: openai.AzureClient) -> string { - 187 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("azure/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.AzureClient.ai.Client.invoke(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 191 0 load_var 1 (self) - 1 call 1071 ntypeargs=0 (openai.AzureClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1072 ntypeargs=0 (openai.AzureClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 192 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.AzureClient.ai.stream.StreamingClient.invoke_stream(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 199 0 load_var 1 (self) - 1 call 1071 ntypeargs=0 (openai.AzureClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1072 ntypeargs=0 (openai.AzureClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 200 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.AzureClient.compat(self: openai.AzureClient) -> openai.internal.ChatCompat { - 154 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 2 (query) - - 155 4 load_var 1 (self) - 5 load_field 3 (api_version) - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +8 (to 17) - - 156 10 load_type 0 - 11 load_type 0 - 12 load_var 2 (query) - 13 load_const 2 ("api-version") - - 155 14 load_var 3 (_4) - - 156 15 call 37 ntypeargs=2 (baml.Map.set) - 16 pop 1 - - 160 17 load_var 1 (self) - 18 call 1070 ntypeargs=0 (openai.AzureClient.resolved_base_url) - 19 store_var 4 (_10) - - 158 20 load_const 3 ("azure") - 21 load_var 4 (_10) - 22 load_const 4 () - 23 load_const 1 (openai.internal.ChatAuth.ApiKeyHeader) - 24 alloc_variant 777 (openai.internal.ChatAuth) - 25 load_const 5 ("AZURE_OPENAI_API_KEY") - 26 load_const 6 (true) - 27 load_const 4 () - 28 load_const 4 () - 29 load_const 4 () - 30 load_const 4 () - 31 load_const 7 (4096) - 32 load_const 4 () - - 165 33 load_var 2 (query) - - 158 34 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 35 return -} - -function openai.AzureClient.new(model: string, resource_name: string | null, deployment_id: string | null, api_version: string | null, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.AzureClient { - 0 load_var 2 (resource_name) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 60 4 load_const 1 (null) - 5 store_var 2 (resource_name) - 6 load_var 3 (deployment_id) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 61 10 load_const 1 (null) - 11 store_var 3 (deployment_id) - 12 load_var 4 (api_version) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 62 16 load_const 2 ("2024-10-21") - 17 store_var 4 (api_version) - 18 load_var 5 (base_url) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 63 22 load_const 1 (null) - 23 store_var 5 (base_url) - 24 load_var 6 (api_key) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 64 28 load_const 1 (null) - 29 store_var 6 (api_key) - 30 load_var 7 (request_body) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 65 34 load_const 1 (null) - 35 store_var 7 (request_body) - 36 load_var 8 (headers) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 66 40 load_const 1 (null) - 41 store_var 8 (headers) - 42 load_var 9 (query_params) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 67 46 load_const 1 (null) - 47 store_var 9 (query_params) - 48 load_var 10 (temperature) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 68 52 load_const 1 (null) - 53 store_var 10 (temperature) - 54 load_var 11 (max_tokens) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 69 58 load_const 1 (null) - 59 store_var 11 (max_tokens) - 60 load_var 12 (max_completion_tokens) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 70 64 load_const 1 (null) - 65 store_var 12 (max_completion_tokens) - 66 load_var 13 (top_p) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 71 70 load_const 1 (null) - 71 store_var 13 (top_p) - 72 load_var 14 (stop) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 72 76 load_const 1 (null) - 77 store_var 14 (stop) - 78 load_var 15 (seed) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 73 82 load_const 1 (null) - 83 store_var 15 (seed) - - 75 84 load_var2 1 2 - 85 load_var2 3 4 - 86 load_var2 5 6 - 87 load_var2 7 8 - 88 load_var2 9 10 - 89 load_var2 11 12 - 90 load_var2 13 14 - 91 load_var 15 (seed) - 92 init_instance 0 (openai.AzureClient .model, .resource_name, .deployment_id, .api_version, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed) - 93 return -} - -function openai.AzureClient.params(self: openai.AzureClient) -> openai.internal.ChatParams { - 171 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 172 3 load_var 1 (self) - 4 call 1068 ntypeargs=0 (openai.AzureClient.resolved_api_key) - 5 store_var 3 (_3) - - 170 6 load_var2 2 3 - - 173 7 load_var 1 (self) - 8 load_field 9 (temperature) - - 174 9 load_var 1 (self) - 10 load_field 10 (max_tokens) - - 175 11 load_var 1 (self) - 12 load_field 11 (max_completion_tokens) - - 176 13 load_var 1 (self) - 14 load_field 12 (top_p) - - 177 15 load_var 1 (self) - 16 load_field 13 (stop) - - 178 17 load_var 1 (self) - 18 load_field 14 (seed) - - 179 19 load_var 1 (self) - 20 load_field 7 (headers) - - 180 21 load_var 1 (self) - 22 load_field 8 (query_params) - - 181 23 load_var 1 (self) - 24 load_field 6 (request_body) - - 170 25 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 26 return -} - -function openai.AzureClient.resolved_api_key(self: openai.AzureClient) -> string | null { - 95 0 load_var 1 (self) - 1 load_field 5 (api_key) - 2 load_const 0 ("AZURE_OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.AzureClient.resolved_base_url(self: openai.AzureClient) -> string { - 126 0 load_var 1 (self) - 1 load_field 4 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +72 (to 80) - - 134 9 load_var 1 (self) - 10 call 1069 ntypeargs=0 (openai.AzureClient.resolved_deployment_id) - 11 store_var 4 (deployment) - - 135 12 load_var 1 (self) - 13 load_field 1 (resource_name) - 14 store_var 5 (_15) - 15 load_var 5 (_15) - 16 narrow_bind 1 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +46 (to 64) - - 140 19 load_const 0 (null) - 20 load_const 2 ("AZURE_OPENAI_ENDPOINT") - 21 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 22 store_var 8 (_26) - 23 load_var 8 (_26) - 24 narrow_bind 1 8 - 25 pop_jump_if_false +2 (to 27) - 26 jump +4 (to 30) - - 148 27 load_const 3 ("openai.AzureClient needs a deployment endpoint: set base_url, or resource_name, or the AZURE_OPENAI_ENDPOINT environment variable") - 28 call 1098 ntypeargs=0 (openai.internal._azure_reject) - 29 throw - - 140 30 load_var 8 (_26) - 31 store_var 9 (endpoint) - - 141 32 load_var 9 (endpoint) - 33 load_const 4 ("/") - 34 call 149 ntypeargs=0 (baml.String.ends_with) - 35 pop_jump_if_false +2 (to 37) - 36 jump +4 (to 40) - - 144 37 load_var 9 (endpoint) - 38 store_var 10 (origin) - - 141 39 jump +11 (to 50) - - 142 40 load_var 9 (endpoint) - 41 call 139 ntypeargs=0 (baml.String.length) - 42 store_var 11 (_31) - 43 load_var 9 (endpoint) - 44 load_const 5 (0) - 45 load_var 11 (_31) - 46 load_const 1 (1) - 47 sub_int - 48 call 153 ntypeargs=0 (baml.String.slice) - 49 store_var 10 (origin) - - 146 50 load_type 6 - 51 load_var 10 (origin) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 12 (_33) - 54 load_type 6 - 55 load_var 4 (deployment) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 13 (_36) - 58 load_var 12 (_33) - 59 load_const 7 ("/openai/deployments/") - 60 bin_op + - 61 load_var 13 (_36) - 62 bin_op + - 63 jump +35 (to 98) - - 136 64 load_type 6 - - 135 65 load_var 5 (_15) - - 136 66 call 138 ntypeargs=1 (baml.String.from) - 67 store_var 6 (_19) - 68 load_type 6 - 69 load_var 4 (deployment) - 70 call 138 ntypeargs=1 (baml.String.from) - 71 store_var 7 (_22) - 72 load_const 8 ("https://") - 73 load_var 6 (_19) - 74 bin_op + - 75 load_const 9 (".openai.azure.com/openai/deployments/") - 76 bin_op + - 77 load_var 7 (_22) - 78 bin_op + - 79 jump +19 (to 98) - - 126 80 load_var 2 (_4) - 81 store_var 3 (explicit) - - 127 82 load_var 1 (self) - 83 load_field 1 (resource_name) - 84 load_const 0 (null) - 85 call 672 ntypeargs=0 (baml.ops.equals_equals) - 86 unary_op ! - 87 jump_if_false +2 (to 89) - 88 jump +7 (to 95) - 89 pop 1 - 90 load_var 1 (self) - 91 load_field 2 (deployment_id) - 92 load_const 0 (null) - 93 call 672 ntypeargs=0 (baml.ops.equals_equals) - 94 unary_op ! - 95 pop_jump_if_false +2 (to 97) - 96 jump +3 (to 99) - - 132 97 load_var 3 (explicit) - 98 return - - 128 99 load_const 10 ("openai.AzureClient takes base_url OR resource_name/deployment_id, not both") - 100 call 1098 ntypeargs=0 (openai.internal._azure_reject) - 101 throw -} - -function openai.AzureClient.resolved_deployment_id(self: openai.AzureClient) -> string { - 100 0 load_var 1 (self) - 1 load_field 2 (deployment_id) - 2 store_var_load_var 2 (_2) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (self) - 7 load_field 0 (model) - 8 store_var 2 (_2) - 9 load_var 2 (_2) - 10 return -} - -function openai.ChatClient.ai.Client.id(self: openai.ChatClient) -> string { - 111 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("openai-chat/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.ChatClient.ai.Client.invoke(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 115 0 load_var 1 (self) - 1 call 1054 ntypeargs=0 (openai.ChatClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1055 ntypeargs=0 (openai.ChatClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 116 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.ChatClient.ai.stream.StreamingClient.invoke_stream(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 123 0 load_var 1 (self) - 1 call 1054 ntypeargs=0 (openai.ChatClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1055 ntypeargs=0 (openai.ChatClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 124 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.ChatClient.compat(self: openai.ChatClient) -> openai.internal.ChatCompat { - 86 0 load_var 1 (self) - 1 call 1053 ntypeargs=0 (openai.ChatClient.resolved_base_url) - 2 store_var 2 (_2) - - 84 3 load_const 0 ("openai-chat") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 2 ("OPENAI_API_KEY") - 8 load_const 3 (true) - 9 load_const 1 () - 10 load_const 1 () - 11 load_const 3 (true) - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.ChatClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.ChatClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 38 4 load_const 1 ("gpt-4o-mini") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 39 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 40 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (request_body) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 41 22 load_const 2 (null) - 23 store_var 4 (request_body) - 24 load_var 5 (headers) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 42 28 load_const 2 (null) - 29 store_var 5 (headers) - 30 load_var 6 (query_params) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 43 34 load_const 2 (null) - 35 store_var 6 (query_params) - 36 load_var 7 (temperature) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 44 40 load_const 2 (null) - 41 store_var 7 (temperature) - 42 load_var 8 (max_tokens) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 45 46 load_const 2 (null) - 47 store_var 8 (max_tokens) - 48 load_var 9 (max_completion_tokens) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 46 52 load_const 2 (null) - 53 store_var 9 (max_completion_tokens) - 54 load_var 10 (top_p) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 47 58 load_const 2 (null) - 59 store_var 10 (top_p) - 60 load_var 11 (stop) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 48 64 load_const 2 (null) - 65 store_var 11 (stop) - 66 load_var 12 (seed) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 49 70 load_const 2 (null) - 71 store_var 12 (seed) - - 51 72 load_var2 1 2 - 73 load_var2 3 4 - 74 load_var2 5 6 - 75 load_var2 7 8 - 76 load_var2 9 10 - 77 load_var2 11 12 - 78 init_instance 0 (openai.ChatClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed) - 79 return -} - -function openai.ChatClient.params(self: openai.ChatClient) -> openai.internal.ChatParams { - 95 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 96 3 load_var 1 (self) - 4 call 1052 ntypeargs=0 (openai.ChatClient.resolved_api_key) - 5 store_var 3 (_3) - - 94 6 load_var2 2 3 - - 97 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 98 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - - 99 11 load_var 1 (self) - 12 load_field 8 (max_completion_tokens) - - 100 13 load_var 1 (self) - 14 load_field 9 (top_p) - - 101 15 load_var 1 (self) - 16 load_field 10 (stop) - - 102 17 load_var 1 (self) - 18 load_field 11 (seed) - - 103 19 load_var 1 (self) - 20 load_field 4 (headers) - - 104 21 load_var 1 (self) - 22 load_field 5 (query_params) - - 105 23 load_var 1 (self) - 24 load_field 3 (request_body) - - 94 25 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 26 return -} - -function openai.ChatClient.resolved_api_key(self: openai.ChatClient) -> string | null { - 72 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.ChatClient.resolved_base_url(self: openai.ChatClient) -> string { - 77 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("https://api.openai.com/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.GenericClient.ai.Client.id(self: openai.GenericClient) -> string { - 110 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("openai-generic/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.GenericClient.ai.Client.invoke(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 114 0 load_var 1 (self) - 1 call 1062 ntypeargs=0 (openai.GenericClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1063 ntypeargs=0 (openai.GenericClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 115 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.GenericClient.ai.stream.StreamingClient.invoke_stream(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 122 0 load_var 1 (self) - 1 call 1062 ntypeargs=0 (openai.GenericClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1063 ntypeargs=0 (openai.GenericClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 123 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.GenericClient.compat(self: openai.GenericClient) -> openai.internal.ChatCompat { - 88 0 load_var 1 (self) - 1 call 1061 ntypeargs=0 (openai.GenericClient.resolved_base_url) - 2 store_var 2 (_2) - - 86 3 load_const 0 ("openai-generic") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 1 () - 8 load_const 1 () - 9 load_const 2 (true) - 10 load_const 1 () - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.GenericClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.GenericClient { - 0 load_var 2 (base_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 35 4 load_const 1 (null) - 5 store_var 2 (base_url) - 6 load_var 3 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 36 10 load_const 1 (null) - 11 store_var 3 (api_key) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 37 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 38 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 39 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 40 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 41 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 42 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 43 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 44 58 load_const 1 (null) - 59 store_var 11 (seed) - - 46 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.GenericClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.GenericClient.params(self: openai.GenericClient) -> openai.internal.ChatParams { - 95 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 96 3 load_var 1 (self) - 4 call 1060 ntypeargs=0 (openai.GenericClient.resolved_api_key) - 5 store_var 3 (_3) - - 94 6 load_var2 2 3 - - 97 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 98 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 99 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 100 14 load_var 1 (self) - 15 load_field 9 (stop) - - 101 16 load_var 1 (self) - 17 load_field 10 (seed) - - 102 18 load_var 1 (self) - 19 load_field 4 (headers) - - 103 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 104 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 94 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.GenericClient.resolved_api_key(self: openai.GenericClient) -> string | null { - 64 0 load_var 1 (self) - 1 load_field 2 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.GenericClient.resolved_base_url(self: openai.GenericClient) -> string { - 72 0 load_var 1 (self) - 1 load_field 1 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +16 (to 24) - - 81 9 load_var 1 (self) - 10 load_field 1 (base_url) - 11 load_const 0 (null) - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 2 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - - 79 18 load_const 3 ("openai-generic") - - 81 19 load_const 4 ("openai.GenericClient requires base_url (a literal or env.NAME naming a set variable): the endpoint of the OpenAI-compatible server, e.g. \"http://localhost:8000/v1\". Checked: ") - 20 load_var 3 (_8) - 21 bin_op + - - 79 22 call 1097 ntypeargs=0 (openai.internal._reject) - 23 throw - - 72 24 load_var 2 (_4) - 25 return -} - -function openai.ImageClient.ai.Client.id(self: openai.ImageClient) -> string { - 133 0 load_var 1 (self) - 1 call 1141 ntypeargs=0 (openai.internal._oai_images_client_id) - 2 return -} - -function openai.ImageClient.ai.Client.invoke(self: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 137 0 load_var2 1 2 - 1 call 1155 ntypeargs=0 (openai.internal.images_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 138 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, quality: string | null, background: string | null, output_format: string | null, output_compression: int | null, moderation: string | null, style: string | null, user: string | null, response_format: string | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ImageClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 73 4 load_const 1 ("gpt-image-1") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 74 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 75 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (n) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 76 22 load_const 2 (null) - 23 store_var 4 (n) - 24 load_var 5 (size) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 77 28 load_const 2 (null) - 29 store_var 5 (size) - 30 load_var 6 (quality) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 78 34 load_const 2 (null) - 35 store_var 6 (quality) - 36 load_var 7 (background) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 79 40 load_const 2 (null) - 41 store_var 7 (background) - 42 load_var 8 (output_format) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 80 46 load_const 2 (null) - 47 store_var 8 (output_format) - 48 load_var 9 (output_compression) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 81 52 load_const 2 (null) - 53 store_var 9 (output_compression) - 54 load_var 10 (moderation) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 82 58 load_const 2 (null) - 59 store_var 10 (moderation) - 60 load_var 11 (style) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 83 64 load_const 2 (null) - 65 store_var 11 (style) - 66 load_var 12 (user) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 84 70 load_const 2 (null) - 71 store_var 12 (user) - 72 load_var 13 (response_format) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 85 76 load_const 2 (null) - 77 store_var 13 (response_format) - 78 load_var 14 (request_body) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 86 82 load_const 2 (null) - 83 store_var 14 (request_body) - 84 load_var 15 (headers) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 87 88 load_const 2 (null) - 89 store_var 15 (headers) - 90 load_var 16 (query_params) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 88 94 load_const 2 (null) - 95 store_var 16 (query_params) - - 90 96 load_var2 1 2 - 97 load_var2 3 4 - 98 load_var2 5 6 - 99 load_var2 7 8 - 100 load_var2 9 10 - 101 load_var2 11 12 - 102 load_var2 13 14 - 103 load_var2 15 16 - 104 init_instance 0 (openai.ImageClient .model, .api_key, .base_url, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format, .request_body, .headers, .query_params) - 105 return -} - -function openai.ImageClient.resolved_api_key(self: openai.ImageClient) -> string { - 115 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 121 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("OPENAI_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 3 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - - 118 18 load_const 4 ("openai-images") - 19 load_const 5 (null) - - 121 20 load_const 6 ("no OpenAI API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — ") - 21 load_var 3 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 115 26 load_var 2 (_4) - 27 return -} - -function openai.ImageClient.resolved_base_url(self: openai.ImageClient) -> string | null { - 128 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OllamaClient.ai.Client.id(self: openai.OllamaClient) -> string { - 93 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("ollama/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.OllamaClient.ai.Client.invoke(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 97 0 load_var 1 (self) - 1 call 1079 ntypeargs=0 (openai.OllamaClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1080 ntypeargs=0 (openai.OllamaClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 98 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OllamaClient.ai.stream.StreamingClient.invoke_stream(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 105 0 load_var 1 (self) - 1 call 1079 ntypeargs=0 (openai.OllamaClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1080 ntypeargs=0 (openai.OllamaClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 106 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OllamaClient.compat(self: openai.OllamaClient) -> openai.internal.ChatCompat { - 70 0 load_var 1 (self) - 1 call 1078 ntypeargs=0 (openai.OllamaClient.resolved_base_url) - 2 store_var 2 (_2) - - 68 3 load_const 0 ("ollama") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 1 () - 8 load_const 1 () - 9 load_const 2 (true) - 10 load_const 2 (true) - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.OllamaClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OllamaClient { - 0 load_var 2 (base_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 33 4 load_const 1 (null) - 5 store_var 2 (base_url) - 6 load_var 3 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 34 10 load_const 1 (null) - 11 store_var 3 (api_key) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 35 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 36 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 37 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 38 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 39 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 40 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 41 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 42 58 load_const 1 (null) - 59 store_var 11 (seed) - - 44 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.OllamaClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.OllamaClient.params(self: openai.OllamaClient) -> openai.internal.ChatParams { - 78 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 79 3 load_var 1 (self) - 4 call 1077 ntypeargs=0 (openai.OllamaClient.resolved_api_key) - 5 store_var 3 (_3) - - 77 6 load_var2 2 3 - - 80 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 81 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 82 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 83 14 load_var 1 (self) - 15 load_field 9 (stop) - - 84 16 load_var 1 (self) - 17 load_field 10 (seed) - - 85 18 load_var 1 (self) - 19 load_field 4 (headers) - - 86 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 87 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 77 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.OllamaClient.resolved_api_key(self: openai.OllamaClient) -> string | null { - 60 0 load_var 1 (self) - 1 load_field 2 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OllamaClient.resolved_base_url(self: openai.OllamaClient) -> string { - 64 0 load_var 1 (self) - 1 load_field 1 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("http://localhost:11434/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.OpenRouterClient.ai.Client.id(self: openai.OpenRouterClient) -> string { - 91 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("openrouter/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.OpenRouterClient.ai.Client.invoke(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 95 0 load_var 1 (self) - 1 call 1087 ntypeargs=0 (openai.OpenRouterClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1088 ntypeargs=0 (openai.OpenRouterClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 96 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OpenRouterClient.ai.stream.StreamingClient.invoke_stream(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 103 0 load_var 1 (self) - 1 call 1087 ntypeargs=0 (openai.OpenRouterClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1088 ntypeargs=0 (openai.OpenRouterClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 104 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OpenRouterClient.compat(self: openai.OpenRouterClient) -> openai.internal.ChatCompat { - 68 0 load_var 1 (self) - 1 call 1086 ntypeargs=0 (openai.OpenRouterClient.resolved_base_url) - 2 store_var 2 (_2) - - 66 3 load_const 0 ("openrouter") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 2 ("OPENROUTER_API_KEY") - 8 load_const 3 (true) - 9 load_const 1 () - 10 load_const 1 () - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.OpenRouterClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OpenRouterClient { - 0 load_var 2 (api_key) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 31 4 load_const 1 (null) - 5 store_var 2 (api_key) - 6 load_var 3 (base_url) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 32 10 load_const 1 (null) - 11 store_var 3 (base_url) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 33 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 34 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 35 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 36 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 37 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 38 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 39 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 40 58 load_const 1 (null) - 59 store_var 11 (seed) - - 42 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.OpenRouterClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.OpenRouterClient.params(self: openai.OpenRouterClient) -> openai.internal.ChatParams { - 76 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 77 3 load_var 1 (self) - 4 call 1085 ntypeargs=0 (openai.OpenRouterClient.resolved_api_key) - 5 store_var 3 (_3) - - 75 6 load_var2 2 3 - - 78 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 79 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 80 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 81 14 load_var 1 (self) - 15 load_field 9 (stop) - - 82 16 load_var 1 (self) - 17 load_field 10 (seed) - - 83 18 load_var 1 (self) - 19 load_field 4 (headers) - - 84 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 85 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 75 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.OpenRouterClient.resolved_api_key(self: openai.OpenRouterClient) -> string | null { - 58 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENROUTER_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OpenRouterClient.resolved_base_url(self: openai.OpenRouterClient) -> string { - 62 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("https://openrouter.ai/api/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.ResponsesClient.ai.Client.id(self: openai.ResponsesClient) -> string { - 123 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_2) - 5 load_const 1 ("openai/") - 6 load_var 2 (_2) - 7 bin_op + - 8 return -} - -function openai.ResponsesClient.ai.Client.invoke(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 127 0 load_var2 1 2 - 1 call 1043 ntypeargs=0 (openai.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 128 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ResponsesClient.ai.stream.StreamingClient.invoke_stream(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 135 0 load_var2 1 2 - 1 call 1050 ntypeargs=0 (openai.internal.invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 136 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ResponsesClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, temperature: float | null, top_p: float | null, max_output_tokens: int | null, reasoning_effort: string | null, reasoning_summary: string | null, verbosity: string | null, parallel_tool_calls: bool | null, store: bool, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ResponsesClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 63 4 load_const 1 ("gpt-4o-mini") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 64 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 65 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (temperature) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 66 22 load_const 2 (null) - 23 store_var 4 (temperature) - 24 load_var 5 (top_p) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 67 28 load_const 2 (null) - 29 store_var 5 (top_p) - 30 load_var 6 (max_output_tokens) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 68 34 load_const 2 (null) - 35 store_var 6 (max_output_tokens) - 36 load_var 7 (reasoning_effort) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 69 40 load_const 2 (null) - 41 store_var 7 (reasoning_effort) - 42 load_var 8 (reasoning_summary) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 70 46 load_const 2 (null) - 47 store_var 8 (reasoning_summary) - 48 load_var 9 (verbosity) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 71 52 load_const 2 (null) - 53 store_var 9 (verbosity) - 54 load_var 10 (parallel_tool_calls) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 72 58 load_const 2 (null) - 59 store_var 10 (parallel_tool_calls) - 60 load_var 11 (store) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 73 64 load_const 3 (false) - 65 store_var 11 (store) - 66 load_var 12 (request_body) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 74 70 load_const 2 (null) - 71 store_var 12 (request_body) - 72 load_var 13 (headers) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 75 76 load_const 2 (null) - 77 store_var 13 (headers) - 78 load_var 14 (query_params) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 76 82 load_const 2 (null) - 83 store_var 14 (query_params) - - 78 84 load_var2 1 2 - 85 load_var2 3 4 - 86 load_var2 5 6 - 87 load_var2 7 8 - 88 load_var2 9 10 - 89 load_var2 11 12 - 90 load_var2 13 14 - 91 init_instance 0 (openai.ResponsesClient .model, .api_key, .base_url, .temperature, .top_p, .max_output_tokens, .reasoning_effort, .reasoning_summary, .verbosity, .parallel_tool_calls, .store, .request_body, .headers, .query_params) - 92 return -} - -function openai.ResponsesClient.resolved_api_key(self: openai.ResponsesClient) -> string { - 105 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 111 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("OPENAI_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 3 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - - 108 18 load_const 4 ("openai") - 19 load_const 5 (null) - - 111 20 load_const 6 ("openai needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 21 load_var 3 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 105 26 load_var 2 (_4) - 27 return -} - -function openai.ResponsesClient.resolved_base_url(self: openai.ResponsesClient) -> string | null { - 118 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.internal.CcToolCall.baml.FromJson.from_json(j: baml.json.json) -> openai.internal.CcToolCall { - 389 0 load_var 1 (j) - 1 load_const 0 ("id") - 2 call 360 ntypeargs=0 (baml.json.field) - 3 store_var 2 (_3) - 4 load_type 1 - 5 load_var 2 (_3) - 6 call 359 ntypeargs=1 (baml.json.to) - - 390 7 load_var 1 (j) - 8 load_const 2 ("type") - 9 call 360 ntypeargs=0 (baml.json.field) - 10 store_var 3 (_6) - 11 load_type 1 - 12 load_var 3 (_6) - 13 call 359 ntypeargs=1 (baml.json.to) - - 391 14 load_var 1 (j) - 15 load_const 3 ("index") - 16 call 360 ntypeargs=0 (baml.json.field) - 17 store_var 4 (_9) - 18 load_type 4 - 19 load_var 4 (_9) - 20 call 359 ntypeargs=1 (baml.json.to) - - 392 21 load_var 1 (j) - 22 load_const 5 ("function") - 23 call 360 ntypeargs=0 (baml.json.field) - 24 store_var 5 (_12) - 25 load_type 6 - 26 load_var 5 (_12) - 27 call 359 ntypeargs=1 (baml.json.to) - - 388 28 init_instance 0 (openai.internal.CcToolCall .id, .type, .index, .fn) - 29 return -} - -function openai.internal.ChatCompat.new(provider: string, base_url: string, path: string, auth: openai.internal.ChatAuth, api_key_env: string | null, api_key_required: bool, collapse_text_content: bool, inline_image_urls: bool, send_stream_options: bool, max_tokens_key: string, default_max_tokens: int | null, default_role: string, compat_query: map | null) -> openai.internal.ChatCompat { - 0 load_var 3 (path) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 116 4 load_const 1 ("/chat/completions") - 5 store_var 3 (path) - 6 load_var 4 (auth) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +4 (to 13) - - 117 10 load_const 2 (openai.internal.ChatAuth.Bearer) - 11 alloc_variant 777 (openai.internal.ChatAuth) - 12 store_var 4 (auth) - 13 load_var 5 (api_key_env) - 14 load_const 0 () - 15 cmp_op == - 16 pop_jump_if_false +3 (to 19) - - 118 17 load_const 3 (null) - 18 store_var 5 (api_key_env) - 19 load_var 6 (api_key_required) - 20 load_const 0 () - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - - 119 23 load_const 4 (false) - 24 store_var 6 (api_key_required) - 25 load_var 7 (collapse_text_content) - 26 load_const 0 () - 27 cmp_op == - 28 pop_jump_if_false +3 (to 31) - - 120 29 load_const 4 (false) - 30 store_var 7 (collapse_text_content) - 31 load_var 8 (inline_image_urls) - 32 load_const 0 () - 33 cmp_op == - 34 pop_jump_if_false +3 (to 37) - - 121 35 load_const 4 (false) - 36 store_var 8 (inline_image_urls) - 37 load_var 9 (send_stream_options) - 38 load_const 0 () - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - - 122 41 load_const 4 (false) - 42 store_var 9 (send_stream_options) - 43 load_var 10 (max_tokens_key) - 44 load_const 0 () - 45 cmp_op == - 46 pop_jump_if_false +3 (to 49) - - 123 47 load_const 5 ("max_tokens") - 48 store_var 10 (max_tokens_key) - 49 load_var 11 (default_max_tokens) - 50 load_const 0 () - 51 cmp_op == - 52 pop_jump_if_false +3 (to 55) - - 124 53 load_const 3 (null) - 54 store_var 11 (default_max_tokens) - 55 load_var 12 (default_role) - 56 load_const 0 () - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - - 125 59 load_const 6 ("user") - 60 store_var 12 (default_role) - 61 load_var 13 (compat_query) - 62 load_const 0 () - 63 cmp_op == - 64 pop_jump_if_false +3 (to 67) - - 126 65 load_const 3 (null) - 66 store_var 13 (compat_query) - - 142 67 load_var 13 (compat_query) - 68 store_var_load_var 14 (_27) - 69 load_const 3 (null) - 70 cmp_op == - 71 pop_jump_if_false +5 (to 76) - - 128 72 load_type 7 - 73 load_type 7 - 74 alloc_map 0 - 75 store_var 14 (_27) - - 129 76 load_var2 1 2 - 77 load_var2 3 4 - 78 load_var2 5 6 - 79 load_var2 7 8 - 80 load_var2 9 10 - 81 load_var2 11 12 - - 142 82 load_var 14 (_27) - 83 init_instance 0 (openai.internal.ChatCompat .provider, .base_url, .path, .auth, .api_key_env, .api_key_required, .collapse_text_content, .inline_image_urls, .send_stream_options, .max_tokens_key, .default_max_tokens, .default_role, .compat_query) - 84 return -} - -function openai.internal.ChatExtraPart.baml.ToJson.to_json(self: openai.internal.ChatExtraPart) -> baml.json.json { - 263 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (part) - 3 call 355 ntypeargs=1 (baml.json.to_json) - 4 store_var 2 (base) - - 264 5 load_var 2 (base) - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +3 (to 13) - - 275 11 load_var 2 (base) - - 264 12 jump +63 (to 75) - 13 load_var 3 (_5) - 14 store_var 4 (object) - - 266 15 load_type 2 - 16 load_type 3 - 17 alloc_map 0 - 18 store_var 5 (out) - - 267 19 load_type 2 - 20 load_type 3 - 21 load_var 4 (object) - 22 call 35 ntypeargs=2 (baml.Map.keys) - 23 load_type 4 - 24 load_const 5 ("iter") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 6 (_11) - 27 load_var 6 (_11) - 28 load_type 6 - 29 load_const 7 ("next") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 7 (_12) - 32 load_var 7 (_12) - 33 is_type 8 - 34 pop_jump_if_false +2 (to 36) - 35 jump +15 (to 50) - 36 load_var 7 (_12) - 37 store_var 8 (key) - - 268 38 load_type 2 - 39 load_type 3 - 40 load_var2 4 8 - 41 call 38 ntypeargs=2 (baml.Map.get) - 42 store_var 9 (_18) - 43 load_type 2 - 44 load_type 3 - 45 load_var2 5 8 - 46 load_var 9 (_18) - 47 call 37 ntypeargs=2 (baml.Map.set) - 48 pop 1 - 49 jump -22 (to 27) - - 270 50 load_type 2 - 51 load_type 3 - 52 load_var 1 (self) - 53 load_field 1 (extra) - 54 call 35 ntypeargs=2 (baml.Map.keys) - 55 container_len - 56 store_var 10 (_25) - 57 load_var 10 (_25) - 58 load_const 9 (0) - 59 cmp_int_op > - 60 pop_jump_if_false +14 (to 74) - - 271 61 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 62 store_var 11 (_31) - 63 load_type 1 - 64 load_var 1 (self) - 65 load_field 1 (extra) - 66 call 355 ntypeargs=1 (baml.json.to_json) - 67 store_var 12 (_32) - 68 load_type 2 - 69 load_type 3 - 70 load_var2 5 11 - 71 load_var 12 (_32) - 72 call 37 ntypeargs=2 (baml.Map.set) - 73 pop 1 - - 273 74 load_var 5 (out) - 75 return -} - -function openai.internal.ChatParams.new(model: string, api_key: string | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null, headers: map | null, query_params: map | null, request_body: baml.json.json | null) -> openai.internal.ChatParams { - 0 load_var 2 (api_key) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 166 4 load_const 1 (null) - 5 store_var 2 (api_key) - 6 load_var 3 (temperature) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 167 10 load_const 1 (null) - 11 store_var 3 (temperature) - 12 load_var 4 (max_tokens) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 168 16 load_const 1 (null) - 17 store_var 4 (max_tokens) - 18 load_var 5 (max_completion_tokens) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 169 22 load_const 1 (null) - 23 store_var 5 (max_completion_tokens) - 24 load_var 6 (top_p) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 170 28 load_const 1 (null) - 29 store_var 6 (top_p) - 30 load_var 7 (stop) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 171 34 load_const 1 (null) - 35 store_var 7 (stop) - 36 load_var 8 (seed) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 172 40 load_const 1 (null) - 41 store_var 8 (seed) - 42 load_var 9 (headers) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 173 46 load_const 1 (null) - 47 store_var 9 (headers) - 48 load_var 10 (query_params) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 174 52 load_const 1 (null) - 53 store_var 10 (query_params) - 54 load_var 11 (request_body) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 175 58 load_const 1 (null) - 59 store_var 11 (request_body) - - 177 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (request_body) - 66 init_instance 0 (openai.internal.ChatParams .model, .api_key, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .headers, .query_params, .request_body) - 67 return -} - -function openai.internal.ChatStreamDecoder._absorb_call(self: openai.internal.ChatStreamDecoder, delta: openai.internal.CcToolCall, position: int) -> void { - 0 load_var 4 - 1 make_cell - 2 store_var 4 - - 1396 3 load_var 2 (delta) - 4 load_field 2 (index) - 5 store_var_load_var 5 (_5) - 6 load_const 0 (null) - 7 cmp_op == - 8 pop_jump_if_false +3 (to 11) - 9 load_var 3 (position) - 10 store_var 5 (_5) - 11 load_var 5 (_5) - 12 store_deref 4 - - 1397 13 load_type 1 - 14 load_type 2 - 15 load_var 1 (self) - 16 load_field 1 (calls) - - 1398 17 load_var 4 (index) - 18 make_closure 3026 1 - - 1397 19 call 19 ntypeargs=2 (baml.Array.find) - - 1402 20 store_var 7 (_14) - 21 load_var 7 (_14) - 22 narrow_bind 3 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +16 (to 40) - - 1405 25 load_deref 4 - 26 load_const 4 ("") - 27 load_const 5 ("") - 28 load_const 6 ("") - 29 init_instance 0 (openai.internal.ChatToolCallBuffer .index, .id, .name, .arguments) - 30 store_var 8 (fresh) - - 1406 31 load_type 1 - 32 load_var 1 (self) - 33 load_field 1 (calls) - 34 load_var 8 (fresh) - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - - 1407 37 load_var 8 (fresh) - 38 store_var 6 (buffer) - - 1402 39 jump +3 (to 42) - 40 load_var 7 (_14) - 41 store_var 6 (buffer) - - 1410 42 load_var 2 (delta) - 43 load_field 0 (id) - 44 store_var 9 (_23) - 45 load_var 9 (_23) - 46 narrow_bind 7 9 - 47 pop_jump_if_false +3 (to 50) - - 1411 48 load_var2 6 9 - - 1410 49 store_field 1 (id) - - 1413 50 load_var 2 (delta) - 51 load_field 3 (fn) - 52 load_const 0 (null) - 53 cmp_op == - 54 pop_jump_if_false +2 (to 56) - 55 jump +5 (to 60) - 56 load_var 2 (delta) - 57 load_field 3 (fn) - 58 load_field 0 (0) - 59 jump +2 (to 61) - 60 load_const 0 (null) - 61 store_var 10 (_29) - 62 load_var 10 (_29) - 63 narrow_bind 7 10 - 64 pop_jump_if_false +16 (to 80) - 65 load_var 10 (_29) - 66 store_var 11 (name) - - 1414 67 load_type 8 - 68 load_var 6 (buffer) - 69 load_field 2 (name) - 70 call 138 ntypeargs=1 (baml.String.from) - 71 store_var 12 (_31) - 72 load_type 8 - 73 load_var 11 (name) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 13 (_34) - 76 load_var2 6 12 - 77 load_var 13 (_34) - 78 bin_op + - 79 store_field 2 (name) - - 1416 80 load_var 2 (delta) - 81 load_field 3 (fn) - 82 load_const 0 (null) - 83 cmp_op == - 84 pop_jump_if_false +2 (to 86) - 85 jump +5 (to 90) - 86 load_var 2 (delta) - 87 load_field 3 (fn) - 88 load_field 1 (1) - 89 jump +2 (to 91) - 90 load_const 0 (null) - 91 store_var 14 (_41) - 92 load_var 14 (_41) - 93 narrow_bind 7 14 - 94 pop_jump_if_false +2 (to 96) - 95 jump +3 (to 98) - 96 load_const 0 (null) - 97 jump +17 (to 114) - 98 load_var 14 (_41) - 99 store_var 15 (fragment) - - 1417 100 load_type 8 - 101 load_var 6 (buffer) - 102 load_field 3 (arguments) - 103 call 138 ntypeargs=1 (baml.String.from) - 104 store_var 16 (_43) - 105 load_type 8 - 106 load_var 15 (fragment) - 107 call 138 ntypeargs=1 (baml.String.from) - 108 store_var 17 (_46) - 109 load_var2 6 16 - 110 load_var 17 (_46) - 111 bin_op + - 112 store_field 3 (arguments) - - 1416 113 load_const 0 (null) - 114 return -} - -function openai.internal.ChatStreamDecoder.decode(self: openai.internal.ChatStreamDecoder, batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1423 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 1424 3 load_var 2 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +201 (to 218) - 18 load_var 5 (_6) - 19 load_field 1 (data) - 20 store_var 6 (_11) - - 1425 21 load_var 6 (_11) - 22 narrow_bind 6 6 - 23 pop_jump_if_false -14 (to 9) - 24 load_var 6 (_11) - 25 store_var 7 (data) - - 1426 26 load_var 7 (data) - 27 call 144 ntypeargs=0 (baml.String.trim) - 28 load_const 7 ("[DONE]") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +181 (to 212) - - 1430 32 load_var 7 (data) - 33 call 350 ntypeargs=0 (baml.json.parse) - 34 store_var 10 (_20) - - 1429 35 load_type 8 - 36 load_var 10 (_20) - 37 call 359 ntypeargs=1 (baml.json.to) - 38 store_var 8 (parsed) - 39 jump +5 (to 44) - 40 load_var 9 (e) - 41 throw_if_panic - - 1432 42 load_const 9 (null) - 43 store_var 8 (parsed) - - 1439 44 load_var 8 (parsed) - 45 load_const 9 (null) - 46 call 672 ntypeargs=0 (baml.ops.equals_equals) - 47 jump_if_false +6 (to 53) - 48 pop 1 - 49 load_var 7 (data) - 50 call 144 ntypeargs=0 (baml.String.trim) - 51 load_const 10 ("{") - 52 call 148 ntypeargs=0 (baml.String.starts_with) - 53 pop_jump_if_false +2 (to 55) - 54 jump +153 (to 207) - - 1442 55 load_var 8 (parsed) - 56 store_var 11 (_30) - 57 load_var 11 (_30) - 58 narrow_bind 11 11 - 59 pop_jump_if_false -50 (to 9) - 60 load_var 11 (_30) - 61 store_var_load_var 12 (chunk) - - 1443 62 load_field 2 (choices) - 63 store_var_load_var 13 (_33) - 64 load_const 9 (null) - 65 cmp_op == - 66 pop_jump_if_false +4 (to 70) - 67 load_type 12 - 68 alloc_array 0 - 69 store_var 13 (_33) - - 1444 70 load_type 12 - - 1443 71 load_var 13 (_33) - 72 load_const 13 (0) - - 1444 73 call 3 ntypeargs=1 (baml.Array.at) - 74 store_var 14 (_38) - 75 load_var 14 (_38) - 76 narrow_bind 14 14 - 77 pop_jump_if_false +111 (to 188) - 78 load_var 14 (_38) - 79 store_var_load_var 15 (choice) - - 1445 80 load_field 1 (delta) - 81 load_const 9 (null) - 82 cmp_op == - 83 pop_jump_if_false +2 (to 85) - 84 jump +5 (to 89) - 85 load_var 15 (choice) - 86 load_field 1 (delta) - 87 load_field 1 (1) - 88 jump +2 (to 90) - 89 load_const 9 (null) - 90 store_var 16 (_44) - 91 load_var 16 (_44) - 92 narrow_bind 6 16 - 93 pop_jump_if_false +11 (to 104) - 94 load_var 16 (_44) - 95 store_var_load_var 17 (text) - - 1446 96 load_const 15 ("") - 97 cmp_op != - 98 pop_jump_if_false +6 (to 104) - - 1447 99 load_type 0 - 100 load_var2 3 17 - 101 init_instance 0 (ai.stream.TextDelta .text) - 102 call 4 ntypeargs=1 (baml.Array.push) - 103 pop 1 - - 1450 104 load_var 15 (choice) - 105 load_field 1 (delta) - 106 load_const 9 (null) - 107 cmp_op == - 108 pop_jump_if_false +2 (to 110) - 109 jump +5 (to 114) - 110 load_var 15 (choice) - 111 load_field 1 (delta) - 112 load_field 2 (2) - 113 jump +2 (to 115) - 114 load_const 9 (null) - 115 store_var 18 (_56) - 116 load_var 18 (_56) - 117 narrow_bind 6 18 - 118 pop_jump_if_false +11 (to 129) - 119 load_var 18 (_56) - 120 store_var_load_var 19 (refusal) - - 1451 121 load_const 16 ("") - 122 cmp_op != - 123 pop_jump_if_false +6 (to 129) - - 1452 124 load_type 0 - 125 load_var2 3 19 - 126 init_instance 1 (ai.stream.TextDelta .text) - 127 call 4 ntypeargs=1 (baml.Array.push) - 128 pop 1 - - 1455 129 load_var 15 (choice) - 130 load_field 1 (delta) - 131 load_const 9 (null) - 132 cmp_op == - 133 pop_jump_if_false +2 (to 135) - 134 jump +5 (to 139) - 135 load_var 15 (choice) - 136 load_field 1 (delta) - 137 load_field 4 (4) - 138 jump +2 (to 140) - 139 load_const 9 (null) - 140 store_var_load_var 20 (_65) - 141 load_const 9 (null) - 142 cmp_op == - 143 pop_jump_if_false +4 (to 147) - 144 load_type 17 - 145 alloc_array 0 - 146 store_var 20 (_65) - - 1456 147 load_const 13 (0) - 148 store_var 21 (position) - - 1455 149 load_var 20 (_65) - 150 load_type 18 - 151 load_const 19 ("iter") - 152 virtual_call nargs=1 ntypeargs=0 - 153 store_var 22 (_73) - - 1457 154 load_var 22 (_73) - 155 load_type 20 - 156 load_const 21 ("next") - 157 virtual_call nargs=1 ntypeargs=0 - 158 store_var 23 (_74) - 159 load_var 23 (_74) - 160 is_type 5 - 161 pop_jump_if_false +2 (to 163) - 162 jump +10 (to 172) - - 1458 163 load_var2 1 23 - 164 load_var 21 (position) - 165 call 1136 ntypeargs=0 (openai.internal.ChatStreamDecoder._absorb_call) - 166 pop 1 - - 1459 167 load_var 21 (position) - 168 load_const 6 (1) - 169 add_int - 170 store_var 21 (position) - - 1457 171 jump -17 (to 154) - - 1461 172 load_var 15 (choice) - 173 load_field 2 (finish_reason) - 174 store_var 24 (_82) - 175 load_var 24 (_82) - 176 narrow_bind 6 24 - 177 pop_jump_if_false +11 (to 188) - 178 load_var 24 (_82) - - 1464 179 call 1128 ntypeargs=0 (openai.internal.chat_stop_reason) - 180 store_var 25 (_86) - - 1462 181 load_type 0 - 182 load_var2 3 25 - - 1463 183 load_const 9 (null) - 184 load_const 9 (null) - 185 init_instance 2 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1462 186 call 4 ntypeargs=1 (baml.Array.push) - 187 pop 1 - - 1471 188 load_var 12 (chunk) - 189 load_field 3 (usage) - 190 store_var 26 (_90) - 191 load_var 26 (_90) - 192 narrow_bind 22 26 - 193 pop_jump_if_false -184 (to 9) - 194 load_var 26 (_90) - 195 store_var 27 (usage) - - 1472 196 load_type 0 - 197 load_var 3 (out) - - 1473 198 load_const 9 (null) - - 1475 199 load_var 27 (usage) - 200 load_field 0 (prompt_tokens) - - 1476 201 load_var 27 (usage) - 202 load_field 1 (completion_tokens) - 203 init_instance 3 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1472 204 call 4 ntypeargs=1 (baml.Array.push) - 205 pop 1 - 206 jump -197 (to 9) - - 1440 207 load_var 1 (self) - 208 load_field 0 (provider) - 209 load_var 7 (data) - 210 init_instance 4 (ai.errors.ParseFailed .provider, .raw_output) - 211 throw - - 1427 212 load_type 0 - 213 load_var 3 (out) - 214 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 215 call 4 ntypeargs=1 (baml.Array.push) - 216 pop 1 - 217 jump -208 (to 9) - - 1484 218 load_var 3 (out) - 219 return -} - -function openai.internal.ChatStreamDecoder.new(provider: string) -> openai.internal.ChatStreamDecoder { - 1391 0 load_var 1 (provider) - 1 load_type 0 - 2 alloc_array 0 - 3 init_instance 0 (openai.internal.ChatStreamDecoder .provider, .calls) - 4 return -} - -function openai.internal.ChatStreamDecoder.tool_uses(self: openai.internal.ChatStreamDecoder) -> ai.content.ToolUse[] { - 1489 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 1490 3 load_var 1 (self) - 4 load_field 1 (calls) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +30 (to 47) - 18 load_var 4 (_5) - 19 store_var_load_var 5 (buffer) - - 1492 20 load_field 3 (arguments) - 21 call 144 ntypeargs=0 (baml.String.trim) - 22 load_const 6 ("") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +8 (to 33) - - 1495 26 load_var 5 (buffer) - 27 load_field 3 (arguments) - 28 load_var 1 (self) - 29 load_field 0 (provider) - 30 call 1130 ntypeargs=0 (openai.internal._chat_tool_args) - 31 store_var 6 (args) - 32 jump +5 (to 37) - - 1491 33 load_type 7 - 34 load_type 8 - 35 alloc_map 0 - 36 store_var 6 (args) - - 1497 37 load_type 0 - 38 load_var2 2 5 - 39 load_field 1 (id) - 40 load_var 5 (buffer) - 41 load_field 2 (name) - 42 load_var 6 (args) - 43 init_instance 0 (ai.content.ToolUse .id, .name, .args) - 44 call 4 ntypeargs=1 (baml.Array.push) - 45 pop 1 - 46 jump -37 (to 9) - - 1499 47 load_var 2 (out) - 48 return -} - -function openai.internal.ChatTool.baml.ToJson.to_json(self: openai.internal.ChatTool) -> baml.json.json { - 340 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (out) - - 341 4 load_type 0 - 5 load_type 1 - 6 load_var 2 (out) - 7 load_const 2 ("type") - 8 load_var 1 (self) - 9 load_field 0 (type) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 342 12 load_type 3 - 13 load_var 1 (self) - 14 load_field 1 (fn) - 15 call 355 ntypeargs=1 (baml.json.to_json) - 16 store_var 3 (_8) - 17 load_type 0 - 18 load_type 1 - 19 load_var 2 (out) - 20 load_const 4 ("function") - 21 load_var 3 (_8) - 22 call 37 ntypeargs=2 (baml.Map.set) - 23 pop 1 - - 343 24 load_var 2 (out) - 25 return -} - -function openai.internal.ChatToolCall.baml.ToJson.to_json(self: openai.internal.ChatToolCall) -> baml.json.json { - 310 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (out) - - 311 4 load_type 0 - 5 load_type 1 - 6 load_var 2 (out) - 7 load_const 2 ("id") - 8 load_var 1 (self) - 9 load_field 0 (id) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 312 12 load_type 0 - 13 load_type 1 - 14 load_var 2 (out) - 15 load_const 3 ("type") - 16 load_var 1 (self) - 17 load_field 1 (type) - 18 call 37 ntypeargs=2 (baml.Map.set) - 19 pop 1 - - 313 20 load_type 4 - 21 load_var 1 (self) - 22 load_field 2 (fn) - 23 call 355 ntypeargs=1 (baml.json.to_json) - 24 store_var 3 (_12) - 25 load_type 0 - 26 load_type 1 - 27 load_var 2 (out) - 28 load_const 5 ("function") - 29 load_var 3 (_12) - 30 call 37 ntypeargs=2 (baml.Map.set) - 31 pop 1 - - 314 32 load_var 2 (out) - 33 return -} - -function openai.internal.OaStreamState.new() -> openai.internal.OaStreamState { - 977 0 load_const 0 (null) - - 975 1 load_type 1 - 2 load_type 2 - 3 alloc_map 0 - - 976 4 load_type 1 - 5 load_type 1 - 6 alloc_map 0 - 7 init_instance 0 (openai.internal.OaStreamState .model, .text_started, .call_arguments) - 8 return -} - -function openai.internal._azure_reject(detail: string) -> ai.errors.InvalidRequest { - 49 0 load_const 0 ("azure") - 1 load_var 1 (detail) - 2 call 1097 ntypeargs=0 (openai.internal._reject) - 3 return -} - -function openai.internal._chat_all_text(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[]) -> bool { - 632 0 load_const 0 (true) - 1 store_var 2 (all) - - 633 2 load_var 1 (parts) - 3 load_type 1 - 4 load_const 2 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_3) - 7 load_var 3 (_3) - 8 load_type 3 - 9 load_const 4 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_4) - 12 load_var 4 (_4) - 13 is_type 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +10 (to 25) - 16 load_var 4 (_4) - 17 store_var 5 (_8) - - 634 18 load_var 5 (_8) - 19 narrow_bind 6 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump -14 (to 7) - - 637 22 load_const 7 (false) - 23 store_var 2 (all) - - 634 24 jump -17 (to 7) - - 642 25 load_var 2 (all) - 26 return -} - -function openai.internal._chat_apply_directives(j: baml.json.json) -> baml.json.json { - 835 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +16 (to 21) - 6 load_var 1 (j) - 7 store_var 17 (_47) - 8 load_var 17 (_47) - 9 narrow_bind 1 17 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 855 12 load_var 1 (j) - - 835 13 jump +95 (to 108) - - 854 14 load_type 2 - 15 load_type 2 - 16 load_type 3 - - 835 17 load_var 17 (_47) - - 854 18 make_closure 2936 0 - 19 call 16 ntypeargs=3 (baml.Array.map) - 20 jump +88 (to 108) - - 835 21 load_var 2 (_2) - 22 store_var 3 (object) - - 837 23 load_type 4 - 24 load_type 2 - 25 alloc_map 0 - 26 store_var 4 (out) - - 838 27 load_type 4 - 28 load_type 2 - 29 load_var 3 (object) - 30 call 35 ntypeargs=2 (baml.Map.keys) - 31 load_type 5 - 32 load_const 6 ("iter") - 33 virtual_call nargs=1 ntypeargs=0 - 34 store_var 5 (_8) - 35 load_var 5 (_8) - 36 load_type 7 - 37 load_const 8 ("next") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 6 (_9) - 40 load_var 6 (_9) - 41 is_type 9 - 42 pop_jump_if_false +2 (to 44) - 43 jump +21 (to 64) - 44 load_var 6 (_9) - 45 store_var 7 (key) - - 839 46 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 47 store_var 8 (_15) - 48 load_var2 7 8 - 49 cmp_op != - 50 pop_jump_if_false -15 (to 35) - - 840 51 load_type 4 - 52 load_type 2 - 53 load_var2 3 7 - 54 call 38 ntypeargs=2 (baml.Map.get) - 55 call 1118 ntypeargs=0 (openai.internal._chat_apply_directives) - 56 store_var 9 (_18) - 57 load_type 4 - 58 load_type 2 - 59 load_var2 4 7 - 60 load_var 9 (_18) - 61 call 37 ntypeargs=2 (baml.Map.set) - 62 pop 1 - 63 jump -28 (to 35) - - 843 64 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 65 store_var 10 (_26) - 66 load_type 4 - 67 load_type 2 - 68 load_var2 3 10 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 11 (_29) - 71 load_var 11 (_29) - 72 narrow_bind 0 11 - 73 pop_jump_if_false +34 (to 107) - 74 load_var 11 (_29) - 75 store_var 12 (directives) - - 845 76 load_type 4 - 77 load_type 2 - 78 load_var 12 (directives) - 79 call 35 ntypeargs=2 (baml.Map.keys) - 80 load_type 5 - 81 load_const 10 ("iter") - 82 virtual_call nargs=1 ntypeargs=0 - 83 store_var 13 (_34) - 84 load_var 13 (_34) - 85 load_type 7 - 86 load_const 11 ("next") - 87 virtual_call nargs=1 ntypeargs=0 - 88 store_var 14 (_35) - 89 load_var 14 (_35) - 90 is_type 9 - 91 pop_jump_if_false +2 (to 93) - 92 jump +15 (to 107) - 93 load_var 14 (_35) - 94 store_var 15 (key) - - 846 95 load_type 4 - 96 load_type 2 - 97 load_var2 12 15 - 98 call 38 ntypeargs=2 (baml.Map.get) - 99 store_var 16 (_41) - 100 load_type 4 - 101 load_type 2 - 102 load_var2 4 15 - 103 load_var 16 (_41) - 104 call 37 ntypeargs=2 (baml.Map.set) - 105 pop 1 - 106 jump -22 (to 84) - - 852 107 load_var 4 (out) - 108 return -} - -function openai.internal._chat_apply_metadata(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], metadata: map) -> void { - 620 0 load_type 0 - 1 load_type 1 - 2 load_var 2 (metadata) - 3 call 35 ntypeargs=2 (baml.Map.keys) - 4 container_len - 5 store_var 3 (_4) - 6 load_var 3 (_4) - 7 load_const 2 (0) - 8 cmp_int_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +34 (to 44) - - 623 11 load_type 3 - 12 load_var 1 (parts) - 13 call 5 ntypeargs=1 (baml.Array.pop) - 14 store_var 4 (_10) - 15 load_var 4 (_10) - 16 narrow_bind 4 4 - 17 pop_jump_if_false +2 (to 19) - 18 jump +19 (to 37) - 19 load_var 4 (_10) - 20 narrow_bind 5 4 - 21 pop_jump_if_false +2 (to 23) - 22 jump +15 (to 37) - 23 load_var 4 (_10) - 24 narrow_bind 6 4 - 25 pop_jump_if_false +2 (to 27) - 26 jump +11 (to 37) - 27 load_var 4 (_10) - 28 narrow_bind 7 4 - 29 pop_jump_if_false +2 (to 31) - 30 jump +7 (to 37) - 31 load_var 4 (_10) - 32 narrow_bind 8 4 - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - 35 load_const 9 (null) - 36 jump +8 (to 44) - - 624 37 load_type 3 - 38 load_var2 1 4 - - 623 39 load_var 2 (metadata) - 40 init_instance 0 (openai.internal.ChatExtraPart .part, .extra) - - 624 41 call 4 ntypeargs=1 (baml.Array.push) - 42 pop 1 - - 623 43 load_const 9 (null) - 44 return -} - -function openai.internal._chat_audio_format(mime_type: string) -> string { - 493 0 load_var 1 (mime_type) - 1 load_const 0 ("audio/") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 496 5 load_var 1 (mime_type) - 6 store_var 2 (subtype) - - 493 7 jump +9 (to 16) - - 494 8 load_var 1 (mime_type) - 9 call 139 ntypeargs=0 (baml.String.length) - 10 store_var 3 (_4) - 11 load_var 1 (mime_type) - 12 load_const 1 (6) - 13 load_var 3 (_4) - 14 call 153 ntypeargs=0 (baml.String.slice) - 15 store_var 2 (subtype) - - 498 16 load_var 2 (subtype) - 17 load_const 2 ("mpeg") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +17 (to 37) - 21 load_var 2 (subtype) - 22 load_const 3 ("mp3") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +10 (to 35) - 26 load_var 2 (subtype) - 27 load_const 4 ("x-wav") - 28 cmp_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +3 (to 33) - - 501 31 load_var 2 (subtype) - - 498 32 jump +6 (to 38) - - 500 33 load_const 5 ("wav") - - 498 34 jump +4 (to 38) - - 499 35 load_const 6 ("mp3") - - 498 36 jump +2 (to 38) - - 499 37 load_const 7 ("mp3") - 38 return -} - -function openai.internal._chat_audio_output_mime(request_body: baml.json.json | null) -> string { - 512 0 load_type 0 - 1 load_var 1 (request_body) - 2 load_const 1 (".audio.format") - 3 load_const 2 ("wav") - 4 call 364 ntypeargs=1 (baml.json.path_or) - 5 store_var 2 (format) - - 513 6 load_var 2 (format) - 7 load_const 3 ("mp3") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +16 (to 26) - 11 load_var 2 (format) - 12 load_const 4 ("pcm16") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +9 (to 24) - - 516 16 load_type 0 - 17 load_var 2 (format) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 3 (_6) - 20 load_const 5 ("audio/") - 21 load_var 3 (_6) - 22 bin_op + - - 513 23 jump +4 (to 27) - - 515 24 load_const 6 ("audio/pcm") - - 513 25 jump +2 (to 27) - - 514 26 load_const 7 ("audio/mpeg") - 27 return -} - -function openai.internal._chat_body_mentions(overrides: baml.json.json | null, key: string) -> bool { - 894 0 load_var 1 (overrides) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 896 6 load_const 1 (false) - - 894 7 jump +5 (to 12) - - 895 8 load_type 2 - 9 load_type 3 - - 894 10 load_var2 3 2 - - 895 11 call 34 ntypeargs=2 (baml.Map.has) - 12 return -} - -function openai.internal._chat_content(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], collapse: bool) -> string | (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - 647 0 load_var 2 (collapse) - 1 jump_if_false +4 (to 5) - 2 pop 1 - 3 load_var 1 (parts) - 4 call 1113 ntypeargs=0 (openai.internal._chat_all_text) - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - - 660 7 load_var 1 (parts) - 8 jump +38 (to 46) - - 648 9 load_const 0 ("") - 10 store_var 3 (text) - - 649 11 load_var 1 (parts) - 12 load_type 1 - 13 load_const 2 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 4 (_5) - 16 load_var 4 (_5) - 17 load_type 3 - 18 load_const 4 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 5 (_6) - 21 load_var 5 (_6) - 22 is_type 5 - 23 pop_jump_if_false +2 (to 25) - 24 jump +21 (to 45) - 25 load_var 5 (_6) - 26 store_var 6 (_10) - - 650 27 load_var 6 (_10) - 28 narrow_bind 6 6 - 29 pop_jump_if_false -13 (to 16) - 30 load_var 6 (_10) - 31 store_var 7 (t) - - 652 32 load_type 7 - 33 load_var 3 (text) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 8 (_12) - 36 load_type 7 - 37 load_var 7 (t) - 38 load_field 1 (text) - 39 call 138 ntypeargs=1 (baml.String.from) - 40 store_var 9 (_15) - 41 load_var2 8 9 - 42 bin_op + - 43 store_var 3 (text) - - 650 44 jump -28 (to 16) - - 658 45 load_var 3 (text) - 46 return -} - -function openai.internal._chat_directives_key() -> string { - 285 0 load_const 0 ("__baml_directives") - 1 return -} - -function openai.internal._chat_headers(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> map { - 947 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 3 (headers) - - 948 6 load_var 2 (params) - 7 load_field 8 (headers) - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 narrow_bind 3 4 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 4 (_5) - 13 store_var 5 (user_headers) - - 949 14 load_type 2 - 15 load_type 2 - 16 load_var 5 (user_headers) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 6 (_10) - 22 load_var 6 (_10) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 7 (_11) - 27 load_var 7 (_11) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 7 (_11) - 32 store_var 8 (name) - - 950 33 load_var 8 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 9 (_16) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 5 8 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 10 (_18) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 10 (_18) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 3 9 - 49 load_var 10 (_18) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 953 53 load_var 2 (params) - 54 load_field 1 (api_key) - 55 store_var_load_var 11 (key) - - 954 56 load_const 9 (null) - 57 call 672 ntypeargs=0 (baml.ops.equals_equals) - 58 jump_if_false +4 (to 62) - 59 pop 1 - 60 load_var 1 (compat) - 61 load_field 5 (api_key_required) - 62 pop_jump_if_false +2 (to 64) - 63 jump +46 (to 109) - - 960 64 load_var 11 (key) - 65 store_var 16 (_43) - 66 load_var 16 (_43) - 67 narrow_bind 11 16 - 68 pop_jump_if_false +39 (to 107) - 69 load_var 16 (_43) - 70 store_var 17 (credential) - - 961 71 load_var 1 (compat) - 72 load_field 3 (auth) - 73 discriminant - 74 load_const 12 (ChatAuth.Bearer) - 75 cmp_int_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +17 (to 94) - 78 load_var 1 (compat) - 79 load_field 3 (auth) - 80 discriminant - 81 load_const 11 (ChatAuth.ApiKeyHeader) - 82 cmp_int_op == - 83 pop_jump_if_false +2 (to 85) - 84 jump +2 (to 86) - 85 jump +22 (to 107) - - 967 86 load_type 2 - 87 load_type 2 - 88 load_var 3 (headers) - 89 load_const 13 ("api-key") - 90 load_var 17 (credential) - 91 call 37 ntypeargs=2 (baml.Map.set) - 92 pop 1 - 93 jump +14 (to 107) - - 963 94 load_type 2 - 95 load_var 17 (credential) - 96 call 138 ntypeargs=1 (baml.String.from) - 97 store_var 18 (_49) - 98 load_type 2 - 99 load_type 2 - 100 load_var 3 (headers) - 101 load_const 14 ("authorization") - 102 load_const 15 ("Bearer ") - 103 load_var 18 (_49) - 104 bin_op + - 105 call 37 ntypeargs=2 (baml.Map.set) - 106 pop 1 - - 973 107 load_var 3 (headers) - 108 return - - 956 109 load_var 1 (compat) - 110 load_field 0 (provider) - 111 store_var 12 (_31) - - 957 112 load_type 2 - 113 load_var 1 (compat) - 114 load_field 0 (provider) - 115 call 138 ntypeargs=1 (baml.String.from) - 116 store_var 13 (_34) - 117 load_var 1 (compat) - 118 load_field 4 (api_key_env) - 119 store_var_load_var 15 (_39) - 120 load_const 9 (null) - 121 cmp_op == - 122 pop_jump_if_false +3 (to 125) - 123 load_const 16 ("the provider's environment variable") - 124 store_var 15 (_39) - 125 load_type 2 - 126 load_var 15 (_39) - 127 call 138 ntypeargs=1 (baml.String.from) - 128 store_var 14 (_37) - - 955 129 load_var2 12 13 - - 957 130 load_const 17 (" needs an API key: pass api_key, or set ") - 131 bin_op + - 132 load_var 14 (_37) - 133 bin_op + - - 955 134 call 1097 ntypeargs=0 (openai.internal._reject) - 135 throw -} - -function openai.internal._chat_is_opaque_key(key: string) -> bool { - 827 0 load_var 1 (key) - 1 load_const 0 ("parameters") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +6 (to 10) - 5 pop 1 - 6 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 7 store_var 2 (_3) - 8 load_var2 1 2 - 9 cmp_op == - 10 return -} - -function openai.internal._chat_media_block(url: string) -> ai.content.Media { - 1116 0 load_var 1 (url) - 1 load_const 0 ("data:") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +9 (to 12) - - 1117 4 load_var 1 (url) - 5 load_const 1 (";base64,") - 6 call 155 ntypeargs=0 (baml.String.index_of) - 7 store_var 2 (_4) - 8 load_var 2 (_4) - 9 narrow_bind 2 2 - 10 pop_jump_if_false +2 (to 12) - 11 jump +8 (to 19) - - 1126 12 load_var 1 (url) - 13 load_const 3 (null) - 14 call 347 ntypeargs=0 (baml.media.Image.from_url) - 15 load_const 4 () - 16 load_const 4 () - 17 call 904 ntypeargs=0 (ai.content.Media.new) - 18 jump +23 (to 41) - - 1117 19 load_var 2 (_4) - 20 store_var_load_var 3 (separator) - - 1120 21 load_const 5 (8) - 22 add_int - 23 store_var 5 (_8) - 24 load_var 1 (url) - 25 call 139 ntypeargs=0 (baml.String.length) - 26 store_var 6 (_10) - 27 load_var2 1 5 - 28 load_var 6 (_10) - 29 call 153 ntypeargs=0 (baml.String.slice) - 30 store_var 4 (_7) - - 1121 31 load_var 1 (url) - 32 load_const 6 (5) - 33 load_var 3 (separator) - 34 call 153 ntypeargs=0 (baml.String.slice) - 35 store_var 7 (_11) - - 1119 36 load_var2 4 7 - 37 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 1118 38 load_const 4 () - 39 load_const 4 () - 40 call 904 ntypeargs=0 (ai.content.Media.new) - 41 return -} - -function openai.internal._chat_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, compat: openai.internal.ChatCompat) -> openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart { - 524 0 load_var 1 (media) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +111 (to 116) - 6 load_var 1 (media) - 7 store_var 5 (_11) - 8 load_var 5 (_11) - 9 narrow_bind 1 5 - 10 pop_jump_if_false +2 (to 12) - 11 jump +82 (to 93) - 12 load_var 1 (media) - 13 store_var 10 (_22) - 14 load_var 10 (_22) - 15 narrow_bind 2 10 - 16 pop_jump_if_false +2 (to 18) - 17 jump +6 (to 23) - - 577 18 load_var 2 (compat) - 19 load_field 0 (provider) - 20 load_const 3 ("OpenAI Chat Completions has no video input part; extract frames as images, or use the Realtime API") - - 576 21 call 1097 ntypeargs=0 (openai.internal._reject) - 22 throw - - 524 23 load_var 10 (_22) - 24 store_var_load_var 11 (pdf) - - 552 25 load_const 4 (true) - 26 call 933 ntypeargs=0 (ai.wire.resolve_media) - 27 store_var 12 (resolved) - - 556 28 load_var 12 (resolved) - 29 load_field 1 (base64) - 30 store_var 14 (_28) - 31 load_var 14 (_28) - 32 narrow_bind 5 14 - 33 pop_jump_if_false +2 (to 35) - 34 jump +24 (to 58) - - 559 35 load_var 2 (compat) - 36 load_field 0 (provider) - 37 store_var 15 (_31) - - 560 38 load_var 12 (resolved) - 39 load_field 0 (url) - 40 store_var_load_var 17 (_36) - 41 load_const 6 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 7 ("this document") - 45 store_var 17 (_36) - 46 load_type 8 - 47 load_var 17 (_36) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 16 (_34) - - 558 50 load_var 15 (_31) - - 560 51 load_const 9 ("OpenAI Chat Completions has no document-by-URL content part, so a PDF must be inlined, and ") - 52 load_var 16 (_34) - 53 bin_op + - 54 load_const 10 (" is not a URL this client can fetch (gs:// and other non-HTTP schemes are not supported here). Pass the PDF as base64 or a local file.") - 55 bin_op + - - 558 56 call 1097 ntypeargs=0 (openai.internal._reject) - 57 throw - - 556 58 load_var 14 (_28) - 59 store_var 13 (data) - - 570 60 load_var 11 (pdf) - 61 call 323 ntypeargs=0 (baml.media.Pdf.file) - 62 store_var_load_var 19 (_43) - 63 load_const 6 (null) - 64 cmp_op == - 65 pop_jump_if_false +4 (to 69) - 66 load_var 11 (pdf) - 67 call 322 ntypeargs=0 (baml.media.Pdf.url) - 68 store_var 19 (_43) - 69 load_var 19 (_43) - 70 call 1020 ntypeargs=0 (openai.internal._openai_file_name) - 71 store_var 18 (_41) - - 571 72 load_type 8 - 73 load_var 12 (resolved) - 74 load_field 2 (mime_type) - 75 call 138 ntypeargs=1 (baml.String.from) - 76 store_var 20 (_49) - 77 load_type 8 - 78 load_var 13 (data) - 79 call 138 ntypeargs=1 (baml.String.from) - 80 store_var 21 (_52) - - 563 81 load_const 11 ("file") - - 565 82 load_var 18 (_41) - - 571 83 load_const 12 ("data:") - 84 load_var 20 (_49) - 85 bin_op + - 86 load_const 13 (";base64,") - 87 bin_op + - 88 load_var 21 (_52) - 89 bin_op + - 90 init_instance 0 (openai.internal.ChatFileData .filename, .file_data) - 91 init_instance 1 (openai.internal.ChatFilePart .type, .file) - - 524 92 jump +33 (to 125) - 93 load_var 5 (_11) - 94 load_const 4 (true) - - 535 95 call 933 ntypeargs=0 (ai.wire.resolve_media) - 96 store_var 6 (resolved) - - 539 97 load_var 6 (resolved) - 98 load_field 1 (base64) - 99 store_var_load_var 8 (_17) - 100 load_const 6 (null) - 101 cmp_op == - 102 pop_jump_if_false +3 (to 105) - 103 load_const 14 ("") - 104 store_var 8 (_17) - 105 load_var 8 (_17) - 106 store_var 7 (_16) - - 540 107 load_var 6 (resolved) - 108 load_field 2 (mime_type) - 109 call 1108 ntypeargs=0 (openai.internal._chat_audio_format) - 110 store_var 9 (_20) - - 536 111 load_const 15 ("input_audio") - - 538 112 load_var2 7 9 - 113 init_instance 2 (openai.internal.ChatInputAudio .data, .format) - 114 init_instance 3 (openai.internal.ChatAudioPart .type, .input_audio) - - 524 115 jump +10 (to 125) - 116 load_var2 3 2 - - 526 117 load_field 7 (inline_image_urls) - 118 call 933 ntypeargs=0 (ai.wire.resolve_media) - - 529 119 call 1107 ntypeargs=0 (openai.internal._chat_media_url) - 120 store_var 4 (_9) - - 527 121 load_const 16 ("image_url") - - 529 122 load_var 4 (_9) - 123 init_instance 4 (openai.internal.ChatImageUrl .url) - 124 init_instance 5 (openai.internal.ChatImagePart .type, .image_url) - 125 return -} - -function openai.internal._chat_media_url(resolved: ai.wire.ResolvedMedia) -> string { - 482 0 load_var 1 (resolved) - 1 load_field 0 (url) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +26 (to 32) - - 485 7 load_type 1 - 8 load_var 1 (resolved) - 9 load_field 2 (mime_type) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 3 (_7) - 12 load_var 1 (resolved) - 13 load_field 1 (base64) - 14 store_var_load_var 5 (_12) - 15 load_const 2 (null) - 16 cmp_op == - 17 pop_jump_if_false +3 (to 20) - 18 load_const 3 ("") - 19 store_var 5 (_12) - 20 load_type 1 - 21 load_var 5 (_12) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 4 (_10) - 24 load_const 4 ("data:") - 25 load_var 3 (_7) - 26 bin_op + - 27 load_const 5 (";base64,") - 28 bin_op + - 29 load_var 4 (_10) - 30 bin_op + - 31 jump +2 (to 33) - - 482 32 load_var 2 (_3) - 33 return -} - -function openai.internal._chat_percent_encode(value: string) -> string { - 906 0 load_const 0 ("") - 1 store_var 2 (out) - - 907 2 load_var 1 (value) - 3 call 151 ntypeargs=0 (baml.String.chars) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_5) - 8 load_var 3 (_5) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_6) - 13 load_var 4 (_6) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +60 (to 76) - 17 load_var 4 (_6) - 18 store_var 5 (character) - - 905 19 load_const 6 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~") - - 908 20 load_var 5 (character) - 21 call 147 ntypeargs=0 (baml.String.includes) - 22 pop_jump_if_false +2 (to 24) - 23 jump +41 (to 64) - - 911 24 load_var 5 (character) - 25 call 179 ntypeargs=0 (baml.String.to_utf8) - 26 call 196 ntypeargs=0 (baml.Uint8Array.to_hex) - 27 call 143 ntypeargs=0 (baml.String.to_upper_case) - 28 store_var 8 (hex) - - 912 29 load_const 7 (0) - 30 store_var 9 (i) - - 913 31 load_var 9 (i) - 32 store_var 10 (_23) - 33 load_var 8 (hex) - 34 call 139 ntypeargs=0 (baml.String.length) - 35 store_var 11 (_24) - 36 load_var2 10 11 - 37 cmp_int_op < - 38 pop_jump_if_false -30 (to 8) - - 914 39 load_type 8 - 40 load_var 2 (out) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 12 (_26) - 43 load_var2 8 9 - 44 load_var 9 (i) - 45 load_const 9 (2) - 46 add_int - 47 call 153 ntypeargs=0 (baml.String.slice) - 48 store_var 14 (_30) - 49 load_type 8 - 50 load_var 14 (_30) - 51 call 138 ntypeargs=1 (baml.String.from) - 52 store_var 13 (_29) - 53 load_var 12 (_26) - 54 load_const 10 ("%") - 55 bin_op + - 56 load_var 13 (_29) - 57 bin_op + - 58 store_var 2 (out) - - 915 59 load_var 9 (i) - 60 load_const 9 (2) - 61 add_int - 62 store_var 9 (i) - - 913 63 jump -32 (to 31) - - 909 64 load_type 8 - 65 load_var 2 (out) - 66 call 138 ntypeargs=1 (baml.String.from) - 67 store_var 6 (_12) - 68 load_type 8 - 69 load_var 5 (character) - 70 call 138 ntypeargs=1 (baml.String.from) - 71 store_var 7 (_15) - 72 load_var2 6 7 - 73 bin_op + - 74 store_var 2 (out) - - 908 75 jump -67 (to 8) - - 919 76 load_var 2 (out) - 77 return -} - -function openai.internal._chat_prompt_parts(message: ai.PromptMessage, compat: openai.internal.ChatCompat) -> (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - 585 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (parts) - - 586 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +67 (to 84) - 18 load_var 5 (_6) - 19 store_var 6 (part) - - 587 20 load_var 6 (part) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +51 (to 76) - 26 load_var 6 (part) - 27 store_var 8 (_16) - 28 load_var 8 (_16) - 29 narrow_bind 7 8 - 30 pop_jump_if_false +2 (to 32) - 31 jump +37 (to 68) - 32 load_var 6 (part) - 33 store_var 10 (_22) - 34 load_var 10 (_22) - 35 narrow_bind 8 10 - 36 pop_jump_if_false +2 (to 38) - 37 jump +23 (to 60) - 38 load_var 6 (part) - 39 store_var 12 (_28) - 40 load_var 12 (_28) - 41 narrow_bind 9 12 - 42 pop_jump_if_false +2 (to 44) - 43 jump +9 (to 52) - 44 load_var2 6 2 - - 605 45 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 46 store_var 14 (_36) - 47 load_type 0 - 48 load_var2 3 14 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -42 (to 9) - - 587 52 load_var2 12 2 - - 601 53 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 54 store_var 13 (_31) - 55 load_type 0 - 56 load_var2 3 13 - 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - 59 jump -50 (to 9) - - 587 60 load_var2 10 2 - - 597 61 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 62 store_var 11 (_25) - 63 load_type 0 - 64 load_var2 3 11 - 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -58 (to 9) - - 587 68 load_var2 8 2 - - 593 69 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 70 store_var 9 (_19) - 71 load_type 0 - 72 load_var2 3 9 - 73 call 4 ntypeargs=1 (baml.Array.push) - 74 pop 1 - 75 jump -66 (to 9) - - 589 76 load_type 0 - 77 load_var 3 (parts) - 78 load_const 10 ("text") - - 587 79 load_var 7 (_10) - 80 init_instance 0 (openai.internal.ChatTextPart .type, .text) - - 589 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -74 (to 9) - - 610 84 load_var 3 (parts) - 85 return -} - -function openai.internal._chat_prune_nulls(j: baml.json.json) -> baml.json.json { - 865 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +16 (to 21) - 6 load_var 1 (j) - 7 store_var 10 (_31) - 8 load_var 10 (_31) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 886 12 load_var 1 (j) - - 865 13 jump +65 (to 78) - - 885 14 load_type 2 - 15 load_type 2 - 16 load_type 3 - - 865 17 load_var 10 (_31) - - 885 18 make_closure 2942 0 - 19 call 16 ntypeargs=3 (baml.Array.map) - 20 jump +58 (to 78) - - 865 21 load_var 2 (_2) - 22 store_var 3 (object) - - 867 23 load_type 4 - 24 load_type 2 - 25 alloc_map 0 - 26 store_var 4 (out) - - 868 27 load_type 4 - 28 load_type 2 - 29 load_var 3 (object) - 30 call 35 ntypeargs=2 (baml.Map.keys) - 31 load_type 5 - 32 load_const 6 ("iter") - 33 virtual_call nargs=1 ntypeargs=0 - 34 store_var 5 (_8) - 35 load_var 5 (_8) - 36 load_type 7 - 37 load_const 8 ("next") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 6 (_9) - 40 load_var 6 (_9) - 41 is_type 9 - 42 pop_jump_if_false +2 (to 44) - 43 jump +34 (to 77) - 44 load_var 6 (_9) - 45 store_var 7 (key) - - 869 46 load_type 4 - 47 load_type 2 - 48 load_var2 3 7 - 49 call 38 ntypeargs=2 (baml.Map.get) - 50 store_var 8 (value) - - 870 51 load_var 8 (value) - 52 load_const 10 (null) - 53 cmp_op == - 54 pop_jump_if_false +2 (to 56) - 55 jump -20 (to 35) - - 873 56 load_var 7 (key) - 57 call 1117 ntypeargs=0 (openai.internal._chat_is_opaque_key) - 58 pop_jump_if_false +2 (to 60) - 59 jump +11 (to 70) - - 877 60 load_var 8 (value) - 61 call 1119 ntypeargs=0 (openai.internal._chat_prune_nulls) - 62 store_var 9 (_27) - 63 load_type 4 - 64 load_type 2 - 65 load_var2 4 7 - 66 load_var 9 (_27) - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - 69 jump -34 (to 35) - - 874 70 load_type 4 - 71 load_type 2 - 72 load_var2 4 7 - 73 load_var 8 (value) - 74 call 37 ntypeargs=2 (baml.Map.set) - 75 pop 1 - 76 jump -41 (to 35) - - 883 77 load_var 4 (out) - 78 return -} - -function openai.internal._chat_push_tool_uses(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], calls: openai.internal.CcToolCall[], provider: string) -> void { - 1148 0 load_var 2 (calls) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 5 (_5) - 10 load_var 5 (_5) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +74 (to 87) - 14 load_var 5 (_5) - 15 store_var 6 (call) - - 1149 16 load_type 5 - 17 load_type 6 - 18 alloc_map 0 - 19 store_var 7 (empty) - - 1150 20 load_var 6 (call) - 21 load_field 3 (fn) - 22 load_const 7 (null) - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +5 (to 30) - 26 load_var 6 (call) - 27 load_field 3 (fn) - 28 load_field 1 (1) - 29 jump +2 (to 31) - 30 load_const 7 (null) - 31 store_var 9 (_15) - 32 load_var 9 (_15) - 33 narrow_bind 8 9 - 34 pop_jump_if_false +2 (to 36) - 35 jump +4 (to 39) - - 1158 36 load_var 7 (empty) - 37 store_var 8 (args) - - 1150 38 jump +15 (to 53) - 39 load_var 9 (_15) - 40 store_var 10 (raw) - - 1152 41 load_var 10 (raw) - 42 call 144 ntypeargs=0 (baml.String.trim) - 43 load_const 9 ("") - 44 cmp_op == - 45 pop_jump_if_false +2 (to 47) - 46 jump +5 (to 51) - - 1155 47 load_var2 10 3 - 48 call 1130 ntypeargs=0 (openai.internal._chat_tool_args) - 49 store_var 8 (args) - 50 jump +3 (to 53) - - 1153 51 load_var 7 (empty) - 52 store_var 8 (args) - - 1161 53 load_var 6 (call) - 54 load_field 0 (id) - 55 store_var_load_var 12 (_23) - 56 load_const 7 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 10 ("") - 60 store_var 12 (_23) - 61 load_var 12 (_23) - 62 store_var 11 (_22) - 63 load_var 6 (call) - 64 load_field 3 (fn) - 65 load_const 7 (null) - 66 cmp_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +5 (to 73) - 69 load_var 6 (call) - 70 load_field 3 (fn) - 71 load_field 0 (0) - 72 jump +2 (to 74) - 73 load_const 7 (null) - 74 store_var_load_var 13 (_27) - 75 load_const 7 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 11 ("") - 79 store_var 13 (_27) - - 1160 80 load_type 12 - 81 load_var2 1 11 - - 1161 82 load_var2 13 8 - 83 init_instance 0 (ai.content.ToolUse .id, .name, .args) - - 1160 84 call 4 ntypeargs=1 (baml.Array.push) - 85 pop 1 - 86 jump -81 (to 5) - - 1147 87 load_const 7 (null) - 88 return -} - -function openai.internal._chat_send(request: baml.http.Request, provider: string, audio_mime: string) -> ai.ModelTurn { - 0 load_var 3 (audio_mime) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 1285 4 load_const 1 ("audio/wav") - 5 store_var 3 (audio_mime) - - 1287 6 load_var 1 (request) - 7 load_const 0 () - 8 call 250 ntypeargs=0 (baml.http.send) - 9 store_var 4 (response) - 10 jump +18 (to 28) - 11 load_var 5 (e) - 12 throw_if_panic - - 1291 13 load_type 2 - 14 load_var 5 (e) - 15 call 138 ntypeargs=1 (baml.String.from) - 16 store_var 7 (_10) - 17 load_type 3 - 18 load_var 7 (_10) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 6 (_9) - - 1289 21 load_var 2 (provider) - - 1291 22 load_const 4 ("transport failed before a response arrived: ") - 23 load_var 6 (_9) - 24 bin_op + - 25 load_const 5 (null) - 26 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 27 throw - - 1296 28 load_var 4 (response) - 29 sys_op 238 (baml.http.Response.text) - 30 store_var 8 (text) - 31 jump +8 (to 39) - 32 load_var 9 (e) - 33 throw_if_panic - - 1298 34 load_var 2 (provider) - 35 load_const 6 ("the response body could not be read completely") - 36 load_const 5 (null) - 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 38 throw - - 1305 39 load_var 4 (response) - 40 call 240 ntypeargs=0 (baml.http.Response.ok) - 41 unary_op ! - 42 pop_jump_if_false +2 (to 44) - 43 jump +17 (to 60) - - 1316 44 load_var 8 (text) - 45 call 350 ntypeargs=0 (baml.json.parse) - 46 store_var 11 (_24) - 47 load_type 7 - 48 load_var 11 (_24) - 49 call 359 ntypeargs=1 (baml.json.to) - 50 jump +6 (to 56) - 51 load_var 10 (e) - 52 throw_if_panic - - 1317 53 load_var2 2 8 - 54 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 55 throw - - 1319 56 load_var2 2 8 - 57 load_var 3 (audio_mime) - 58 call 1132 ntypeargs=0 (openai.internal.chat_parse) - 59 return - - 1309 60 load_var2 2 4 - - 1311 61 load_field 0 (status_code) - - 1312 62 load_var2 8 4 - - 1313 63 load_field 1 (headers) - - 1309 64 call 977 ntypeargs=0 (ai.errors.classify_http) - 65 throw -} - -function openai.internal._chat_stream_failure(provider: string, detail: string) -> ai.errors.Failure { - 1510 0 load_var 2 (detail) - - 1509 1 load_const 0 ("SSE request failed with status ") - - 1510 2 call 155 ntypeargs=0 (baml.String.index_of) - 3 store_var 3 (_6) - 4 load_var 3 (_6) - 5 narrow_bind 1 3 - 6 pop_jump_if_false +40 (to 46) - 7 load_var 3 (_6) - 8 store_var 6 (_10) - - 1509 9 load_const 2 ("SSE request failed with status ") - - 1511 10 call 139 ntypeargs=0 (baml.String.length) - 11 load_var 6 (_10) - 12 add_int - 13 store_var 5 (_9) - 14 load_var 2 (detail) - 15 call 139 ntypeargs=0 (baml.String.length) - 16 store_var 7 (_12) - 17 load_var2 2 5 - 18 load_var 7 (_12) - 19 call 153 ntypeargs=0 (baml.String.slice) - 20 store_var 4 (rest) - - 1512 21 load_var 4 (rest) - 22 load_const 3 (":") - 23 call 155 ntypeargs=0 (baml.String.index_of) - 24 store_var 8 (_14) - 25 load_var 8 (_14) - 26 narrow_bind 1 8 - 27 pop_jump_if_false +19 (to 46) - 28 load_var 8 (_14) - 29 store_var 9 (colon) - - 1513 30 load_var 4 (rest) - 31 load_const 1 (0) - 32 load_var 9 (colon) - 33 call 153 ntypeargs=0 (baml.String.slice) - 34 call 81 ntypeargs=0 (baml.Int.parse) - 35 store_var 10 (code) - 36 jump +5 (to 41) - 37 load_var 11 (e) - 38 throw_if_panic - - 1514 39 load_const 1 (0) - 40 store_var 10 (code) - - 1516 41 load_var 10 (code) - 42 load_const 1 (0) - 43 cmp_int_op > - 44 pop_jump_if_false +2 (to 46) - 45 jump +12 (to 57) - - 1527 46 load_type 4 - 47 load_var 2 (detail) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 16 (_29) - - 1525 50 load_var 1 (provider) - - 1527 51 load_const 5 ("transport failed before a response arrived: ") - 52 load_var 16 (_29) - 53 bin_op + - 54 load_const 6 (null) - 55 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 56 jump +19 (to 75) - - 1519 57 load_var 10 (code) - 58 store_var 12 (_22) - - 1520 59 load_var 9 (colon) - 60 load_const 7 (1) - 61 add_int - 62 store_var 14 (_25) - 63 load_var 4 (rest) - 64 call 139 ntypeargs=0 (baml.String.length) - 65 store_var 15 (_27) - 66 load_var2 4 14 - 67 load_var 15 (_27) - 68 call 153 ntypeargs=0 (baml.String.slice) - 69 call 144 ntypeargs=0 (baml.String.trim) - 70 store_var 13 (_23) - - 1517 71 load_var2 1 12 - 72 load_var 13 (_23) - 73 load_const 8 () - 74 call 977 ntypeargs=0 (ai.errors.classify_http) - 75 return -} - -function openai.internal._chat_tool_args(raw: string, provider: string) -> map { - 1138 0 load_type 0 - 1 load_var 1 (raw) - 2 call 357 ntypeargs=1 (baml.json.from_string) - 3 jump +6 (to 9) - 4 load_var 3 (e) - 5 throw_if_panic - - 1139 6 load_var2 2 1 - 7 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 8 throw - 9 return -} - -function openai.internal._chat_tools(toolbox: ai.tools.Toolbox) -> openai.internal.ChatTool[] | null { - 978 0 load_var 1 (toolbox) - 1 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 2 pop_jump_if_false +2 (to 4) - 3 jump +44 (to 47) - - 981 4 load_type 0 - 5 alloc_array 0 - 6 store_var 2 (tools) - - 982 7 load_var 1 (toolbox) - 8 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 3 (_5) - 13 load_var 3 (_5) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 4 (_6) - 18 load_var 4 (_6) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +24 (to 45) - 22 load_var 4 (_6) - 23 store_var 5 (tool) - - 987 24 load_var 5 (tool) - 25 load_field 0 (name) - 26 store_var 6 (_13) - - 988 27 load_var 5 (tool) - 28 load_field 1 (description) - 29 store_var 7 (_14) - - 989 30 load_type 6 - 31 load_var 5 (tool) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 store_var 8 (_15) - - 983 35 load_type 0 - 36 load_var 2 (tools) - - 984 37 load_const 7 ("function") - - 986 38 load_var2 6 7 - 39 load_var 8 (_15) - 40 init_instance 0 (openai.internal.ChatToolFunction .name, .description, .parameters) - 41 init_instance 1 (openai.internal.ChatTool .type, .fn) - - 983 42 call 4 ntypeargs=1 (baml.Array.push) - 43 pop 1 - 44 jump -31 (to 13) - - 994 45 load_var 2 (tools) - 46 jump +2 (to 48) - - 979 47 load_const 8 (null) - 48 return -} - -function openai.internal._chat_url(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - 924 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 3 (query) - - 925 4 load_type 0 - 5 load_type 0 - 6 load_var 1 (compat) - 7 load_field 12 (compat_query) - 8 call 35 ntypeargs=2 (baml.Map.keys) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_8) - 13 load_var 4 (_8) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_9) - 18 load_var 5 (_9) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +22 (to 43) - 22 load_var 5 (_9) - 23 store_var 6 (key) - - 926 24 load_type 0 - 25 load_type 0 - 26 load_var 1 (compat) - 27 load_field 12 (compat_query) - 28 load_var 6 (key) - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var_load_var 7 (_16) - 31 load_const 6 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 7 ("") - 35 store_var 7 (_16) - 36 load_type 0 - 37 load_type 0 - 38 load_var2 3 6 - 39 load_var 7 (_16) - 40 call 37 ntypeargs=2 (baml.Map.set) - 41 pop 1 - 42 jump -29 (to 13) - - 928 43 load_var 2 (params) - 44 load_field 9 (query_params) - 45 store_var 8 (_26) - 46 load_var 8 (_26) - 47 narrow_bind 8 8 - 48 pop_jump_if_false +39 (to 87) - 49 load_var 8 (_26) - 50 store_var 9 (user_query) - - 929 51 load_type 0 - 52 load_type 0 - 53 load_var 9 (user_query) - 54 call 35 ntypeargs=2 (baml.Map.keys) - 55 load_type 1 - 56 load_const 9 ("iter") - 57 virtual_call nargs=1 ntypeargs=0 - 58 store_var 10 (_31) - 59 load_var 10 (_31) - 60 load_type 3 - 61 load_const 10 ("next") - 62 virtual_call nargs=1 ntypeargs=0 - 63 store_var 11 (_32) - 64 load_var 11 (_32) - 65 is_type 5 - 66 pop_jump_if_false +2 (to 68) - 67 jump +20 (to 87) - 68 load_var 11 (_32) - 69 store_var 12 (key) - - 930 70 load_type 0 - 71 load_type 0 - 72 load_var2 9 12 - 73 call 38 ntypeargs=2 (baml.Map.get) - 74 store_var_load_var 13 (_39) - 75 load_const 6 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 11 ("") - 79 store_var 13 (_39) - 80 load_type 0 - 81 load_type 0 - 82 load_var2 3 12 - 83 load_var 13 (_39) - 84 call 37 ntypeargs=2 (baml.Map.set) - 85 pop 1 - 86 jump -27 (to 59) - - 933 87 load_type 0 - 88 load_var 1 (compat) - 89 load_field 1 (base_url) - 90 call 138 ntypeargs=1 (baml.String.from) - 91 store_var 15 (_48) - 92 load_type 0 - 93 load_var 1 (compat) - 94 load_field 2 (path) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 16 (_51) - 97 load_var2 15 16 - 98 bin_op + - 99 store_var 14 (url) - - 934 100 load_type 0 - 101 load_type 0 - 102 load_var 3 (query) - 103 call 35 ntypeargs=2 (baml.Map.keys) - 104 container_len - 105 store_var 17 (_55) - 106 load_var 17 (_55) - 107 load_const 12 (0) - 108 cmp_int_op == - 109 pop_jump_if_false +2 (to 111) - 110 jump +74 (to 184) - - 937 111 load_type 0 - 112 alloc_array 0 - 113 store_var 18 (pairs) - - 938 114 load_type 0 - 115 load_type 0 - 116 load_var 3 (query) - 117 call 35 ntypeargs=2 (baml.Map.keys) - 118 load_type 1 - 119 load_const 13 ("iter") - 120 virtual_call nargs=1 ntypeargs=0 - 121 store_var 19 (_63) - 122 load_var 19 (_63) - 123 load_type 3 - 124 load_const 14 ("next") - 125 virtual_call nargs=1 ntypeargs=0 - 126 store_var 20 (_64) - 127 load_var 20 (_64) - 128 is_type 5 - 129 pop_jump_if_false +2 (to 131) - 130 jump +35 (to 165) - 131 load_var 20 (_64) - 132 store_var_load_var 21 (key) - - 939 133 call 1121 ntypeargs=0 (openai.internal._chat_percent_encode) - 134 store_var 23 (_72) - 135 load_type 0 - 136 load_var 23 (_72) - 137 call 138 ntypeargs=1 (baml.String.from) - 138 store_var 22 (_71) - 139 load_type 0 - 140 load_type 0 - 141 load_var2 3 21 - 142 call 38 ntypeargs=2 (baml.Map.get) - 143 store_var_load_var 26 (_78) - 144 load_const 6 (null) - 145 cmp_op == - 146 pop_jump_if_false +3 (to 149) - 147 load_const 15 ("") - 148 store_var 26 (_78) - 149 load_var 26 (_78) - 150 call 1121 ntypeargs=0 (openai.internal._chat_percent_encode) - 151 store_var 25 (_76) - 152 load_type 0 - 153 load_var 25 (_76) - 154 call 138 ntypeargs=1 (baml.String.from) - 155 store_var 24 (_75) - 156 load_type 0 - 157 load_var2 18 22 - 158 load_const 16 ("=") - 159 bin_op + - 160 load_var 24 (_75) - 161 bin_op + - 162 call 4 ntypeargs=1 (baml.Array.push) - 163 pop 1 - 164 jump -42 (to 122) - - 941 165 load_type 0 - 166 load_var 14 (url) - 167 call 138 ntypeargs=1 (baml.String.from) - 168 store_var 27 (_87) - 169 load_type 0 - 170 load_var 18 (pairs) - 171 load_const 17 ("&") - 172 call 15 ntypeargs=1 (baml.Array.join) - 173 store_var 29 (_91) - 174 load_type 0 - 175 load_var 29 (_91) - 176 call 138 ntypeargs=1 (baml.String.from) - 177 store_var 28 (_90) - 178 load_var 27 (_87) - 179 load_const 18 ("?") - 180 bin_op + - 181 load_var 28 (_90) - 182 bin_op + - 183 jump +2 (to 185) - - 935 184 load_var 14 (url) - 185 return -} - -function openai.internal._oai_images_block(datum: openai.internal.OaImageDatum, mime: string) -> ai.content.Media | null { - 348 0 load_var 1 (datum) - 1 load_field 0 (b64_json) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +17 (to 23) - - 354 7 load_var 1 (datum) - 8 load_field 1 (url) - 9 store_var 4 (_10) - 10 load_var 4 (_10) - 11 narrow_bind 0 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +3 (to 16) - - 360 14 load_const 1 (null) - 15 jump +14 (to 29) - - 354 16 load_var2 4 2 - - 356 17 call 1152 ntypeargs=0 (openai.internal._oai_images_fetch_inline) - - 355 18 load_const 2 () - - 357 19 load_var 1 (datum) - 20 load_field 2 (revised_prompt) - - 355 21 call 904 ntypeargs=0 (ai.content.Media.new) - 22 jump +7 (to 29) - - 348 23 load_var2 3 2 - - 350 24 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 349 25 load_const 2 () - - 351 26 load_var 1 (datum) - 27 load_field 2 (revised_prompt) - - 349 28 call 904 ntypeargs=0 (ai.content.Media.new) - 29 return -} - -function openai.internal._oai_images_client_id(c: openai.ImageClient) -> string { - 88 0 load_type 0 - 1 load_var 1 (c) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_3) - 5 load_const 1 ("openai-images/") - 6 load_var 2 (_3) - 7 bin_op + - 8 return -} - -function openai.internal._oai_images_drop_nulls(value: baml.json.json) -> baml.json.json { - 97 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +36 (to 41) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 119 12 load_var 1 (value) - - 97 13 jump +74 (to 87) - - 113 14 load_type 2 - 15 alloc_array 0 - 16 store_var 11 (out) - - 97 17 load_var 10 (_24) - 18 load_type 3 - 19 load_const 4 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 12 (_28) - - 114 22 load_var 12 (_28) - 23 load_type 5 - 24 load_const 6 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 13 (_29) - 27 load_var 13 (_29) - 28 is_type 7 - 29 pop_jump_if_false +2 (to 31) - 30 jump +9 (to 39) - 31 load_var 13 (_29) - - 115 32 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - 33 store_var 14 (_34) - 34 load_type 2 - 35 load_var2 11 14 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -16 (to 22) - - 117 39 load_var 11 (out) - - 97 40 jump +47 (to 87) - 41 load_var 2 (_2) - 42 store_var 3 (object) - - 99 43 load_type 8 - 44 load_type 2 - 45 alloc_map 0 - 46 store_var 4 (out) - - 100 47 load_type 8 - 48 load_type 2 - 49 load_var 3 (object) - 50 call 35 ntypeargs=2 (baml.Map.keys) - 51 load_type 9 - 52 load_const 10 ("iter") - 53 virtual_call nargs=1 ntypeargs=0 - 54 store_var 5 (_8) - 55 load_var 5 (_8) - 56 load_type 11 - 57 load_const 12 ("next") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 6 (_9) - 60 load_var 6 (_9) - 61 is_type 7 - 62 pop_jump_if_false +2 (to 64) - 63 jump +23 (to 86) - 64 load_var 6 (_9) - 65 store_var 7 (key) - - 101 66 load_type 8 - 67 load_type 2 - 68 load_var2 3 7 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 8 (entry) - - 102 71 load_var 8 (entry) - 72 load_const 13 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump -20 (to 55) - - 105 76 load_var 8 (entry) - 77 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - 78 store_var 9 (_20) - 79 load_type 8 - 80 load_type 2 - 81 load_var2 4 7 - 82 load_var 9 (_20) - 83 call 37 ntypeargs=2 (baml.Map.set) - 84 pop 1 - 85 jump -30 (to 55) - - 110 86 load_var 4 (out) - 87 return -} - -function openai.internal._oai_images_escape_query(raw: string) -> string { - 213 0 load_var 1 (raw) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("&") - 8 load_const 5 ("%26") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("=") - 11 load_const 7 ("%3D") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("?") - 14 load_const 9 ("%3F") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("#") - 17 load_const 11 ("%23") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - - 220 19 return -} - -function openai.internal._oai_images_fetch_inline(location: string, fallback_mime: string) -> image { - 322 0 load_var 1 (location) - 1 load_const 0 () - 2 call 248 ntypeargs=0 (baml.http.fetch) - 3 store_var 3 (response) - 4 jump +26 (to 30) - 5 load_var 4 (e) - 6 throw_if_panic - - 325 7 load_type 1 - 8 load_var 1 (location) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 store_var 5 (_9) - 11 load_type 2 - 12 load_var 4 (e) - 13 call 138 ntypeargs=1 (baml.String.from) - 14 store_var 7 (_12) - 15 load_type 1 - 16 load_var 7 (_12) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 6 (_11) - - 323 19 load_const 3 ("openai-images") - - 325 20 load_const 4 ("fetching the generated image at ") - 21 load_var 5 (_9) - 22 bin_op + - 23 load_const 5 (" failed: ") - 24 bin_op + - 25 load_var 6 (_11) - 26 bin_op + - 27 load_const 6 (null) - 28 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 29 throw - - 329 30 load_var 3 (response) - 31 call 240 ntypeargs=0 (baml.http.Response.ok) - 32 unary_op ! - 33 pop_jump_if_false +2 (to 35) - 34 jump +47 (to 81) - - 336 35 load_type 1 - 36 load_type 1 - 37 load_var 3 (response) - 38 load_field 1 (headers) - 39 load_const 7 ("content-type") - 40 call 38 ntypeargs=2 (baml.Map.get) - 41 store_var_load_var 13 (_31) - 42 load_const 6 (null) - 43 cmp_op == - 44 pop_jump_if_false +3 (to 47) - 45 load_const 8 ("") - 46 store_var 13 (_31) - 47 load_var 13 (_31) - 48 load_const 9 (";") - 49 call 150 ntypeargs=0 (baml.String.split) - 50 store_var 12 (_29) - 51 load_type 1 - 52 load_var 12 (_29) - 53 load_const 10 (0) - 54 call 3 ntypeargs=1 (baml.Array.at) - 55 store_var_load_var 11 (_27) - 56 load_const 6 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 11 ("") - 60 store_var 11 (_27) - 61 load_var 11 (_27) - 62 store_var 10 (reported) - - 337 63 load_var 10 (reported) - 64 call 144 ntypeargs=0 (baml.String.trim) - 65 load_const 12 ("") - 66 cmp_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +5 (to 73) - - 340 69 load_var 10 (reported) - 70 call 144 ntypeargs=0 (baml.String.trim) - 71 store_var 14 (mime) - 72 jump +3 (to 75) - - 338 73 load_var 2 (fallback_mime) - 74 store_var 14 (mime) - - 342 75 load_var 3 (response) - 76 sys_op 239 (baml.http.Response.bytes) - 77 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 78 load_var 14 (mime) - 79 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 80 return - - 332 81 load_type 1 - 82 load_var 1 (location) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 8 (_21) - 85 load_type 13 - 86 load_var 3 (response) - 87 load_field 0 (status_code) - 88 call 138 ntypeargs=1 (baml.String.from) - 89 store_var 9 (_23) - - 330 90 load_const 14 ("openai-images") - - 332 91 load_const 15 ("fetching the generated image at ") - 92 load_var 8 (_21) - 93 bin_op + - 94 load_const 16 (" returned HTTP ") - 95 bin_op + - 96 load_var 9 (_23) - 97 bin_op + - 98 load_const 6 (null) - 99 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 100 throw -} - -function openai.internal._oai_images_headers(c: openai.ImageClient) -> map { - 247 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 2 (headers) - - 248 6 load_var 1 (c) - 7 load_field 14 (headers) - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 narrow_bind 3 3 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 3 (_4) - 13 store_var 4 (extra) - - 249 14 load_type 2 - 15 load_type 2 - 16 load_var 4 (extra) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 5 (_9) - 22 load_var 5 (_9) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 6 (_10) - 27 load_var 6 (_10) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 6 (_10) - 32 store_var 7 (name) - - 250 33 load_var 7 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 8 (_15) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 4 7 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 9 (_17) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 9 (_17) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 2 8 - 49 load_var 9 (_17) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 253 53 load_var 1 (c) - 54 call 1093 ntypeargs=0 (openai.ImageClient.resolved_api_key) - 55 store_var 11 (_28) - 56 load_type 2 - 57 load_var 11 (_28) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 10 (_27) - 60 load_type 2 - 61 load_type 2 - 62 load_var 2 (headers) - 63 load_const 11 ("authorization") - 64 load_const 12 ("Bearer ") - 65 load_var 10 (_27) - 66 bin_op + - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - - 254 69 load_var 2 (headers) - 70 return -} - -function openai.internal._oai_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - 127 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 2 (_4) - - 128 4 load_const 1 ("openai-images") - 5 load_const 2 (null) - - 127 6 load_const 3 ("Images API only supports text prompts; found ") - 7 load_var 2 (_4) - 8 bin_op + - 9 load_const 4 (" input") - 10 bin_op + - 11 load_const 2 (null) - 12 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 13 return -} - -function openai.internal._oai_images_mime(format: string | null) -> string { - 307 0 load_var 1 (format) - 1 store_var_load_var 3 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("png") - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 call 142 ntypeargs=0 (baml.String.to_lower_case) - 9 store_var 2 (normalized) - - 308 10 load_var 2 (normalized) - 11 load_const 2 ("jpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 2 (normalized) - 16 load_const 3 ("jpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 2 (normalized) - 21 load_const 4 ("webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - 25 load_var 2 (normalized) - 26 load_const 5 ("gif") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +3 (to 32) - - 312 30 load_const 6 ("image/png") - - 308 31 jump +8 (to 39) - - 311 32 load_const 7 ("image/gif") - - 308 33 jump +6 (to 39) - - 310 34 load_const 8 ("image/webp") - - 308 35 jump +4 (to 39) - - 309 36 load_const 9 ("image/jpeg") - - 308 37 jump +2 (to 39) - - 309 38 load_const 10 ("image/jpeg") - 39 return -} - -function openai.internal._oai_images_prompt_text(prompt: ai.Prompt, journal: ai.Journal) -> string { - 142 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (parts) - - 143 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +66 (to 83) - 18 load_var 5 (_6) - 19 load_field 2 (parts) - 20 load_type 6 - 21 load_const 7 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 6 (_11) - - 144 24 load_var 6 (_11) - 25 load_type 8 - 26 load_const 9 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 7 (_12) - 29 load_var 7 (_12) - 30 is_type 5 - 31 pop_jump_if_false +2 (to 33) - 32 jump -23 (to 9) - 33 load_var 7 (_12) - 34 store_var 8 (part) - - 145 35 load_var 8 (part) - 36 store_var 9 (_16) - 37 load_var 9 (_16) - 38 narrow_bind 10 9 - 39 pop_jump_if_false +2 (to 41) - 40 jump +31 (to 71) - 41 load_var 8 (part) - 42 store_var 11 (_24) - 43 load_var 11 (_24) - 44 narrow_bind 11 11 - 45 pop_jump_if_false +2 (to 47) - 46 jump +22 (to 68) - 47 load_var 8 (part) - 48 store_var 12 (_26) - 49 load_var 12 (_26) - 50 narrow_bind 12 12 - 51 pop_jump_if_false +2 (to 53) - 52 jump +13 (to 65) - 53 load_var 8 (part) - 54 store_var 13 (_28) - 55 load_var 13 (_28) - 56 narrow_bind 13 13 - 57 pop_jump_if_false +2 (to 59) - 58 jump +4 (to 62) - - 163 59 load_const 14 ("pdf") - 60 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 61 throw - - 160 62 load_const 15 ("video") - 63 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 64 throw - - 157 65 load_const 16 ("audio") - 66 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 67 throw - - 154 68 load_const 17 ("image") - 69 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 70 throw - - 145 71 load_var 9 (_16) - - 147 72 call 144 ntypeargs=0 (baml.String.trim) - 73 store_var 10 (trimmed) - - 148 74 load_var 10 (trimmed) - 75 load_const 18 ("") - 76 cmp_op != - 77 pop_jump_if_false -53 (to 24) - - 149 78 load_type 0 - 79 load_var2 3 10 - 80 call 4 ntypeargs=1 (baml.Array.push) - 81 pop 1 - 82 jump -58 (to 24) - - 168 83 load_var 2 (journal) - 84 call 905 ntypeargs=0 (ai.Journal.entries) - 85 load_type 19 - 86 load_const 20 ("iter") - 87 virtual_call nargs=1 ntypeargs=0 - 88 store_var 14 (_32) - 89 load_var 14 (_32) - 90 load_type 21 - 91 load_const 22 ("next") - 92 virtual_call nargs=1 ntypeargs=0 - 93 store_var 15 (_33) - 94 load_var 15 (_33) - 95 is_type 5 - 96 pop_jump_if_false +2 (to 98) - 97 jump +19 (to 116) - 98 load_var 15 (_33) - 99 store_var 16 (_37) - - 169 100 load_var 16 (_37) - 101 narrow_bind 23 16 - 102 pop_jump_if_false -13 (to 89) - 103 load_var 16 (_37) - 104 load_field 0 (content) - - 170 105 call 144 ntypeargs=0 (baml.String.trim) - 106 store_var 17 (trimmed) - - 171 107 load_var 17 (trimmed) - 108 load_const 24 ("") - 109 cmp_op != - 110 pop_jump_if_false -21 (to 89) - - 172 111 load_type 0 - 112 load_var2 3 17 - 113 call 4 ntypeargs=1 (baml.Array.push) - 114 pop 1 - 115 jump -26 (to 89) - - 176 116 load_type 0 - 117 load_var 3 (parts) - 118 load_const 25 ("\n\n") - 119 call 15 ntypeargs=1 (baml.Array.join) - 120 store_var 18 (joined) - - 177 121 load_var 18 (joined) - 122 load_const 26 ("") - 123 cmp_op == - 124 pop_jump_if_false +2 (to 126) - 125 jump +3 (to 128) - - 185 126 load_var 18 (joined) - 127 return - - 178 128 load_const 27 ("openai-images") - 129 load_const 28 (null) - 130 load_const 29 ("Images API request requires a text prompt") - 131 load_const 28 (null) - 132 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 133 throw -} - -function openai.internal._oai_images_response_format(model: string, explicit: string | null) -> string | null { - 193 0 load_var 2 (explicit) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +10 (to 15) - - 196 6 load_var 1 (model) - 7 load_const 1 ("gpt-image") - 8 call 148 ntypeargs=0 (baml.String.starts_with) - 9 pop_jump_if_false +2 (to 11) - 10 jump +3 (to 13) - - 199 11 load_const 2 ("b64_json") - 12 jump +4 (to 16) - - 197 13 load_const 3 (null) - 14 jump +2 (to 16) - - 193 15 load_var 3 (_3) - 16 return -} - -function openai.internal._oai_images_trim_slash(url: string) -> string { - 203 0 load_var 1 (url) - 1 load_const 0 ("/") - 2 call 149 ntypeargs=0 (baml.String.ends_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 206 5 load_var 1 (url) - 6 jump +10 (to 16) - - 204 7 load_var 1 (url) - 8 call 139 ntypeargs=0 (baml.String.length) - 9 store_var 2 (_4) - 10 load_var 1 (url) - 11 load_const 1 (0) - 12 load_var 2 (_4) - 13 load_const 2 (1) - 14 sub_int - 15 call 153 ntypeargs=0 (baml.String.slice) - 16 return -} - -function openai.internal._oai_images_with_query(url: string, params: map | null) -> string { - 224 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (pairs) - - 225 3 load_var 2 (params) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +54 (to 61) - 8 load_var 4 (_4) - 9 store_var 5 (configured) - - 226 10 load_type 0 - 11 load_type 0 - 12 load_var 5 (configured) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_9) - 18 load_var 6 (_9) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_10) - 23 load_var 7 (_10) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +35 (to 61) - 27 load_var 7 (_10) - 28 store_var_load_var 8 (key) - - 228 29 call 1147 ntypeargs=0 (openai.internal._oai_images_escape_query) - 30 store_var 10 (_18) - 31 load_type 0 - 32 load_var 10 (_18) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 9 (_17) - 35 load_type 0 - 36 load_type 0 - 37 load_var2 5 8 - 38 call 38 ntypeargs=2 (baml.Map.get) - 39 store_var_load_var 13 (_24) - 40 load_const 7 (null) - 41 cmp_op == - 42 pop_jump_if_false +3 (to 45) - 43 load_const 8 ("") - 44 store_var 13 (_24) - 45 load_var 13 (_24) - 46 call 1147 ntypeargs=0 (openai.internal._oai_images_escape_query) - 47 store_var 12 (_22) - 48 load_type 0 - 49 load_var 12 (_22) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 11 (_21) - - 227 52 load_type 0 - 53 load_var2 3 9 - - 228 54 load_const 9 ("=") - 55 bin_op + - 56 load_var 11 (_21) - 57 bin_op + - - 227 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -42 (to 18) - - 232 61 load_var 3 (pairs) - 62 container_len - 63 store_var 14 (_33) - 64 load_var 14 (_33) - 65 load_const 10 (0) - 66 cmp_int_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - - 235 69 load_var 1 (url) - 70 load_const 11 ("?") - 71 call 147 ntypeargs=0 (baml.String.includes) - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 238 74 load_const 12 ("?") - 75 store_var 15 (separator) - - 235 76 jump +3 (to 79) - - 236 77 load_const 13 ("&") - 78 store_var 15 (separator) - - 240 79 load_type 0 - 80 load_var 1 (url) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 16 (_37) - 83 load_type 0 - 84 load_var 15 (separator) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 17 (_39) - 87 load_type 0 - 88 load_var 3 (pairs) - 89 load_const 14 ("&") - 90 call 15 ntypeargs=1 (baml.Array.join) - 91 store_var 19 (_43) - 92 load_type 0 - 93 load_var 19 (_43) - 94 call 138 ntypeargs=1 (baml.String.from) - 95 store_var 18 (_42) - 96 load_var2 16 17 - 97 bin_op + - 98 load_var 18 (_42) - 99 bin_op + - 100 jump +2 (to 102) - - 233 101 load_var 1 (url) - 102 return -} - -function openai.internal._openai_apply_message_metadata(body: baml.json.json, metadata: map[]) -> baml.json.json { - 497 0 load_var 1 (body) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +51 (to 55) - - 499 5 load_type 1 - 6 load_type 2 - - 497 7 load_var 3 (_3) - 8 load_const 3 ("input") - - 499 9 call 38 ntypeargs=2 (baml.Map.get) - 10 store_var 4 (_8) - 11 load_var 4 (_8) - 12 narrow_bind 4 4 - 13 pop_jump_if_false +42 (to 55) - 14 load_var 4 (_8) - 15 store_var 5 (items) - - 501 16 load_const 5 (0) - 17 store_var 6 (index) - - 502 18 load_var 2 (metadata) - 19 load_type 6 - 20 load_const 7 ("iter") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_11) - 23 load_var 7 (_11) - 24 load_type 8 - 25 load_const 9 ("next") - 26 virtual_call nargs=1 ntypeargs=0 - 27 store_var 8 (_12) - 28 load_var 8 (_12) - 29 is_type 10 - 30 pop_jump_if_false +2 (to 32) - 31 jump +24 (to 55) - 32 load_var 8 (_12) - 33 store_var 9 (directives) - - 503 34 load_type 1 - 35 load_type 2 - 36 load_var 9 (directives) - 37 call 35 ntypeargs=2 (baml.Map.keys) - 38 container_len - 39 store_var 10 (_17) - 40 load_var 10 (_17) - 41 load_const 5 (0) - 42 cmp_int_op > - 43 pop_jump_if_false +7 (to 50) - - 504 44 load_type 2 - 45 load_var2 5 6 - 46 call 3 ntypeargs=1 (baml.Array.at) - 47 load_var 9 (directives) - 48 call 1026 ntypeargs=0 (openai.internal._openai_merge_onto_last_part) - 49 pop 1 - - 506 50 load_var 6 (index) - 51 load_const 11 (1) - 52 add_int - 53 store_var 6 (index) - - 502 54 jump -31 (to 23) - - 516 55 load_var 1 (body) - 56 return -} - -function openai.internal._openai_audio_format(mime_type: string) -> string { - 327 0 load_var 1 (mime_type) - 1 load_const 0 ("audio/wav") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +52 (to 56) - 5 load_var 1 (mime_type) - 6 load_const 1 ("audio/x-wav") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +45 (to 54) - 10 load_var 1 (mime_type) - 11 load_const 2 ("audio/mpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +38 (to 52) - 15 load_var 1 (mime_type) - 16 load_const 3 ("audio/mp3") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +31 (to 50) - 20 load_var 1 (mime_type) - 21 load_const 4 ("audio/flac") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +24 (to 48) - 25 load_var 1 (mime_type) - 26 load_const 5 ("audio/x-flac") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +17 (to 46) - 30 load_var 1 (mime_type) - 31 load_const 6 ("audio/ogg") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +10 (to 44) - 35 load_var 1 (mime_type) - 36 load_const 7 ("audio/webm") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +3 (to 42) - - 333 40 load_var 1 (mime_type) - - 327 41 jump +16 (to 57) - - 332 42 load_const 8 ("webm") - - 327 43 jump +14 (to 57) - - 331 44 load_const 9 ("ogg") - - 327 45 jump +12 (to 57) - - 330 46 load_const 10 ("flac") - - 327 47 jump +10 (to 57) - - 330 48 load_const 11 ("flac") - - 327 49 jump +8 (to 57) - - 329 50 load_const 12 ("mp3") - - 327 51 jump +6 (to 57) - - 329 52 load_const 13 ("mp3") - - 327 53 jump +4 (to 57) - - 328 54 load_const 14 ("wav") - - 327 55 jump +2 (to 57) - - 328 56 load_const 15 ("wav") - 57 return -} - -function openai.internal._openai_decode_batch(batch: string, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1098 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 1099 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +41 (to 58) - 18 load_var 5 (_6) - 19 store_var_load_var 6 (raw) - - 1100 20 load_field 1 (data) - 21 store_var 7 (_11) - 22 load_var 7 (_11) - 23 narrow_bind 6 7 - 24 pop_jump_if_false -15 (to 9) - - 1101 25 load_type 7 - - 1100 26 load_var 7 (_11) - - 1101 27 call 357 ntypeargs=1 (baml.json.from_string) - 28 jump +4 (to 32) - 29 load_var 8 (e) - 30 throw_if_panic - - 1102 31 load_const 8 (null) - - 1104 32 store_var 9 (_17) - 33 load_var 9 (_17) - 34 narrow_bind 9 9 - 35 pop_jump_if_false -26 (to 9) - 36 load_var2 9 6 - - 1105 37 load_field 0 (event) - 38 load_var 2 (state) - 39 call 1047 ntypeargs=0 (openai.internal._openai_stream_events) - 40 load_type 10 - 41 load_const 11 ("iter") - 42 virtual_call nargs=1 ntypeargs=0 - 43 store_var 10 (_22) - 44 load_var 10 (_22) - 45 load_type 12 - 46 load_const 13 ("next") - 47 virtual_call nargs=1 ntypeargs=0 - 48 store_var 11 (_23) - 49 load_var 11 (_23) - 50 is_type 5 - 51 pop_jump_if_false +2 (to 53) - 52 jump -43 (to 9) - - 1106 53 load_type 0 - 54 load_var2 3 11 - 55 call 4 ntypeargs=1 (baml.Array.push) - 56 pop 1 - 57 jump -13 (to 44) - - 1112 58 load_var 3 (out) - 59 return -} - -function openai.internal._openai_error_failure(err: openai.internal.OaErrorBody) -> ai.errors.Failure { - 785 0 load_var 1 (err) - 1 load_field 0 (code) - 2 store_var_load_var 4 (_6) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("") - 7 store_var 4 (_6) - 8 load_var 4 (_6) - 9 load_const 2 (" ") - 10 bin_op + - 11 store_var 3 (_4) - 12 load_var 1 (err) - 13 load_field 2 (type) - 14 store_var_load_var 5 (_10) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +3 (to 20) - 18 load_const 3 ("") - 19 store_var 5 (_10) - 20 load_var2 3 5 - 21 bin_op + - 22 call 142 ntypeargs=0 (baml.String.to_lower_case) - 23 store_var 2 (code) - - 786 24 load_var 1 (err) - 25 load_field 1 (message) - 26 store_var_load_var 7 (_14) - 27 load_const 0 (null) - 28 cmp_op == - 29 pop_jump_if_false +3 (to 32) - 30 load_const 4 ("the OpenAI Responses request failed") - 31 store_var 7 (_14) - 32 load_var 7 (_14) - 33 store_var 6 (detail) - - 787 34 load_type 5 - 35 load_var 1 (err) - 36 call 355 ntypeargs=1 (baml.json.to_json) - 37 call 351 ntypeargs=0 (baml.json.stringify) - 38 store_var 8 (raw) - - 788 39 load_var 2 (code) - 40 load_const 6 ("rate_limit") - 41 call 147 ntypeargs=0 (baml.String.includes) - 42 jump_if_false +2 (to 44) - 43 jump +5 (to 48) - 44 pop 1 - 45 load_var 2 (code) - 46 load_const 7 ("quota") - 47 call 147 ntypeargs=0 (baml.String.includes) - 48 jump_if_false +2 (to 50) - 49 jump +5 (to 54) - 50 pop 1 - 51 load_var 2 (code) - 52 load_const 8 ("credit_balance") - 53 call 147 ntypeargs=0 (baml.String.includes) - 54 pop_jump_if_false +2 (to 56) - 55 jump +35 (to 90) - - 790 56 load_var 2 (code) - 57 load_const 9 ("content_filter") - 58 call 147 ntypeargs=0 (baml.String.includes) - 59 jump_if_false +2 (to 61) - 60 jump +5 (to 65) - 61 pop 1 - 62 load_var 2 (code) - 63 load_const 10 ("moderation") - 64 call 147 ntypeargs=0 (baml.String.includes) - 65 jump_if_false +2 (to 67) - 66 jump +5 (to 71) - 67 pop 1 - 68 load_var 2 (code) - 69 load_const 11 ("refusal") - 70 call 147 ntypeargs=0 (baml.String.includes) - 71 pop_jump_if_false +2 (to 73) - 72 jump +14 (to 86) - - 792 73 load_var 2 (code) - 74 call 1039 ntypeargs=0 (openai.internal._openai_transient_code) - 75 pop_jump_if_false +2 (to 77) - 76 jump +6 (to 82) - - 795 77 load_const 12 ("openai") - 78 load_const 0 (null) - - 798 79 load_var2 6 8 - - 799 80 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 792 81 jump +13 (to 94) - - 793 82 load_const 13 ("openai") - 83 load_var2 6 8 - 84 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 792 85 jump +9 (to 94) - - 791 86 load_const 14 ("openai") - 87 load_var2 6 8 - 88 init_instance 2 (ai.errors.Refused .provider, .reason, .raw_body) - - 790 89 jump +5 (to 94) - - 789 90 load_const 15 ("openai") - 91 load_const 0 (null) - 92 load_var 8 (raw) - 93 init_instance 3 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 94 return -} - -function openai.internal._openai_event_key(event: openai.internal.OaStreamEvent) -> string { - 987 0 load_var 1 (event) - 1 load_field 4 (item_id) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +20 (to 26) - - 989 7 load_var 1 (event) - 8 load_field 5 (output_index) - 9 store_var 4 (_7) - 10 load_var 4 (_7) - 11 narrow_bind 1 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +4 (to 17) - - 992 14 load_const 2 ("") - 15 store_var 2 (item) - - 989 16 jump +12 (to 28) - - 990 17 load_type 3 - - 989 18 load_var 4 (_7) - - 990 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 5 (_9) - 21 load_const 4 ("#") - 22 load_var 5 (_9) - 23 bin_op + - 24 store_var 2 (item) - - 989 25 jump +3 (to 28) - - 987 26 load_var 3 (_4) - 27 store_var 2 (item) - - 994 28 load_var 1 (event) - 29 load_field 6 (content_index) - 30 store_var 6 (_13) - 31 load_var 6 (_13) - 32 narrow_bind 1 6 - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - - 997 35 load_var 2 (item) - - 994 36 jump +16 (to 52) - 37 load_var 6 (_13) - 38 store_var 7 (part) - - 995 39 load_type 5 - 40 load_var 2 (item) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 8 (_16) - 43 load_type 3 - 44 load_var 7 (part) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 9 (_19) - 47 load_var 8 (_16) - 48 load_const 6 (":") - 49 bin_op + - 50 load_var 9 (_19) - 51 bin_op + - 52 return -} - -function openai.internal._openai_file_name(source: string | null) -> string { - 312 0 load_var 1 (source) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +43 (to 47) - 5 load_var 2 (_2) - 6 store_var 3 (raw) - - 313 7 load_var 3 (raw) - 8 load_const 1 ("?") - 9 call 150 ntypeargs=0 (baml.String.split) - 10 store_var 5 (_7) - 11 load_type 2 - 12 load_var 5 (_7) - 13 load_const 3 (0) - 14 call 3 ntypeargs=1 (baml.Array.at) - 15 store_var_load_var 4 (_5) - 16 load_const 4 (null) - 17 cmp_op == - 18 pop_jump_if_false +3 (to 21) - 19 load_var 3 (raw) - 20 store_var 4 (_5) - 21 load_var 4 (_5) - 22 load_const 5 ("/") - - 314 23 call 150 ntypeargs=0 (baml.String.split) - 24 store_var 6 (segments) - - 315 25 load_var 6 (segments) - 26 container_len - 27 store_var 9 (_15) - 28 load_type 2 - 29 load_var2 6 9 - 30 load_const 0 (1) - 31 sub_int - 32 call 3 ntypeargs=1 (baml.Array.at) - 33 store_var_load_var 8 (_12) - 34 load_const 4 (null) - 35 cmp_op == - 36 pop_jump_if_false +3 (to 39) - 37 load_const 6 ("") - 38 store_var 8 (_12) - 39 load_var 8 (_12) - 40 store_var 7 (last) - - 316 41 load_var 7 (last) - 42 call 144 ntypeargs=0 (baml.String.trim) - 43 load_const 7 ("") - 44 cmp_op != - 45 pop_jump_if_false +2 (to 47) - 46 jump +3 (to 49) - - 320 47 load_const 8 ("document.pdf") - 48 jump +3 (to 51) - - 317 49 load_var 7 (last) - 50 call 144 ntypeargs=0 (baml.String.trim) - 51 return -} - -function openai.internal._openai_headers(c: openai.ResponsesClient) -> map { - 659 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 2 (headers) - - 660 6 load_var 1 (c) - 7 load_field 12 (headers) - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 narrow_bind 3 3 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 3 (_4) - 13 store_var 4 (extra) - - 661 14 load_type 2 - 15 load_type 2 - 16 load_var 4 (extra) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 5 (_9) - 22 load_var 5 (_9) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 6 (_10) - 27 load_var 6 (_10) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 6 (_10) - 32 store_var 7 (name) - - 662 33 load_var 7 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 8 (_15) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 4 7 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 9 (_17) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 9 (_17) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 2 8 - 49 load_var 9 (_17) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 665 53 load_var 1 (c) - 54 call 1012 ntypeargs=0 (openai.ResponsesClient.resolved_api_key) - 55 store_var 11 (_28) - 56 load_type 2 - 57 load_var 11 (_28) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 10 (_27) - 60 load_type 2 - 61 load_type 2 - 62 load_var 2 (headers) - 63 load_const 11 ("authorization") - 64 load_const 12 ("Bearer ") - 65 load_var 10 (_27) - 66 bin_op + - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - - 666 69 load_var 2 (headers) - 70 return -} - -function openai.internal._openai_image_mime(output_format: string | null) -> string { - 755 0 load_var 1 (output_format) - 1 store_var_load_var 3 (_5) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("") - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 call 144 ntypeargs=0 (baml.String.trim) - 9 call 142 ntypeargs=0 (baml.String.to_lower_case) - 10 store_var 2 (format) - - 756 11 load_var 2 (format) - 12 load_const 2 ("jpeg") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +17 (to 32) - 16 load_var 2 (format) - 17 load_const 3 ("jpg") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +10 (to 30) - 21 load_var 2 (format) - 22 load_const 4 ("webp") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +3 (to 28) - - 759 26 load_const 5 ("image/png") - - 756 27 jump +6 (to 33) - - 758 28 load_const 6 ("image/webp") - - 756 29 jump +4 (to 33) - - 757 30 load_const 7 ("image/jpeg") - - 756 31 jump +2 (to 33) - - 757 32 load_const 8 ("image/jpeg") - 33 return -} - -function openai.internal._openai_media_role_error(kind: string, role: string) -> ai.errors.Failure { - 338 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 3 (_6) - 4 load_type 0 - 5 load_var 2 (role) - 6 call 138 ntypeargs=1 (baml.String.from) - 7 store_var 4 (_8) - - 339 8 load_const 1 ("openai") - 9 load_const 2 (null) - - 338 10 load_const 3 ("OpenAI Responses only supports ") - 11 load_var 3 (_6) - 12 bin_op + - 13 load_const 4 (" input in user messages, found ") - 14 bin_op + - 15 load_var 4 (_8) - 16 bin_op + - 17 load_const 2 (null) - 18 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 19 return -} - -function openai.internal._openai_merge_onto_last_part(item: baml.json.json, directives: map) -> void { - 472 0 load_var 1 (item) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 489 6 load_const 1 (null) - - 472 7 jump +64 (to 71) - - 474 8 load_type 2 - 9 load_type 3 - - 472 10 load_var 3 (_3) - 11 load_const 4 ("content") - - 474 12 call 38 ntypeargs=2 (baml.Map.get) - 13 store_var 4 (_8) - 14 load_var 4 (_8) - 15 narrow_bind 5 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +3 (to 20) - - 486 18 load_const 1 (null) - - 474 19 jump +52 (to 71) - 20 load_var 4 (_8) - 21 store_var 5 (parts) - - 476 22 load_var 5 (parts) - 23 container_len - 24 store_var 6 (_12) - 25 load_type 3 - 26 load_var2 5 6 - 27 load_const 6 (1) - 28 sub_int - 29 call 3 ntypeargs=1 (baml.Array.at) - 30 store_var 7 (_14) - 31 load_var 7 (_14) - 32 narrow_bind 0 7 - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - - 483 35 load_const 1 (null) - - 476 36 jump +35 (to 71) - 37 load_var 7 (_14) - 38 store_var 8 (part) - - 478 39 load_type 2 - 40 load_type 3 - 41 load_var 2 (directives) - 42 call 35 ntypeargs=2 (baml.Map.keys) - 43 load_type 7 - 44 load_const 8 ("iter") - 45 virtual_call nargs=1 ntypeargs=0 - 46 store_var 9 (_19) - 47 load_var 9 (_19) - 48 load_type 9 - 49 load_const 10 ("next") - 50 virtual_call nargs=1 ntypeargs=0 - 51 store_var 10 (_20) - 52 load_var 10 (_20) - 53 is_type 11 - 54 pop_jump_if_false +2 (to 56) - 55 jump +15 (to 70) - 56 load_var 10 (_20) - 57 store_var 11 (key) - - 479 58 load_type 2 - 59 load_type 3 - 60 load_var2 2 11 - 61 call 38 ntypeargs=2 (baml.Map.get) - 62 store_var 12 (_26) - 63 load_type 2 - 64 load_type 3 - 65 load_var2 8 11 - 66 load_var 12 (_26) - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - 69 jump -22 (to 47) - - 481 70 load_const 1 (null) - 71 return -} - -function openai.internal._openai_percent_encode(raw: string) -> string { - 288 0 load_const 0 ("") - 1 store_var 2 (out) - - 289 2 load_var 1 (raw) - 3 call 179 ntypeargs=0 (baml.String.to_utf8) - 4 call 194 ntypeargs=0 (baml.Uint8Array.to_array) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_5) - 9 load_var 3 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_6) - 14 load_var 4 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +81 (to 98) - 18 load_var 4 (_6) - 19 store_var_load_var 5 (byte) - - 290 20 load_const 6 (48) - 21 cmp_int_op >= - 22 jump_if_false +5 (to 27) - 23 pop 1 - 24 load_var 5 (byte) - 25 load_const 7 (57) - 26 cmp_int_op <= - 27 jump_if_false +2 (to 29) - 28 jump +10 (to 38) - 29 pop 1 - - 291 30 load_var 5 (byte) - 31 load_const 8 (65) - 32 cmp_int_op >= - 33 jump_if_false +5 (to 38) - 34 pop 1 - 35 load_var 5 (byte) - 36 load_const 9 (90) - 37 cmp_int_op <= - - 290 38 jump_if_false +2 (to 40) - 39 jump +10 (to 49) - 40 pop 1 - - 292 41 load_var 5 (byte) - 42 load_const 10 (97) - 43 cmp_int_op >= - 44 jump_if_false +5 (to 49) - 45 pop 1 - 46 load_var 5 (byte) - 47 load_const 11 (122) - 48 cmp_int_op <= - - 290 49 jump_if_false +2 (to 51) - 50 jump +5 (to 55) - 51 pop 1 - - 293 52 load_var 5 (byte) - 53 load_const 12 (45) - 54 cmp_int_op == - - 290 55 jump_if_false +2 (to 57) - 56 jump +5 (to 61) - 57 pop 1 - - 294 58 load_var 5 (byte) - 59 load_const 13 (46) - 60 cmp_int_op == - - 290 61 jump_if_false +2 (to 63) - 62 jump +5 (to 67) - 63 pop 1 - - 295 64 load_var 5 (byte) - 65 load_const 14 (95) - 66 cmp_int_op == - - 290 67 jump_if_false +2 (to 69) - 68 jump +5 (to 73) - 69 pop 1 - - 296 70 load_var 5 (byte) - 71 load_const 15 (126) - 72 cmp_int_op == - - 297 73 pop_jump_if_false +2 (to 75) - 74 jump +15 (to 89) - - 300 75 load_var 5 (byte) - 76 load_type 16 - 77 alloc_array 1 - 78 call 193 ntypeargs=0 (baml.Uint8Array.from_array) - 79 call 196 ntypeargs=0 (baml.Uint8Array.to_hex) - 80 call 143 ntypeargs=0 (baml.String.to_upper_case) - 81 store_var 7 (_35) - 82 load_var 2 (out) - 83 load_const 17 ("%") - 84 load_var 7 (_35) - 85 bin_op + - 86 bin_op + - 87 store_var 2 (out) - - 297 88 jump -79 (to 9) - - 298 89 load_var 5 (byte) - 90 load_type 16 - 91 alloc_array 1 - 92 call 182 ntypeargs=0 (baml.String.from_code_points) - 93 store_var 6 (_31) - 94 load_var2 2 6 - 95 bin_op + - 96 store_var 2 (out) - - 297 97 jump -88 (to 9) - - 303 98 load_var 2 (out) - 99 return -} - -function openai.internal._openai_prompt_content(message: ai.PromptMessage, role: string) -> (openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile)[] { - 344 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (content) - - 345 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +229 (to 246) - 18 load_var 5 (_6) - 19 store_var 6 (part) - - 346 20 load_var 6 (part) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +198 (to 223) - 26 load_var 6 (part) - 27 store_var 9 (_21) - 28 load_var 9 (_21) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +136 (to 167) - 32 load_var 6 (part) - 33 store_var 16 (_46) - 34 load_var 16 (_46) - 35 narrow_bind 8 16 - 36 pop_jump_if_false +2 (to 38) - 37 jump +92 (to 129) - 38 load_var 6 (part) - 39 store_var 22 (_62) - 40 load_var 22 (_62) - 41 narrow_bind 9 22 - 42 pop_jump_if_false +2 (to 44) - 43 jump +7 (to 50) - - 422 44 load_const 10 ("openai") - 45 load_const 11 (null) - 46 load_const 12 ("OpenAI Responses does not support video prompt input") - 47 load_const 11 (null) - 48 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 49 throw - - 346 50 load_var 22 (_62) - 51 store_var 23 (pdf) - - 391 52 load_var 2 (role) - 53 load_const 13 ("user") - 54 cmp_op != - 55 pop_jump_if_false +2 (to 57) - 56 jump +69 (to 125) - - 394 57 load_var 23 (pdf) - 58 load_const 14 (false) - 59 call 933 ntypeargs=0 (ai.wire.resolve_media) - 60 store_var 24 (resolved) - - 395 61 load_var 23 (pdf) - 62 call 323 ntypeargs=0 (baml.media.Pdf.file) - 63 store_var_load_var 26 (_70) - 64 load_const 11 (null) - 65 cmp_op == - 66 pop_jump_if_false +4 (to 70) - 67 load_var 23 (pdf) - 68 call 322 ntypeargs=0 (baml.media.Pdf.url) - 69 store_var 26 (_70) - 70 load_var 26 (_70) - 71 call 1020 ntypeargs=0 (openai.internal._openai_file_name) - 72 store_var 25 (name) - - 396 73 load_var 24 (resolved) - 74 load_field 0 (url) - 75 store_var 27 (_74) - 76 load_var 27 (_74) - 77 narrow_bind 6 27 - 78 pop_jump_if_false +2 (to 80) - 79 jump +35 (to 114) - - 412 80 load_type 15 - 81 load_var 24 (resolved) - 82 load_field 2 (mime_type) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 28 (_87) - 85 load_var 24 (resolved) - 86 load_field 1 (base64) - 87 store_var_load_var 30 (_92) - 88 load_const 11 (null) - 89 cmp_op == - 90 pop_jump_if_false +3 (to 93) - 91 load_const 16 ("") - 92 store_var 30 (_92) - 93 load_type 15 - 94 load_var 30 (_92) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 29 (_90) - - 408 97 load_type 0 - 98 load_var 3 (content) - - 409 99 load_const 17 ("input_file") - - 411 100 load_var 25 (name) - - 412 101 load_const 18 ("data:") - 102 load_var 28 (_87) - 103 bin_op + - 104 load_const 19 (";base64,") - 105 bin_op + - 106 load_var 29 (_90) - 107 bin_op + - 108 load_const 11 (null) - 109 load_const 11 (null) - 110 init_instance 1 (openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id) - - 408 111 call 4 ntypeargs=1 (baml.Array.push) - 112 pop 1 - 113 jump -104 (to 9) - - 397 114 load_type 0 - 115 load_var 3 (content) - - 398 116 load_const 20 ("input_file") - - 400 117 load_var 25 (name) - 118 load_const 11 (null) - - 396 119 load_var 27 (_74) - 120 load_const 11 (null) - 121 init_instance 2 (openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id) - - 397 122 call 4 ntypeargs=1 (baml.Array.push) - 123 pop 1 - 124 jump -115 (to 9) - - 392 125 load_const 21 ("PDF") - 126 load_var 2 (role) - 127 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 128 throw - - 346 129 load_var 16 (_46) - 130 store_var 17 (audio) - - 374 131 load_var 2 (role) - 132 load_const 22 ("user") - 133 cmp_op != - 134 pop_jump_if_false +2 (to 136) - 135 jump +28 (to 163) - - 378 136 load_var 17 (audio) - 137 load_const 23 (true) - 138 call 933 ntypeargs=0 (ai.wire.resolve_media) - 139 store_var 18 (resolved) - - 383 140 load_var 18 (resolved) - 141 load_field 1 (base64) - 142 store_var_load_var 20 (_56) - 143 load_const 11 (null) - 144 cmp_op == - 145 pop_jump_if_false +3 (to 148) - 146 load_const 24 ("") - 147 store_var 20 (_56) - 148 load_var 20 (_56) - 149 store_var 19 (_55) - - 384 150 load_var 18 (resolved) - 151 load_field 2 (mime_type) - 152 call 1021 ntypeargs=0 (openai.internal._openai_audio_format) - 153 store_var 21 (_59) - - 379 154 load_type 0 - 155 load_var 3 (content) - - 380 156 load_const 25 ("input_audio") - - 382 157 load_var2 19 21 - 158 init_instance 3 (openai.internal.OaAudioPayload .data, .format) - 159 init_instance 4 (openai.internal.OaInputAudio .type, .input_audio) - - 379 160 call 4 ntypeargs=1 (baml.Array.push) - 161 pop 1 - 162 jump -153 (to 9) - - 375 163 load_const 26 ("audio") - 164 load_var 2 (role) - 165 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 166 throw - - 346 167 load_var 9 (_21) - 168 store_var 10 (image) - - 358 169 load_var 2 (role) - 170 load_const 27 ("user") - 171 cmp_op != - 172 pop_jump_if_false +2 (to 174) - 173 jump +46 (to 219) - - 361 174 load_var 10 (image) - 175 load_const 14 (false) - 176 call 933 ntypeargs=0 (ai.wire.resolve_media) - 177 store_var 11 (resolved) - - 362 178 load_var 11 (resolved) - 179 load_field 0 (url) - 180 store_var_load_var 12 (_28) - 181 load_const 11 (null) - 182 cmp_op == - 183 pop_jump_if_false +26 (to 209) - 184 load_type 15 - 185 load_var 11 (resolved) - 186 load_field 2 (mime_type) - 187 call 138 ntypeargs=1 (baml.String.from) - 188 store_var 13 (_33) - 189 load_var 11 (resolved) - 190 load_field 1 (base64) - 191 store_var_load_var 15 (_38) - 192 load_const 11 (null) - 193 cmp_op == - 194 pop_jump_if_false +3 (to 197) - 195 load_const 28 ("") - 196 store_var 15 (_38) - 197 load_type 15 - 198 load_var 15 (_38) - 199 call 138 ntypeargs=1 (baml.String.from) - 200 store_var 14 (_36) - 201 load_const 29 ("data:") - 202 load_var 13 (_33) - 203 bin_op + - 204 load_const 30 (";base64,") - 205 bin_op + - 206 load_var 14 (_36) - 207 bin_op + - 208 store_var 12 (_28) - - 363 209 load_type 0 - 210 load_var 3 (content) - - 364 211 load_const 31 ("input_image") - - 362 212 load_var 12 (_28) - 213 load_const 11 (null) - 214 load_const 32 ("auto") - 215 init_instance 5 (openai.internal.OaInputImage .type, .image_url, .file_id, .detail) - - 363 216 call 4 ntypeargs=1 (baml.Array.push) - 217 pop 1 - 218 jump -209 (to 9) - - 359 219 load_const 33 ("image") - 220 load_var 2 (role) - 221 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 222 throw - - 346 223 load_var 7 (_10) - 224 store_var 8 (text) - - 348 225 load_var 2 (role) - 226 load_const 34 ("assistant") - 227 cmp_op == - 228 pop_jump_if_false +2 (to 230) - 229 jump +9 (to 238) - - 352 230 load_type 0 - 231 load_var 3 (content) - 232 load_const 35 ("input_text") - 233 load_var 8 (text) - 234 init_instance 6 (openai.internal.OaInputText .type, .text) - 235 call 4 ntypeargs=1 (baml.Array.push) - 236 pop 1 - 237 jump -228 (to 9) - - 349 238 load_type 0 - 239 load_var 3 (content) - 240 load_const 36 ("output_text") - 241 load_var 8 (text) - 242 init_instance 7 (openai.internal.OaOutputText .type, .text) - 243 call 4 ntypeargs=1 (baml.Array.push) - 244 pop 1 - 245 jump -236 (to 9) - - 431 246 load_var 3 (content) - 247 return -} - -function openai.internal._openai_prune_nulls(value: baml.json.json) -> baml.json.json { - 219 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +36 (to 41) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 241 12 load_var 1 (value) - - 219 13 jump +74 (to 87) - - 235 14 load_type 2 - 15 alloc_array 0 - 16 store_var 11 (out) - - 219 17 load_var 10 (_24) - 18 load_type 3 - 19 load_const 4 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 12 (_28) - - 236 22 load_var 12 (_28) - 23 load_type 5 - 24 load_const 6 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 13 (_29) - 27 load_var 13 (_29) - 28 is_type 7 - 29 pop_jump_if_false +2 (to 31) - 30 jump +9 (to 39) - 31 load_var 13 (_29) - - 237 32 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - 33 store_var 14 (_34) - 34 load_type 2 - 35 load_var2 11 14 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -16 (to 22) - - 239 39 load_var 11 (out) - - 219 40 jump +47 (to 87) - 41 load_var 2 (_2) - 42 store_var 3 (object) - - 221 43 load_type 8 - 44 load_type 2 - 45 alloc_map 0 - 46 store_var 4 (out) - - 222 47 load_type 8 - 48 load_type 2 - 49 load_var 3 (object) - 50 call 35 ntypeargs=2 (baml.Map.keys) - 51 load_type 9 - 52 load_const 10 ("iter") - 53 virtual_call nargs=1 ntypeargs=0 - 54 store_var 5 (_8) - 55 load_var 5 (_8) - 56 load_type 11 - 57 load_const 12 ("next") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 6 (_9) - 60 load_var 6 (_9) - 61 is_type 7 - 62 pop_jump_if_false +2 (to 64) - 63 jump +23 (to 86) - 64 load_var 6 (_9) - 65 store_var 7 (key) - - 223 66 load_type 8 - 67 load_type 2 - 68 load_var2 3 7 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 8 (entry) - - 224 71 load_var 8 (entry) - 72 load_const 13 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump -20 (to 55) - - 227 76 load_var 8 (entry) - 77 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - 78 store_var 9 (_20) - 79 load_type 8 - 80 load_type 2 - 81 load_var2 4 7 - 82 load_var 9 (_20) - 83 call 37 ntypeargs=2 (baml.Map.set) - 84 pop 1 - 85 jump -30 (to 55) - - 232 86 load_var 4 (out) - 87 return -} - -function openai.internal._openai_reasoning(c: openai.ResponsesClient) -> openai.internal.OaReasoningParams | null { - 641 0 load_var 1 (c) - 1 load_field 6 (reasoning_effort) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 jump_if_false +6 (to 10) - 5 pop 1 - 6 load_var 1 (c) - 7 load_field 7 (reasoning_summary) - 8 load_const 0 (null) - 9 call 672 ntypeargs=0 (baml.ops.equals_equals) - 10 pop_jump_if_false +2 (to 12) - 11 jump +7 (to 18) - - 644 12 load_var 1 (c) - 13 load_field 6 (reasoning_effort) - 14 load_var 1 (c) - 15 load_field 7 (reasoning_summary) - 16 init_instance 0 (openai.internal.OaReasoningParams .effort, .summary) - - 641 17 jump +2 (to 19) - - 642 18 load_const 0 (null) - 19 return -} - -function openai.internal._openai_request(c: openai.ResponsesClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 703 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 5 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 5 (_5) - 7 call_indirect - 8 store_var 4 (prompt) - - 704 9 load_var 4 (prompt) - 10 call 1024 ntypeargs=0 (openai.internal.openai_lower_prompt) - 11 store_var 6 (items) - - 707 12 load_var 2 (input) - 13 load_field 1 (journal) - 14 store_var 7 (_11) - 15 load_var 1 (c) - 16 load_type 0 - 17 load_const 1 ("id") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 8 (_12) - 20 load_var2 7 8 - 21 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 708 22 call 1028 ntypeargs=0 (openai.internal.openai_lower_journal) - 23 load_type 2 - 24 load_const 3 ("iter") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 9 (_15) - 27 load_var 9 (_15) - 28 load_type 4 - 29 load_const 5 ("next") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 10 (_16) - 32 load_var 10 (_16) - 33 is_type 6 - 34 pop_jump_if_false +2 (to 36) - 35 jump +6 (to 41) - - 709 36 load_type 7 - 37 load_var2 6 10 - 38 call 4 ntypeargs=1 (baml.Array.push) - 39 pop 1 - 40 jump -13 (to 27) - - 711 41 load_var 2 (input) - 42 load_field 3 (output_type) - 43 call 1029 ntypeargs=0 (openai.internal._openai_wants_image) - 44 store_var 11 (wants_image) - - 712 45 load_var 2 (input) - 46 load_field 2 (toolbox) - 47 load_var 11 (wants_image) - 48 call 1030 ntypeargs=0 (openai.internal._openai_tools) - 49 store_var 12 (tools) - - 714 50 load_var 1 (c) - 51 load_field 0 (model) - 52 store_var 13 (_29) - - 716 53 load_var 1 (c) - 54 load_field 10 (store) - 55 store_var 14 (_31) - - 717 56 load_var 3 (stream) - 57 pop_jump_if_false +2 (to 59) - 58 jump +4 (to 62) - - 720 59 load_const 8 (null) - 60 store_var 15 (_32) - - 717 61 jump +3 (to 64) - - 718 62 load_const 9 (true) - 63 store_var 15 (_32) - - 722 64 load_var 1 (c) - 65 load_field 3 (temperature) - 66 store_var 16 (_33) - - 723 67 load_var 1 (c) - 68 load_field 4 (top_p) - 69 store_var 17 (_34) - - 724 70 load_var 1 (c) - 71 load_field 5 (max_output_tokens) - 72 store_var 18 (_35) - - 725 73 load_var 1 (c) - 74 call 1032 ntypeargs=0 (openai.internal._openai_reasoning) - 75 store_var 19 (_36) - - 726 76 load_var 1 (c) - 77 call 1033 ntypeargs=0 (openai.internal._openai_text) - 78 store_var 20 (_37) - - 727 79 load_var 1 (c) - 80 load_field 9 (parallel_tool_calls) - 81 store_var 21 (_38) - - 729 82 load_var2 12 11 - 83 call 1031 ntypeargs=0 (openai.internal._openai_tool_choice) - 84 store_var 22 (_40) - - 735 85 load_type 10 - - 713 86 load_var2 13 6 - - 715 87 load_var2 14 15 - 88 load_var2 16 17 - 89 load_var2 18 19 - 90 load_var2 20 21 - - 728 91 load_var2 12 22 - 92 init_instance 0 (openai.internal.OaResponsesRequest .model, .input, .store, .stream, .temperature, .top_p, .max_output_tokens, .reasoning, .text, .parallel_tool_calls, .tools, .tool_choice) - - 735 93 call 355 ntypeargs=1 (baml.json.to_json) - 94 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - - 736 95 load_var 12 (tools) - - 734 96 call 1018 ntypeargs=0 (openai.internal._openai_restore_tool_schemas) - 97 store_var 23 (pruned) - - 739 98 load_var 4 (prompt) - 99 call 1025 ntypeargs=0 (openai.internal.openai_prompt_metadata) - 100 store_var 25 (_52) - 101 load_var2 23 25 - 102 call 1027 ntypeargs=0 (openai.internal._openai_apply_message_metadata) - - 740 103 load_var 1 (c) - 104 load_field 11 (request_body) - - 738 105 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 106 store_var 24 (body) - - 744 107 load_var 1 (c) - 108 call 1035 ntypeargs=0 (openai.internal._openai_url) - 109 store_var 26 (_55) - - 745 110 load_var 1 (c) - 111 call 1034 ntypeargs=0 (openai.internal._openai_headers) - 112 store_var 27 (_56) - - 746 113 load_var 24 (body) - 114 call 351 ntypeargs=0 (baml.json.stringify) - 115 store_var 28 (_57) - - 742 116 load_const 11 ("POST") - 117 load_var2 26 27 - 118 load_var 28 (_57) - 119 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 120 return -} - -function openai.internal._openai_response_failure(resp: openai.internal.OaResponse) -> ai.errors.Failure { - 805 0 load_var 1 (resp) - 1 load_field 6 (error) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +21 (to 27) - - 809 7 load_var 1 (resp) - 8 load_field 2 (status) - 9 store_var_load_var 4 (_10) - 10 load_const 1 (null) - 11 cmp_op == - 12 pop_jump_if_false +3 (to 15) - 13 load_const 2 ("failed") - 14 store_var 4 (_10) - 15 load_type 3 - 16 load_var 4 (_10) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 3 (_8) - 19 load_const 1 (null) - 20 load_const 4 ("the response ended with status ") - 21 load_var 3 (_8) - 22 bin_op + - 23 load_const 1 (null) - 24 init_instance 0 (openai.internal.OaErrorBody .code, .message, .type) - - 808 25 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 26 jump +3 (to 29) - - 805 27 load_var 2 (_3) - - 806 28 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 29 return -} - -function openai.internal._openai_restore_tool_schemas(body: baml.json.json, tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null) -> baml.json.json { - 250 0 load_var 2 (tools) - 1 store_var_load_var 4 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +4 (to 8) - 5 load_type 1 - 6 alloc_array 0 - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 store_var 3 (list) - - 251 10 load_var 3 (list) - 11 container_len - 12 store_var 5 (_7) - 13 load_var 5 (_7) - 14 load_const 2 (0) - 15 cmp_int_op == - 16 pop_jump_if_false +2 (to 18) - 17 jump +62 (to 79) - - 254 18 load_var 1 (body) - 19 store_var 6 (_8) - 20 load_var 6 (_8) - 21 narrow_bind 3 6 - 22 pop_jump_if_false +55 (to 77) - - 256 23 load_type 4 - 24 load_type 5 - - 254 25 load_var 6 (_8) - 26 load_const 6 ("tools") - - 256 27 call 38 ntypeargs=2 (baml.Map.get) - 28 store_var 7 (_13) - 29 load_var 7 (_13) - 30 narrow_bind 7 7 - 31 pop_jump_if_false +46 (to 77) - 32 load_var 7 (_13) - 33 store_var 8 (wire) - - 258 34 load_const 2 (0) - 35 store_var 9 (index) - - 259 36 load_var 3 (list) - 37 load_type 8 - 38 load_const 9 ("iter") - 39 virtual_call nargs=1 ntypeargs=0 - 40 store_var 10 (_17) - 41 load_var 10 (_17) - 42 load_type 10 - 43 load_const 11 ("next") - 44 virtual_call nargs=1 ntypeargs=0 - 45 store_var 11 (_18) - 46 load_var 11 (_18) - 47 is_type 12 - 48 pop_jump_if_false +2 (to 50) - 49 jump +28 (to 77) - 50 load_var 11 (_18) - 51 store_var 12 (_22) - - 260 52 load_var 12 (_22) - 53 narrow_bind 13 12 - 54 pop_jump_if_false +18 (to 72) - 55 load_var 12 (_22) - 56 store_var 13 (fn) - - 262 57 load_type 5 - 58 load_var2 8 9 - 59 call 3 ntypeargs=1 (baml.Array.at) - 60 store_var 14 (_27) - 61 load_var 14 (_27) - 62 narrow_bind 3 14 - 63 pop_jump_if_false +9 (to 72) - - 264 64 load_type 4 - 65 load_type 5 - - 262 66 load_var 14 (_27) - 67 load_const 14 ("parameters") - - 264 68 load_var 13 (fn) - 69 load_field 3 (parameters) - 70 call 37 ntypeargs=2 (baml.Map.set) - 71 pop 1 - - 273 72 load_var 9 (index) - 73 load_const 15 (1) - 74 add_int - 75 store_var 9 (index) - - 259 76 jump -35 (to 41) - - 283 77 load_var 1 (body) - 78 jump +2 (to 80) - - 252 79 load_var 1 (body) - 80 return -} - -function openai.internal._openai_sse_failure(error: unknown) -> ai.errors.Failure { - 1121 0 load_var 1 (error) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +6 (to 11) - - 1123 6 load_type 1 - 7 load_var 1 (error) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 2 (text) - 10 jump +4 (to 14) - - 1121 11 load_var 3 (_3) - 12 load_field 0 (message) - 13 store_var 2 (text) - - 1126 14 load_var 2 (text) - - 1125 15 load_const 2 ("SSE request failed with status ") - - 1126 16 call 155 ntypeargs=0 (baml.String.index_of) - 17 store_var 4 (_9) - 18 load_var 4 (_9) - 19 narrow_bind 3 4 - 20 pop_jump_if_false +41 (to 61) - 21 load_var 4 (_9) - 22 store_var 7 (_13) - - 1125 23 load_const 4 ("SSE request failed with status ") - - 1127 24 call 139 ntypeargs=0 (baml.String.length) - 25 load_var 7 (_13) - 26 add_int - 27 store_var 6 (_12) - 28 load_var 2 (text) - 29 call 139 ntypeargs=0 (baml.String.length) - 30 store_var 8 (_15) - 31 load_var2 2 6 - 32 load_var 8 (_15) - 33 call 153 ntypeargs=0 (baml.String.slice) - 34 store_var 5 (rest) - - 1128 35 load_var 5 (rest) - 36 load_const 5 (":") - 37 call 155 ntypeargs=0 (baml.String.index_of) - 38 store_var 9 (_17) - 39 load_var 9 (_17) - 40 narrow_bind 3 9 - 41 pop_jump_if_false +20 (to 61) - 42 load_var 9 (_17) - 43 store_var 10 (separator) - - 1129 44 load_var 5 (rest) - 45 load_const 3 (0) - 46 load_var 10 (separator) - 47 call 153 ntypeargs=0 (baml.String.slice) - 48 call 144 ntypeargs=0 (baml.String.trim) - 49 call 81 ntypeargs=0 (baml.Int.parse) - 50 store_var 11 (code) - 51 jump +5 (to 56) - 52 load_var 12 (e) - 53 throw_if_panic - - 1130 54 load_const 3 (0) - 55 store_var 11 (code) - - 1132 56 load_var 11 (code) - 57 load_const 3 (0) - 58 cmp_int_op > - 59 pop_jump_if_false +2 (to 61) - 60 jump +12 (to 72) - - 1143 61 load_type 6 - 62 load_var 2 (text) - 63 call 138 ntypeargs=1 (baml.String.from) - 64 store_var 17 (_33) - - 1141 65 load_const 7 ("openai") - - 1143 66 load_const 8 ("transport failed before a response arrived: ") - 67 load_var 17 (_33) - 68 bin_op + - 69 load_const 9 (null) - 70 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 71 jump +19 (to 90) - - 1135 72 load_var 11 (code) - 73 store_var 13 (_26) - - 1136 74 load_var 10 (separator) - 75 load_const 10 (1) - 76 add_int - 77 store_var 15 (_29) - 78 load_var 5 (rest) - 79 call 139 ntypeargs=0 (baml.String.length) - 80 store_var 16 (_31) - 81 load_var2 5 15 - 82 load_var 16 (_31) - 83 call 153 ntypeargs=0 (baml.String.slice) - 84 call 144 ntypeargs=0 (baml.String.trim) - 85 store_var 14 (_27) - - 1133 86 load_const 11 ("openai") - 87 load_var2 13 14 - 88 load_const 12 () - 89 call 977 ntypeargs=0 (ai.errors.classify_http) - 90 return -} - -function openai.internal._openai_stream_events(event: openai.internal.OaStreamEvent, sse_name: string | null, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1017 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 1018 3 load_var 1 (event) - 4 load_field 0 (type) - 5 store_var_load_var 7 (_8) - 6 load_const 1 (null) - 7 cmp_op == - 8 pop_jump_if_false +3 (to 11) - 9 load_var 2 (sse_name) - 10 store_var 7 (_8) - 11 load_var 7 (_8) - 12 store_var_load_var 6 (_6) - 13 load_const 1 (null) - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - 16 load_const 2 ("") - 17 store_var 6 (_6) - 18 load_var 6 (_6) - 19 store_var_load_var 5 (kind) - - 1021 20 load_const 3 ("response.failed") - 21 cmp_op != - 22 jump_if_false +5 (to 27) - 23 pop 1 - 24 load_var 5 (kind) - 25 load_const 4 ("error") - 26 cmp_op != - 27 pop_jump_if_false +8 (to 35) - - 1022 28 load_var 1 (event) - 29 load_field 11 (error) - 30 store_var 8 (_17) - 31 load_var 8 (_17) - 32 narrow_bind 5 8 - 33 pop_jump_if_false +2 (to 35) - 34 jump +298 (to 332) - - 1026 35 load_var 5 (kind) - 36 load_const 6 ("response.created") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +282 (to 321) - 40 load_var 5 (kind) - 41 load_const 7 ("response.in_progress") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +267 (to 311) - 45 load_var 5 (kind) - 46 load_const 8 ("response.output_text.delta") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +236 (to 285) - 50 load_var 5 (kind) - 51 load_const 9 ("response.output_text.done") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +191 (to 245) - 55 load_var 5 (kind) - 56 load_const 10 ("response.function_call_arguments.delta") - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +152 (to 211) - 60 load_var 5 (kind) - 61 load_const 11 ("response.function_call_arguments.done") - 62 cmp_op == - 63 pop_jump_if_false +2 (to 65) - 64 jump +126 (to 190) - 65 load_var 5 (kind) - 66 load_const 12 ("response.failed") - 67 cmp_op == - 68 pop_jump_if_false +2 (to 70) - 69 jump +118 (to 187) - 70 load_var 5 (kind) - 71 load_const 13 ("error") - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +110 (to 184) - 75 load_var 5 (kind) - 76 load_const 14 ("response.completed") - 77 cmp_op == - 78 pop_jump_if_false +2 (to 80) - 79 jump +55 (to 134) - 80 load_var 5 (kind) - 81 load_const 15 ("response.incomplete") - 82 cmp_op == - 83 pop_jump_if_false +247 (to 330) - - 1078 84 load_var 1 (event) - 85 load_field 8 (response) - 86 store_var 33 (_122) - 87 load_var 33 (_122) - 88 narrow_bind 16 33 - 89 pop_jump_if_false +39 (to 128) - 90 load_var 33 (_122) - - 1079 91 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 92 store_var 34 (turn) - - 1082 93 load_var 34 (turn) - 94 load_field 1 (stop_reason) - 95 store_var 35 (_128) - - 1083 96 load_var 34 (turn) - 97 load_field 2 (usage) - 98 load_const 1 (null) - 99 cmp_op == - 100 pop_jump_if_false +2 (to 102) - 101 jump +6 (to 107) - 102 load_var 34 (turn) - 103 load_field 2 (usage) - 104 load_field 0 (0) - 105 store_var 36 (_129) - 106 jump +3 (to 109) - 107 load_const 1 (null) - 108 store_var 36 (_129) - - 1084 109 load_var 34 (turn) - 110 load_field 2 (usage) - 111 load_const 1 (null) - 112 cmp_op == - 113 pop_jump_if_false +2 (to 115) - 114 jump +6 (to 120) - 115 load_var 34 (turn) - 116 load_field 2 (usage) - 117 load_field 1 (1) - 118 store_var 37 (_133) - 119 jump +3 (to 122) - 120 load_const 1 (null) - 121 store_var 37 (_133) - - 1080 122 load_type 0 - 123 load_var2 4 35 - - 1081 124 load_var2 36 37 - 125 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1080 126 call 4 ntypeargs=1 (baml.Array.push) - 127 pop 1 - - 1088 128 load_type 0 - 129 load_var 4 (out) - 130 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 131 call 4 ntypeargs=1 (baml.Array.push) - 132 pop 1 - 133 jump +197 (to 330) - - 1078 134 load_var 1 (event) - 135 load_field 8 (response) - 136 store_var 28 (_101) - 137 load_var 28 (_101) - 138 narrow_bind 16 28 - 139 pop_jump_if_false +39 (to 178) - 140 load_var 28 (_101) - - 1079 141 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 142 store_var 29 (turn) - - 1082 143 load_var 29 (turn) - 144 load_field 1 (stop_reason) - 145 store_var 30 (_107) - - 1083 146 load_var 29 (turn) - 147 load_field 2 (usage) - 148 load_const 1 (null) - 149 cmp_op == - 150 pop_jump_if_false +2 (to 152) - 151 jump +6 (to 157) - 152 load_var 29 (turn) - 153 load_field 2 (usage) - 154 load_field 0 (0) - 155 store_var 31 (_108) - 156 jump +3 (to 159) - 157 load_const 1 (null) - 158 store_var 31 (_108) - - 1084 159 load_var 29 (turn) - 160 load_field 2 (usage) - 161 load_const 1 (null) - 162 cmp_op == - 163 pop_jump_if_false +2 (to 165) - 164 jump +6 (to 170) - 165 load_var 29 (turn) - 166 load_field 2 (usage) - 167 load_field 1 (1) - 168 store_var 32 (_112) - 169 jump +3 (to 172) - 170 load_const 1 (null) - 171 store_var 32 (_112) - - 1080 172 load_type 0 - 173 load_var2 4 30 - - 1081 174 load_var2 31 32 - 175 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1080 176 call 4 ntypeargs=1 (baml.Array.push) - 177 pop 1 - - 1088 178 load_type 0 - 179 load_var 4 (out) - 180 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 181 call 4 ntypeargs=1 (baml.Array.push) - 182 pop 1 - 183 jump +147 (to 330) - - 1076 184 load_var 1 (event) - 185 call 1046 ntypeargs=0 (openai.internal._openai_stream_failure) - 186 throw - 187 load_var 1 (event) - 188 call 1046 ntypeargs=0 (openai.internal._openai_stream_failure) - 189 throw - - 1071 190 load_var 1 (event) - 191 load_field 3 (arguments) - 192 store_var 24 (_87) - 193 load_var 24 (_87) - 194 narrow_bind 17 24 - 195 pop_jump_if_false +135 (to 330) - 196 load_var 24 (_87) - 197 store_var 25 (full) - - 1072 198 load_var 3 (state) - 199 load_field 2 (call_arguments) - 200 store_var 26 (_90) - 201 load_var 1 (event) - 202 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 203 store_var 27 (_91) - 204 load_type 18 - 205 load_type 18 - 206 load_var2 26 27 - 207 load_var 25 (full) - 208 call 37 ntypeargs=2 (baml.Map.set) - 209 pop 1 - 210 jump +120 (to 330) - - 1061 211 load_var 1 (event) - 212 load_field 1 (delta) - 213 store_var 19 (_67) - 214 load_var 19 (_67) - 215 narrow_bind 17 19 - 216 pop_jump_if_false +114 (to 330) - 217 load_var 19 (_67) - 218 store_var 20 (delta) - - 1062 219 load_var 1 (event) - 220 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 221 store_var 21 (key) - - 1063 222 load_var 3 (state) - 223 load_field 2 (call_arguments) - 224 store_var 22 (_71) - - 1065 225 load_type 18 - 226 load_type 18 - 227 load_var 3 (state) - 228 load_field 2 (call_arguments) - 229 load_var 21 (key) - 230 call 38 ntypeargs=2 (baml.Map.get) - 231 store_var_load_var 23 (_75) - 232 load_const 1 (null) - 233 cmp_op == - 234 pop_jump_if_false +3 (to 237) - 235 load_const 19 ("") - 236 store_var 23 (_75) - - 1063 237 load_type 18 - 238 load_type 18 - 239 load_var2 22 21 - - 1065 240 load_var2 23 20 - 241 bin_op + - - 1063 242 call 37 ntypeargs=2 (baml.Map.set) - 243 pop 1 - 244 jump +86 (to 330) - - 1045 245 load_var 1 (event) - 246 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 247 store_var 15 (key) - - 1046 248 load_type 18 - 249 load_type 20 - 250 load_var 3 (state) - 251 load_field 1 (text_started) - 252 load_var 15 (key) - 253 call 38 ntypeargs=2 (baml.Map.get) - 254 store_var_load_var 16 (_46) - 255 load_const 1 (null) - 256 cmp_op == - 257 pop_jump_if_false +3 (to 260) - 258 load_const 21 (false) - 259 store_var 16 (_46) - 260 load_var 16 (_46) - 261 unary_op ! - 262 pop_jump_if_false +68 (to 330) - - 1047 263 load_var 1 (event) - 264 load_field 2 (text) - 265 store_var 17 (_54) - 266 load_var 17 (_54) - 267 narrow_bind 17 17 - 268 pop_jump_if_false +62 (to 330) - 269 load_var 17 (_54) - 270 store_var 18 (full) - - 1048 271 load_type 18 - 272 load_type 20 - 273 load_var 3 (state) - 274 load_field 1 (text_started) - 275 load_var 15 (key) - 276 load_const 22 (true) - 277 call 37 ntypeargs=2 (baml.Map.set) - 278 pop 1 - - 1049 279 load_type 0 - 280 load_var2 4 18 - 281 init_instance 2 (ai.stream.TextDelta .text) - 282 call 4 ntypeargs=1 (baml.Array.push) - 283 pop 1 - 284 jump +46 (to 330) - - 1036 285 load_var 1 (event) - 286 load_field 1 (delta) - 287 store_var 11 (_31) - 288 load_var 11 (_31) - 289 narrow_bind 17 11 - 290 pop_jump_if_false +40 (to 330) - 291 load_var 11 (_31) - 292 store_var 12 (delta) - - 1037 293 load_var 3 (state) - 294 load_field 1 (text_started) - 295 store_var 13 (_34) - 296 load_var 1 (event) - 297 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 298 store_var 14 (_35) - 299 load_type 18 - 300 load_type 20 - 301 load_var2 13 14 - 302 load_const 22 (true) - 303 call 37 ntypeargs=2 (baml.Map.set) - 304 pop 1 - - 1038 305 load_type 0 - 306 load_var2 4 12 - 307 init_instance 3 (ai.stream.TextDelta .text) - 308 call 4 ntypeargs=1 (baml.Array.push) - 309 pop 1 - 310 jump +20 (to 330) - - 1030 311 load_var 1 (event) - 312 load_field 8 (response) - 313 store_var 10 (_27) - 314 load_var 10 (_27) - 315 narrow_bind 16 10 - 316 pop_jump_if_false +14 (to 330) - - 1031 317 load_var2 3 10 - - 1030 318 load_field 1 (model) - 319 store_field 0 (model) - 320 jump +10 (to 330) - 321 load_var 1 (event) - 322 load_field 8 (response) - 323 store_var 9 (_23) - 324 load_var 9 (_23) - 325 narrow_bind 16 9 - 326 pop_jump_if_false +4 (to 330) - - 1031 327 load_var2 3 9 - - 1030 328 load_field 1 (model) - 329 store_field 0 (model) - - 1093 330 load_var 4 (out) - 331 return - - 1022 332 load_var 8 (_17) - - 1023 333 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 334 throw -} - -function openai.internal._openai_stream_failure(event: openai.internal.OaStreamEvent) -> ai.errors.Failure { - 1002 0 load_var 1 (event) - 1 load_field 8 (response) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +19 (to 25) - - 1005 7 load_var 1 (event) - 8 load_field 11 (error) - 9 store_var 3 (_7) - 10 load_var 3 (_7) - 11 narrow_bind 1 3 - 12 pop_jump_if_false +2 (to 14) - 13 jump +9 (to 22) - - 1008 14 load_var 1 (event) - 15 load_field 9 (code) - 16 load_var 1 (event) - 17 load_field 10 (message) - 18 load_const 2 (null) - 19 init_instance 0 (openai.internal.OaErrorBody .code, .message, .type) - 20 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 21 jump +6 (to 27) - - 1005 22 load_var 3 (_7) - - 1006 23 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 24 jump +3 (to 27) - - 1002 25 load_var 2 (_3) - - 1003 26 call 1041 ntypeargs=0 (openai.internal._openai_response_failure) - 27 return -} - -function openai.internal._openai_text(c: openai.ResponsesClient) -> openai.internal.OaTextParams | null { - 649 0 load_var 1 (c) - 1 load_field 8 (verbosity) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 pop_jump_if_false +2 (to 6) - 5 jump +5 (to 10) - - 652 6 load_var 1 (c) - 7 load_field 8 (verbosity) - 8 init_instance 0 (openai.internal.OaTextParams .verbosity) - - 649 9 jump +2 (to 11) - - 650 10 load_const 0 (null) - 11 return -} - -function openai.internal._openai_tool_choice(tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null, wants_image: bool) -> string | openai.internal.OaToolChoiceObject | null { - 631 0 load_var 2 (wants_image) - 1 pop_jump_if_false +2 (to 3) - 2 jump +10 (to 12) - - 634 3 load_var 1 (tools) - 4 load_const 0 (null) - 5 cmp_op == - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - - 636 8 load_const 1 ("auto") - - 634 9 jump +5 (to 14) - - 635 10 load_const 0 (null) - - 634 11 jump +3 (to 14) - - 632 12 load_const 2 ("image_generation") - 13 init_instance 0 (openai.internal.OaToolChoiceObject .type) - 14 return -} - -function openai.internal._openai_tools(toolbox: ai.tools.Toolbox, wants_image: bool) -> (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null { - 608 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (tools) - - 609 3 load_var 1 (toolbox) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +24 (to 41) - 18 load_var 5 (_6) - 19 store_var 6 (t) - - 613 20 load_var 6 (t) - 21 load_field 0 (name) - 22 store_var 7 (_12) - - 614 23 load_var 6 (t) - 24 load_field 1 (description) - 25 store_var 8 (_13) - - 615 26 load_type 6 - 27 load_var 6 (t) - 28 load_field 2 (input_schema) - 29 call 355 ntypeargs=1 (baml.json.to_json) - 30 store_var 9 (_14) - - 610 31 load_type 0 - 32 load_var 3 (tools) - - 611 33 load_const 7 ("function") - 34 load_var2 7 8 - 35 load_var 9 (_14) - 36 load_const 8 (false) - 37 init_instance 0 (openai.internal.OaFunctionTool .type, .name, .description, .parameters, .strict) - - 610 38 call 4 ntypeargs=1 (baml.Array.push) - 39 pop 1 - 40 jump -31 (to 9) - - 620 41 load_var 2 (wants_image) - 42 pop_jump_if_false +7 (to 49) - - 621 43 load_type 0 - 44 load_var 3 (tools) - 45 load_const 9 ("image_generation") - 46 init_instance 1 (openai.internal.OaBuiltinTool .type) - 47 call 4 ntypeargs=1 (baml.Array.push) - 48 pop 1 - - 623 49 load_var 3 (tools) - 50 container_len - 51 store_var 10 (_22) - 52 load_var 10 (_22) - 53 load_const 10 (0) - 54 cmp_int_op == - 55 pop_jump_if_false +2 (to 57) - 56 jump +3 (to 59) - - 626 57 load_var 3 (tools) - - 623 58 jump +2 (to 60) - - 624 59 load_const 11 (null) - 60 return -} - -function openai.internal._openai_transient_code(code: string) -> bool { - 771 0 load_var 1 (code) - 1 load_const 0 ("server_error") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 772 6 load_var 1 (code) - 7 load_const 1 ("timeout") - 8 call 147 ntypeargs=0 (baml.String.includes) - - 771 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 773 12 load_var 1 (code) - 13 load_const 2 ("timed_out") - 14 call 147 ntypeargs=0 (baml.String.includes) - - 771 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 774 18 load_var 1 (code) - 19 load_const 3 ("overloaded") - 20 call 147 ntypeargs=0 (baml.String.includes) - - 771 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 775 24 load_var 1 (code) - 25 load_const 4 ("unavailable") - 26 call 147 ntypeargs=0 (baml.String.includes) - - 771 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 776 30 load_var 1 (code) - 31 load_const 5 ("try_again") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 return -} - -function openai.internal._openai_url(c: openai.ResponsesClient) -> string { - 670 0 load_var 1 (c) - 1 call 1013 ntypeargs=0 (openai.ResponsesClient.resolved_base_url) - 2 store_var_load_var 3 (_3) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("https://api.openai.com/v1") - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 store_var 2 (base) - - 671 10 load_var 2 (base) - 11 load_const 2 ("/") - 12 call 149 ntypeargs=0 (baml.String.ends_with) - 13 pop_jump_if_false +2 (to 15) - 14 jump +4 (to 18) - - 674 15 load_var 2 (base) - 16 store_var 4 (trimmed) - - 671 17 jump +11 (to 28) - - 672 18 load_var 2 (base) - 19 call 139 ntypeargs=0 (baml.String.length) - 20 store_var 5 (_9) - 21 load_var 2 (base) - 22 load_const 3 (0) - 23 load_var 5 (_9) - 24 load_const 4 (1) - 25 sub_int - 26 call 153 ntypeargs=0 (baml.String.slice) - 27 store_var 4 (trimmed) - - 676 28 load_type 5 - 29 load_var 4 (trimmed) - 30 call 138 ntypeargs=1 (baml.String.from) - 31 load_const 6 ("/responses") - 32 bin_op + - 33 store_var 6 (url) - - 677 34 load_var 1 (c) - 35 load_field 13 (query_params) - 36 store_var 7 (_15) - 37 load_var 7 (_15) - 38 narrow_bind 7 7 - 39 pop_jump_if_false +65 (to 104) - 40 load_var 7 (_15) - 41 store_var 8 (params) - - 678 42 load_type 5 - 43 alloc_array 0 - 44 store_var 9 (pairs) - - 679 45 load_type 5 - 46 load_type 5 - 47 load_var 8 (params) - 48 call 35 ntypeargs=2 (baml.Map.keys) - 49 load_type 8 - 50 load_const 9 ("iter") - 51 virtual_call nargs=1 ntypeargs=0 - 52 store_var 10 (_21) - 53 load_var 10 (_21) - 54 load_type 10 - 55 load_const 11 ("next") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 11 (_22) - 58 load_var 11 (_22) - 59 is_type 12 - 60 pop_jump_if_false +2 (to 62) - 61 jump +35 (to 96) - 62 load_var 11 (_22) - 63 store_var_load_var 12 (key) - - 681 64 call 1019 ntypeargs=0 (openai.internal._openai_percent_encode) - 65 store_var 14 (_30) - 66 load_type 5 - 67 load_var 14 (_30) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 13 (_29) - 70 load_type 5 - 71 load_type 5 - 72 load_var2 8 12 - 73 call 38 ntypeargs=2 (baml.Map.get) - 74 store_var_load_var 17 (_36) - 75 load_const 0 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 13 ("") - 79 store_var 17 (_36) - 80 load_var 17 (_36) - 81 call 1019 ntypeargs=0 (openai.internal._openai_percent_encode) - 82 store_var 16 (_34) - 83 load_type 5 - 84 load_var 16 (_34) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 15 (_33) - - 680 87 load_type 5 - 88 load_var2 9 13 - - 681 89 load_const 14 ("=") - 90 bin_op + - 91 load_var 15 (_33) - 92 bin_op + - - 680 93 call 4 ntypeargs=1 (baml.Array.push) - 94 pop 1 - 95 jump -42 (to 53) - - 684 96 load_var 9 (pairs) - 97 container_len - 98 store_var 18 (_45) - 99 load_var 18 (_45) - 100 load_const 3 (0) - 101 cmp_int_op > - 102 pop_jump_if_false +2 (to 104) - 103 jump +3 (to 106) - - 688 104 load_var 6 (url) - 105 jump +19 (to 124) - - 685 106 load_type 5 - 107 load_var 6 (url) - 108 call 138 ntypeargs=1 (baml.String.from) - 109 store_var 19 (_47) - 110 load_type 5 - 111 load_var 9 (pairs) - 112 load_const 15 ("&") - 113 call 15 ntypeargs=1 (baml.Array.join) - 114 store_var 21 (_51) - 115 load_type 5 - 116 load_var 21 (_51) - 117 call 138 ntypeargs=1 (baml.String.from) - 118 store_var 20 (_50) - 119 load_var 19 (_47) - 120 load_const 16 ("?") - 121 bin_op + - 122 load_var 20 (_50) - 123 bin_op + - 124 return -} - -function openai.internal._openai_wants_image(output_type: type) -> bool { - 604 0 load_var 1 (output_type) - 1 call 985 ntypeargs=0 (ai.internal._media_shape) - 2 load_const 0 (":image") - 3 call 149 ntypeargs=0 (baml.String.ends_with) - 4 return -} - -function openai.internal._reject(provider: string, detail: string) -> ai.errors.InvalidRequest { - 38 0 load_var 1 (provider) - 1 load_const 0 (null) - 2 load_var 2 (detail) - 3 load_const 0 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 return -} - -function openai.internal.chat_build_request(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> openai.internal.ChatRequest { - 1005 0 load_var 3 (input) - 1 load_field 0 (prompt) - 2 store_var 5 (_6) - 3 load_var 3 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 5 (_6) - 7 call_indirect - - 1006 8 load_var 1 (compat) - 9 call 1115 ntypeargs=0 (openai.internal.chat_lower_prompt) - 10 store_var 6 (messages) - - 1007 11 load_var 3 (input) - 12 load_field 1 (journal) - 13 store_var 7 (_12) - 14 load_var2 1 2 - 15 call 1101 ntypeargs=0 (openai.internal.chat_client_id) - 16 store_var 8 (_13) - 17 load_var2 7 8 - 18 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 1008 19 call 1116 ntypeargs=0 (openai.internal.chat_lower_journal) - 20 load_type 0 - 21 load_const 1 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 9 (_16) - 24 load_var 9 (_16) - 25 load_type 2 - 26 load_const 3 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 10 (_17) - 29 load_var 10 (_17) - 30 is_type 4 - 31 pop_jump_if_false +2 (to 33) - 32 jump +6 (to 38) - - 1009 33 load_type 5 - 34 load_var2 6 10 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -13 (to 24) - - 1015 38 load_var 1 (compat) - 39 load_field 9 (max_tokens_key) - 40 load_const 6 ("max_completion_tokens") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +5 (to 48) - - 1018 44 load_var 2 (params) - 45 load_field 3 (max_tokens) - 46 store_var 11 (max_tokens) - - 1015 47 jump +3 (to 50) - - 1016 48 load_const 7 (null) - 49 store_var 11 (max_tokens) - - 1020 50 load_var 1 (compat) - 51 load_field 9 (max_tokens_key) - 52 load_const 8 ("max_completion_tokens") - 53 cmp_op == - 54 pop_jump_if_false +2 (to 56) - 55 jump +5 (to 60) - - 1023 56 load_var 2 (params) - 57 load_field 4 (max_completion_tokens) - 58 store_var 12 (max_completion_tokens) - - 1020 59 jump +12 (to 71) - - 1021 60 load_var 2 (params) - 61 load_field 4 (max_completion_tokens) - 62 store_var_load_var 13 (_30) - 63 load_const 7 (null) - 64 cmp_op == - 65 pop_jump_if_false +4 (to 69) - 66 load_var 2 (params) - 67 load_field 3 (max_tokens) - 68 store_var 13 (_30) - 69 load_var 13 (_30) - 70 store_var 12 (max_completion_tokens) - - 1030 71 load_var 11 (max_tokens) - 72 load_const 7 (null) - 73 call 672 ntypeargs=0 (baml.ops.equals_equals) - 74 jump_if_false +5 (to 79) - 75 pop 1 - - 1031 76 load_var 12 (max_completion_tokens) - 77 load_const 7 (null) - 78 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 1030 79 jump_if_false +7 (to 86) - 80 pop 1 - - 1032 81 load_var 2 (params) - 82 load_field 10 (request_body) - 83 load_const 9 ("max_tokens") - 84 call 1120 ntypeargs=0 (openai.internal._chat_body_mentions) - 85 unary_op ! - - 1030 86 jump_if_false +7 (to 93) - 87 pop 1 - - 1033 88 load_var 2 (params) - 89 load_field 10 (request_body) - 90 load_const 10 ("max_completion_tokens") - 91 call 1120 ntypeargs=0 (openai.internal._chat_body_mentions) - 92 unary_op ! - - 1029 93 pop_jump_if_false +20 (to 113) - - 1035 94 load_var 1 (compat) - 95 load_field 10 (default_max_tokens) - 96 store_var 14 (_44) - 97 load_var 14 (_44) - 98 narrow_bind 11 14 - 99 pop_jump_if_false +14 (to 113) - 100 load_var 14 (_44) - 101 store_var 15 (floor) - - 1036 102 load_var 1 (compat) - 103 load_field 9 (max_tokens_key) - 104 load_const 12 ("max_completion_tokens") - 105 cmp_op == - 106 pop_jump_if_false +2 (to 108) - 107 jump +4 (to 111) - - 1039 108 load_var 15 (floor) - 109 store_var 11 (max_tokens) - - 1036 110 jump +3 (to 113) - - 1037 111 load_var 15 (floor) - 112 store_var 12 (max_completion_tokens) - - 1044 113 load_var 3 (input) - 114 load_field 2 (toolbox) - 115 call 1124 ntypeargs=0 (openai.internal._chat_tools) - 116 store_var 16 (tools) - - 1045 117 load_var 16 (tools) - 118 load_const 7 (null) - 119 call 672 ntypeargs=0 (baml.ops.equals_equals) - 120 pop_jump_if_false +2 (to 122) - 121 jump +4 (to 125) - - 1048 122 load_const 13 ("auto") - 123 store_var 17 (tool_choice) - - 1045 124 jump +3 (to 127) - - 1046 125 load_const 7 (null) - 126 store_var 17 (tool_choice) - - 1050 127 load_var 4 (stream) - 128 pop_jump_if_false +2 (to 130) - 129 jump +4 (to 133) - - 1053 130 load_const 7 (null) - 131 store_var 18 (stream_flag) - - 1050 132 jump +3 (to 135) - - 1051 133 load_const 14 (true) - 134 store_var 18 (stream_flag) - - 1055 135 load_var 4 (stream) - 136 jump_if_false +4 (to 140) - 137 pop 1 - 138 load_var 1 (compat) - 139 load_field 8 (send_stream_options) - 140 pop_jump_if_false +2 (to 142) - 141 jump +4 (to 145) - - 1058 142 load_const 7 (null) - 143 store_var 19 (stream_options) - - 1055 144 jump +4 (to 148) - - 1056 145 load_const 14 (true) - 146 init_instance 0 (openai.internal.ChatStreamOptions .include_usage) - 147 store_var 19 (stream_options) - - 1062 148 load_var 2 (params) - 149 load_field 0 (model) - - 1063 150 load_var2 6 2 - - 1064 151 load_field 2 (temperature) - - 1065 152 load_var2 11 12 - - 1067 153 load_var 2 (params) - 154 load_field 5 (top_p) - - 1068 155 load_var 2 (params) - 156 load_field 6 (stop) - - 1069 157 load_var 2 (params) - 158 load_field 7 (seed) - - 1070 159 load_var2 16 17 - - 1072 160 load_var2 18 19 - - 1073 161 init_instance 1 (openai.internal.ChatRequest .model, .messages, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .tools, .tool_choice, .stream, .stream_options) - 162 return -} - -function openai.internal.chat_client_id(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - 196 0 load_type 0 - 1 load_var 1 (compat) - 2 load_field 0 (provider) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_4) - 5 load_type 0 - 6 load_var 2 (params) - 7 load_field 0 (model) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 4 (_7) - 10 load_var 3 (_4) - 11 load_const 1 ("/") - 12 bin_op + - 13 load_var 4 (_7) - 14 bin_op + - 15 return -} - -function openai.internal.chat_invoke(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1328 0 load_var2 1 2 - 1 load_var 3 (input) - 2 load_const 0 (false) - 3 call 1127 ntypeargs=0 (openai.internal.chat_render) - 4 store_var 4 (request) - - 1331 5 load_var 1 (compat) - 6 load_field 0 (provider) - 7 store_var 5 (_6) - - 1332 8 load_var 2 (params) - 9 load_field 10 (request_body) - 10 call 1109 ntypeargs=0 (openai.internal._chat_audio_output_mime) - 11 store_var 6 (_7) - - 1330 12 load_var2 4 5 - 13 load_var 6 (_7) - - 1329 14 call 1133 ntypeargs=0 (openai.internal._chat_send) - 15 return -} - -function openai.internal.chat_invoke_stream(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 1539 3 load_var2 1 2 - 4 load_var 3 (input) - 5 load_const 0 (true) - 6 call 1127 ntypeargs=0 (openai.internal.chat_render) - 7 store_var 4 (request) - - 1540 8 load_var 1 (compat) - 9 load_field 0 (provider) - 10 call 1135 ntypeargs=0 (openai.internal.ChatStreamDecoder.new) - 11 store_deref 5 - - 1541 12 load_var 4 (request) - 13 sys_op 252 (baml.http.fetch_sse) - 14 jump +13 (to 27) - 15 load_var 6 (e) - 16 throw_if_panic - - 1542 17 load_var 1 (compat) - 18 load_field 0 (provider) - 19 store_var 7 (_11) - 20 load_type 1 - 21 load_var 6 (e) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 8 (_12) - 24 load_var2 7 8 - 25 call 1139 ntypeargs=0 (openai.internal._chat_stream_failure) - 26 throw - - 1551 27 load_var 5 (decoder) - 28 make_closure 3049 1 - - 1552 29 load_var 1 (compat) - 30 load_field 0 (provider) - - 1549 31 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 32 return -} - -function openai.internal.chat_lower_journal(j: ai.Journal) -> openai.internal.ChatMessage[] { - 721 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 722 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +189 (to 206) - 18 load_var 4 (_5) - 19 store_var 5 (event) - - 723 20 load_var 5 (event) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +170 (to 195) - 26 load_var 5 (event) - 27 store_var 7 (_15) - 28 load_var 7 (_15) - 29 narrow_bind 7 7 - 30 pop_jump_if_false +2 (to 32) - 31 jump +49 (to 80) - 32 load_var 5 (event) - 33 store_var 25 (_62) - 34 load_var 25 (_62) - 35 narrow_bind 8 25 - 36 pop_jump_if_false +2 (to 38) - 37 jump +29 (to 66) - 38 load_var 5 (event) - 39 store_var 27 (_69) - 40 load_var 27 (_69) - 41 narrow_bind 9 27 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 27 (_69) - 44 store_var 28 (failed) - - 800 45 load_type 10 - - 796 46 load_var 28 (failed) - 47 load_field 1 (message) - 48 load_const 11 ("error") - 49 load_type 12 - 50 load_type 12 - 51 alloc_map 1 - - 800 52 call 355 ntypeargs=1 (baml.json.to_json) - 53 call 351 ntypeargs=0 (baml.json.stringify) - 54 store_var 29 (_75) - - 797 55 load_type 0 - 56 load_var 2 (out) - - 798 57 load_const 13 ("tool") - 58 load_var 29 (_75) - 59 load_const 14 (null) - - 802 60 load_var 28 (failed) - 61 load_field 0 (id) - 62 init_instance 0 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 797 63 call 4 ntypeargs=1 (baml.Array.push) - 64 pop 1 - 65 jump -56 (to 9) - - 723 66 load_var 25 (_62) - 67 store_var 26 (completed) - - 785 68 load_type 0 - 69 load_var 2 (out) - - 786 70 load_const 15 ("tool") - - 788 71 load_var 26 (completed) - 72 load_field 1 (output) - 73 load_const 14 (null) - - 790 74 load_var 26 (completed) - 75 load_field 0 (id) - 76 init_instance 1 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 785 77 call 4 ntypeargs=1 (baml.Array.push) - 78 pop 1 - 79 jump -70 (to 9) - - 736 80 load_const 16 ("") - 81 store_var 8 (text) - - 737 82 load_type 17 - 83 alloc_array 0 - 84 store_var 9 (calls) - - 723 85 load_var 7 (_15) - 86 load_field 0 (content) - 87 load_type 18 - 88 load_const 19 ("iter") - 89 virtual_call nargs=1 ntypeargs=0 - 90 store_var 10 (_20) - - 738 91 load_var 10 (_20) - 92 load_type 20 - 93 load_const 21 ("next") - 94 virtual_call nargs=1 ntypeargs=0 - 95 store_var 11 (_21) - 96 load_var 11 (_21) - 97 is_type 5 - 98 pop_jump_if_false +2 (to 100) - 99 jump +52 (to 151) - 100 load_var 11 (_21) - 101 store_var 12 (block) - - 739 102 load_var 12 (block) - 103 store_var 13 (_25) - 104 load_var 13 (_25) - 105 narrow_bind 22 13 - 106 pop_jump_if_false +2 (to 108) - 107 jump +29 (to 136) - 108 load_var 12 (block) - 109 store_var 17 (_33) - 110 load_var 17 (_33) - 111 narrow_bind 23 17 - 112 pop_jump_if_false -21 (to 91) - 113 load_var 17 (_33) - 114 store_var 18 (use) - - 747 115 load_var 18 (use) - 116 load_field 0 (id) - 117 store_var 19 (_37) - - 750 118 load_var 18 (use) - 119 load_field 1 (name) - 120 store_var 20 (_39) - - 751 121 load_type 24 - 122 load_var 18 (use) - 123 load_field 2 (args) - 124 call 355 ntypeargs=1 (baml.json.to_json) - 125 call 351 ntypeargs=0 (baml.json.stringify) - 126 store_var 21 (_40) - - 745 127 load_type 17 - 128 load_var2 9 19 - - 746 129 load_const 25 ("function") - - 749 130 load_var2 20 21 - 131 init_instance 2 (openai.internal.ChatToolCallFunction .name, .arguments) - 132 init_instance 3 (openai.internal.ChatToolCall .id, .type, .fn) - - 745 133 call 4 ntypeargs=1 (baml.Array.push) - 134 pop 1 - 135 jump -44 (to 91) - - 739 136 load_var 13 (_25) - 137 store_var 14 (t) - - 741 138 load_type 12 - 139 load_var 8 (text) - 140 call 138 ntypeargs=1 (baml.String.from) - 141 store_var 15 (_27) - 142 load_type 12 - 143 load_var 14 (t) - 144 load_field 0 (text) - 145 call 138 ntypeargs=1 (baml.String.from) - 146 store_var 16 (_30) - 147 load_var2 15 16 - 148 bin_op + - 149 store_var 8 (text) - - 739 150 jump -59 (to 91) - - 762 151 load_var 8 (text) - 152 load_const 26 ("") - 153 cmp_op == - 154 pop_jump_if_false +2 (to 156) - 155 jump +4 (to 159) - - 765 156 load_var 8 (text) - 157 store_var 22 (content) - - 762 158 jump +3 (to 161) - - 763 159 load_const 14 (null) - 160 store_var 22 (content) - - 767 161 load_var 9 (calls) - 162 container_len - 163 store_var 24 (_50) - 164 load_var 24 (_50) - 165 load_const 27 (0) - 166 cmp_int_op == - 167 pop_jump_if_false +2 (to 169) - 168 jump +4 (to 172) - - 770 169 load_var 9 (calls) - 170 store_var 23 (tool_calls) - - 767 171 jump +3 (to 174) - - 768 172 load_const 14 (null) - 173 store_var 23 (tool_calls) - - 772 174 load_var 22 (content) - 175 load_const 14 (null) - 176 call 672 ntypeargs=0 (baml.ops.equals_equals) - 177 unary_op ! - 178 jump_if_false +2 (to 180) - 179 jump +6 (to 185) - 180 pop 1 - 181 load_var 23 (tool_calls) - 182 load_const 14 (null) - 183 call 672 ntypeargs=0 (baml.ops.equals_equals) - 184 unary_op ! - 185 pop_jump_if_false -176 (to 9) - - 773 186 load_type 0 - 187 load_var 2 (out) - - 774 188 load_const 28 ("assistant") - - 776 189 load_var2 22 23 - - 777 190 load_const 14 (null) - 191 init_instance 4 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 773 192 call 4 ntypeargs=1 (baml.Array.push) - 193 pop 1 - 194 jump -185 (to 9) - - 725 195 load_type 0 - 196 load_var 2 (out) - - 726 197 load_const 29 ("user") - - 723 198 load_var 6 (_9) - 199 load_field 0 (content) - 200 load_const 14 (null) - 201 load_const 14 (null) - 202 init_instance 5 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 725 203 call 4 ntypeargs=1 (baml.Array.push) - 204 pop 1 - 205 jump -196 (to 9) - - 810 206 load_var 2 (out) - 207 return -} - -function openai.internal.chat_lower_prompt(prompt: ai.Prompt, compat: openai.internal.ChatCompat) -> openai.internal.ChatMessage[] { - 670 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (lowered) - - 671 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +85 (to 102) - 18 load_var 5 (_6) - 19 store_var 6 (message) - - 672 20 load_var 6 (message) - 21 load_field 0 (role) - 22 store_var_load_var 8 (_11) - 23 load_const 6 ("") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +13 (to 39) - 27 load_var 8 (_11) - 28 load_const 7 ("tool") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +5 (to 36) - - 675 32 load_var 6 (message) - 33 load_field 0 (role) - 34 store_var 7 (role) - - 672 35 jump +7 (to 42) - - 674 36 load_const 8 ("user") - 37 store_var 7 (role) - - 672 38 jump +4 (to 42) - - 673 39 load_var 2 (compat) - 40 load_field 11 (default_role) - 41 store_var 7 (role) - - 677 42 load_var2 6 2 - 43 call 1111 ntypeargs=0 (openai.internal._chat_prompt_parts) - 44 store_var 9 (parts) - - 681 45 load_var2 9 6 - 46 load_field 3 (metadata) - 47 call 1112 ntypeargs=0 (openai.internal._chat_apply_metadata) - 48 pop 1 - - 682 49 load_const 9 (false) - 50 store_var 10 (merged) - - 683 51 load_var 3 (lowered) - 52 container_len - 53 store_var 11 (_22) - 54 load_type 0 - 55 load_var2 3 11 - 56 load_const 10 (1) - 57 sub_int - 58 call 3 ntypeargs=1 (baml.Array.at) - 59 store_var 12 (_24) - 60 load_var 12 (_24) - 61 narrow_bind 11 12 - 62 pop_jump_if_false +30 (to 92) - 63 load_var 12 (_24) - 64 store_var_load_var 13 (last) - - 684 65 load_field 0 (role) - 66 load_var 7 (role) - 67 cmp_op == - 68 pop_jump_if_false +24 (to 92) - - 685 69 load_var 9 (parts) - 70 load_type 12 - 71 load_const 13 ("iter") - 72 virtual_call nargs=1 ntypeargs=0 - 73 store_var 14 (_30) - 74 load_var 14 (_30) - 75 load_type 14 - 76 load_const 15 ("next") - 77 virtual_call nargs=1 ntypeargs=0 - 78 store_var 15 (_31) - 79 load_var 15 (_31) - 80 is_type 5 - 81 pop_jump_if_false +2 (to 83) - 82 jump +8 (to 90) - - 686 83 load_type 16 - 84 load_var 13 (last) - 85 load_field 1 (parts) - - 685 86 load_var 15 (_31) - - 686 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - 89 jump -15 (to 74) - - 688 90 load_const 17 (true) - 91 store_var 10 (merged) - - 691 92 load_var 10 (merged) - 93 unary_op ! - 94 pop_jump_if_false -85 (to 9) - - 692 95 load_type 0 - 96 load_var2 3 7 - 97 load_var 9 (parts) - 98 init_instance 0 (openai.internal.ChatPromptMessage .role, .parts) - 99 call 4 ntypeargs=1 (baml.Array.push) - 100 pop 1 - 101 jump -92 (to 9) - - 695 102 load_type 18 - 103 alloc_array 0 - 104 store_var 16 (out) - - 696 105 load_var 3 (lowered) - 106 load_type 19 - 107 load_const 20 ("iter") - 108 virtual_call nargs=1 ntypeargs=0 - 109 store_var 17 (_48) - 110 load_var 17 (_48) - 111 load_type 21 - 112 load_const 22 ("next") - 113 virtual_call nargs=1 ntypeargs=0 - 114 store_var 18 (_49) - 115 load_var 18 (_49) - 116 is_type 5 - 117 pop_jump_if_false +2 (to 119) - 118 jump +21 (to 139) - 119 load_var 18 (_49) - 120 store_var 19 (message) - - 699 121 load_var 19 (message) - 122 load_field 0 (role) - 123 store_var 20 (_55) - - 700 124 load_var 19 (message) - 125 load_field 1 (parts) - 126 load_var 2 (compat) - 127 load_field 6 (collapse_text_content) - 128 call 1114 ntypeargs=0 (openai.internal._chat_content) - 129 store_var 21 (_56) - - 697 130 load_type 18 - 131 load_var2 16 20 - - 698 132 load_var 21 (_56) - 133 load_const 23 (null) - 134 load_const 23 (null) - 135 init_instance 1 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 697 136 call 4 ntypeargs=1 (baml.Array.push) - 137 pop 1 - 138 jump -28 (to 110) - - 706 139 load_var 16 (out) - 140 return -} - -function openai.internal.chat_parse(response: openai.internal.CcResponse, provider: string, raw: string, audio_mime: string) -> ai.ModelTurn { - 0 load_var 4 (audio_mime) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 1179 4 load_const 1 ("audio/wav") - 5 store_var 4 (audio_mime) - - 1181 6 load_var 1 (response) - 7 load_field 2 (choices) - 8 store_var_load_var 5 (_7) - 9 load_const 2 (null) - 10 cmp_op == - 11 pop_jump_if_false +4 (to 15) - 12 load_type 3 - 13 alloc_array 0 - 14 store_var 5 (_7) - - 1182 15 load_type 3 - - 1181 16 load_var 5 (_7) - 17 load_const 4 (0) - - 1182 18 call 3 ntypeargs=1 (baml.Array.at) - 19 store_var 7 (_13) - 20 load_var 7 (_13) - 21 narrow_bind 5 7 - 22 pop_jump_if_false +2 (to 24) - 23 jump +4 (to 27) - - 1184 24 load_var2 2 3 - 25 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 26 throw - - 1182 27 load_var 7 (_13) - 28 store_var 6 (choice) - - 1186 29 load_var 6 (choice) - 30 load_field 1 (message) - 31 store_var 9 (_18) - 32 load_var 9 (_18) - 33 narrow_bind 6 9 - 34 pop_jump_if_false +2 (to 36) - 35 jump +4 (to 39) - - 1188 36 load_var2 2 3 - 37 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 38 throw - - 1186 39 load_var 9 (_18) - 40 store_var 8 (message) - - 1191 41 load_type 7 - 42 alloc_array 0 - 43 store_var 10 (content) - - 1192 44 load_var 8 (message) - 45 load_field 4 (reasoning_content) - 46 store_var 11 (_23) - 47 load_var 11 (_23) - 48 narrow_bind 8 11 - 49 pop_jump_if_false +11 (to 60) - 50 load_var 11 (_23) - 51 store_var_load_var 12 (reasoning) - - 1193 52 load_const 9 ("") - 53 cmp_op != - 54 pop_jump_if_false +6 (to 60) - - 1194 55 load_type 7 - 56 load_var2 10 12 - 57 init_instance 2 (ai.content.Reasoning .summary) - 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - - 1197 60 load_var 8 (message) - 61 load_field 1 (content) - 62 store_var 13 (_31) - 63 load_var 13 (_31) - 64 store_var 14 (_32) - 65 load_var 14 (_32) - 66 narrow_bind 8 14 - 67 pop_jump_if_false +2 (to 69) - 68 jump +69 (to 137) - 69 load_var 13 (_31) - 70 store_var 15 (_38) - 71 load_var 15 (_38) - 72 narrow_bind 10 15 - 73 pop_jump_if_false +69 (to 142) - 74 load_var 15 (_38) - 75 load_type 11 - 76 load_const 12 ("iter") - 77 virtual_call nargs=1 ntypeargs=0 - 78 store_var 16 (_41) - - 1203 79 load_var 16 (_41) - 80 load_type 13 - 81 load_const 14 ("next") - 82 virtual_call nargs=1 ntypeargs=0 - 83 store_var 17 (_42) - 84 load_var 17 (_42) - 85 is_type 15 - 86 pop_jump_if_false +2 (to 88) - 87 jump +55 (to 142) - 88 load_var 17 (_42) - 89 store_var_load_var 18 (part) - - 1204 90 load_field 0 (type) - 91 store_var_load_var 19 (_47) - 92 load_const 2 (null) - 93 cmp_op == - 94 pop_jump_if_false +3 (to 97) - 95 load_const 16 ("") - 96 store_var 19 (_47) - 97 load_var 19 (_47) - 98 load_const 17 ("image_url") - 99 cmp_op == - 100 pop_jump_if_false +2 (to 102) - 101 jump +13 (to 114) - - 1211 102 load_var 18 (part) - 103 load_field 1 (text) - 104 store_var 22 (_63) - 105 load_var 22 (_63) - 106 narrow_bind 8 22 - 107 pop_jump_if_false -28 (to 79) - - 1212 108 load_type 7 - 109 load_var2 10 22 - - 1211 110 init_instance 3 (ai.content.Text .text) - - 1212 111 call 4 ntypeargs=1 (baml.Array.push) - 112 pop 1 - 113 jump -34 (to 79) - - 1206 114 load_var 18 (part) - 115 load_field 2 (image_url) - 116 load_const 2 (null) - 117 cmp_op == - 118 pop_jump_if_false +2 (to 120) - 119 jump +5 (to 124) - 120 load_var 18 (part) - 121 load_field 2 (image_url) - 122 load_field 0 (0) - 123 jump +2 (to 125) - 124 load_const 2 (null) - 125 store_var 20 (_56) - 126 load_var 20 (_56) - 127 narrow_bind 8 20 - 128 pop_jump_if_false -49 (to 79) - 129 load_var 20 (_56) - - 1207 130 call 1129 ntypeargs=0 (openai.internal._chat_media_block) - 131 store_var 21 (_59) - 132 load_type 7 - 133 load_var2 10 21 - 134 call 4 ntypeargs=1 (baml.Array.push) - 135 pop 1 - 136 jump -57 (to 79) - - 1199 137 load_type 7 - 138 load_var2 10 14 - - 1197 139 init_instance 4 (ai.content.Text .text) - - 1199 140 call 4 ntypeargs=1 (baml.Array.push) - 141 pop 1 - - 1222 142 load_var 8 (message) - 143 load_field 2 (images) - 144 store_var_load_var 23 (_70) - 145 load_const 2 (null) - 146 cmp_op == - 147 pop_jump_if_false +4 (to 151) - 148 load_type 18 - 149 alloc_array 0 - 150 store_var 23 (_70) - 151 load_var 23 (_70) - 152 load_type 19 - 153 load_const 20 ("iter") - 154 virtual_call nargs=1 ntypeargs=0 - 155 store_var 24 (_74) - - 1223 156 load_var 24 (_74) - 157 load_type 21 - 158 load_const 22 ("next") - 159 virtual_call nargs=1 ntypeargs=0 - 160 store_var 25 (_75) - 161 load_var 25 (_75) - 162 is_type 15 - 163 pop_jump_if_false +2 (to 165) - 164 jump +33 (to 197) - 165 load_var 25 (_75) - 166 store_var_load_var 26 (image) - - 1224 167 load_field 1 (image_url) - 168 load_const 2 (null) - 169 cmp_op == - 170 pop_jump_if_false +2 (to 172) - 171 jump +5 (to 176) - 172 load_var 26 (image) - 173 load_field 1 (image_url) - 174 load_field 0 (0) - 175 jump +2 (to 177) - 176 load_const 2 (null) - 177 store_var_load_var 27 (_80) - 178 load_const 2 (null) - 179 cmp_op == - 180 pop_jump_if_false +4 (to 184) - 181 load_var 26 (image) - 182 load_field 2 (url) - 183 store_var 27 (_80) - 184 load_var 27 (_80) - 185 store_var 28 (_86) - 186 load_var 28 (_86) - 187 narrow_bind 8 28 - 188 pop_jump_if_false -32 (to 156) - 189 load_var 28 (_86) - - 1225 190 call 1129 ntypeargs=0 (openai.internal._chat_media_block) - 191 store_var 29 (_89) - 192 load_type 7 - 193 load_var2 10 29 - 194 call 4 ntypeargs=1 (baml.Array.push) - 195 pop 1 - 196 jump -40 (to 156) - - 1230 197 load_var 8 (message) - 198 load_field 3 (audio) - 199 store_var 30 (_93) - 200 load_var 30 (_93) - 201 narrow_bind 23 30 - 202 pop_jump_if_false +40 (to 242) - 203 load_var 30 (_93) - 204 store_var_load_var 31 (audio) - - 1231 205 load_field 2 (transcript) - 206 store_var 32 (_96) - 207 load_var 32 (_96) - 208 narrow_bind 8 32 - 209 pop_jump_if_false +11 (to 220) - 210 load_var 32 (_96) - 211 store_var_load_var 33 (transcript) - - 1232 212 load_const 24 ("") - 213 cmp_op != - 214 pop_jump_if_false +6 (to 220) - - 1233 215 load_type 7 - 216 load_var2 10 33 - 217 init_instance 5 (ai.content.Text .text) - 218 call 4 ntypeargs=1 (baml.Array.push) - 219 pop 1 - - 1236 220 load_var 31 (audio) - 221 load_field 1 (data) - 222 store_var 34 (_105) - 223 load_var 34 (_105) - 224 narrow_bind 8 34 - 225 pop_jump_if_false +17 (to 242) - 226 load_var 34 (_105) - 227 store_var_load_var 35 (data) - - 1237 228 load_const 25 ("") - 229 cmp_op != - 230 pop_jump_if_false +12 (to 242) - - 1240 231 load_var2 35 4 - 232 call 335 ntypeargs=0 (baml.media.Audio.from_base64) - - 1241 233 load_var 31 (audio) - 234 load_field 0 (id) - 235 load_const 0 () - - 1239 236 call 904 ntypeargs=0 (ai.content.Media.new) - 237 store_var 36 (_110) - - 1238 238 load_type 7 - 239 load_var2 10 36 - 240 call 4 ntypeargs=1 (baml.Array.push) - 241 pop 1 - - 1247 242 load_var 8 (message) - 243 load_field 6 (tool_calls) - 244 store_var_load_var 38 (_116) - 245 load_const 2 (null) - 246 cmp_op == - 247 pop_jump_if_false +4 (to 251) - 248 load_type 26 - 249 alloc_array 0 - 250 store_var 38 (_116) - 251 load_var 38 (_116) - 252 store_var 37 (calls) - - 1248 253 load_var2 10 37 - 254 load_var 2 (provider) - 255 call 1131 ntypeargs=0 (openai.internal._chat_push_tool_uses) - 256 pop 1 - - 1249 257 load_var 8 (message) - 258 load_field 5 (refusal) - 259 store_var 39 (_123) - 260 load_var 39 (_123) - 261 narrow_bind 8 39 - 262 pop_jump_if_false +6 (to 268) - - 1250 263 load_type 7 - 264 load_var2 10 39 - - 1249 265 init_instance 6 (ai.content.Text .text) - - 1250 266 call 4 ntypeargs=1 (baml.Array.push) - 267 pop 1 - - 1253 268 load_var 37 (calls) - 269 container_len - 270 store_var 41 (_131) - 271 load_var 41 (_131) - 272 load_const 4 (0) - 273 cmp_int_op > - 274 pop_jump_if_false +2 (to 276) - 275 jump +27 (to 302) - - 1255 276 load_var 8 (message) - 277 load_field 5 (refusal) - 278 load_const 2 (null) - 279 call 672 ntypeargs=0 (baml.ops.equals_equals) - 280 unary_op ! - 281 pop_jump_if_false +2 (to 283) - 282 jump +16 (to 298) - - 1258 283 load_var 6 (choice) - 284 load_field 2 (finish_reason) - 285 store_var 42 (_136) - 286 load_var 42 (_136) - 287 narrow_bind 8 42 - 288 pop_jump_if_false +2 (to 290) - 289 jump +5 (to 294) - - 1260 290 load_const 4 (ai.content.StopReason.Complete) - 291 alloc_variant 774 (ai.content.StopReason) - 292 store_var 40 (stop) - - 1258 293 jump +12 (to 305) - 294 load_var 42 (_136) - - 1259 295 call 1128 ntypeargs=0 (openai.internal.chat_stop_reason) - 296 store_var 40 (stop) - 297 jump +8 (to 305) - - 1256 298 load_const 27 (ai.content.StopReason.Refused) - 299 alloc_variant 774 (ai.content.StopReason) - 300 store_var 40 (stop) - - 1255 301 jump +4 (to 305) - - 1254 302 load_const 8 (ai.content.StopReason.ToolUse) - 303 alloc_variant 774 (ai.content.StopReason) - 304 store_var 40 (stop) - - 1264 305 load_var 1 (response) - 306 load_field 3 (usage) - 307 store_var 44 (_141) - 308 load_var 44 (_141) - 309 narrow_bind 28 44 - 310 pop_jump_if_false +2 (to 312) - 311 jump +4 (to 315) - - 1273 312 load_const 2 (null) - 313 store_var 43 (usage) - - 1264 314 jump +52 (to 366) - 315 load_var 44 (_141) - 316 store_var_load_var 45 (u) - - 1267 317 load_field 0 (prompt_tokens) - 318 store_var_load_var 47 (_144) - 319 load_const 2 (null) - 320 cmp_op == - 321 pop_jump_if_false +3 (to 324) - 322 load_const 4 (0) - 323 store_var 47 (_144) - 324 load_var 47 (_144) - 325 store_var 46 (_143) - - 1268 326 load_var 45 (u) - 327 load_field 1 (completion_tokens) - 328 store_var_load_var 49 (_148) - 329 load_const 2 (null) - 330 cmp_op == - 331 pop_jump_if_false +3 (to 334) - 332 load_const 4 (0) - 333 store_var 49 (_148) - 334 load_var 49 (_148) - 335 store_var 48 (_147) - - 1269 336 load_var 45 (u) - 337 load_field 3 (prompt_tokens_details) - 338 load_const 2 (null) - 339 cmp_op == - 340 pop_jump_if_false +2 (to 342) - 341 jump +6 (to 347) - 342 load_var 45 (u) - 343 load_field 3 (prompt_tokens_details) - 344 load_field 0 (0) - 345 store_var 50 (_151) - 346 jump +3 (to 349) - 347 load_const 2 (null) - 348 store_var 50 (_151) - - 1270 349 load_var 45 (u) - 350 load_field 4 (completion_tokens_details) - 351 load_const 2 (null) - 352 cmp_op == - 353 pop_jump_if_false +2 (to 355) - 354 jump +6 (to 360) - 355 load_var 45 (u) - 356 load_field 4 (completion_tokens_details) - 357 load_field 0 (0) - 358 store_var 51 (_155) - 359 jump +3 (to 362) - 360 load_const 2 (null) - 361 store_var 51 (_155) - - 1266 362 load_var2 46 48 - 363 load_var2 50 51 - 364 init_instance 7 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 365 store_var 43 (usage) - - 1276 366 load_var2 10 40 - 367 load_var 43 (usage) - 368 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) - 369 return -} - -function openai.internal.chat_render(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 1091 0 load_var2 1 2 - 1 load_var2 3 4 - 2 call 1125 ntypeargs=0 (openai.internal.chat_build_request) - 3 store_var 5 (request) - - 1094 4 load_var2 1 2 - 5 call 1122 ntypeargs=0 (openai.internal._chat_url) - 6 store_var 6 (_6) - - 1095 7 load_var2 1 2 - 8 call 1123 ntypeargs=0 (openai.internal._chat_headers) - 9 store_var 7 (_7) - - 1096 10 load_var2 1 2 - 11 load_var 5 (request) - 12 call 1126 ntypeargs=0 (openai.internal.chat_render_body) - 13 store_var 8 (_8) - - 1092 14 load_const 0 ("POST") - 15 load_var2 6 7 - 16 load_var 8 (_8) - 17 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 18 return -} - -function openai.internal.chat_render_body(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, request: openai.internal.ChatRequest) -> string { - 1080 0 load_type 0 - 1 load_var 3 (request) - 2 call 356 ntypeargs=1 (baml.json.from) - 3 call 1119 ntypeargs=0 (openai.internal._chat_prune_nulls) - 4 call 1118 ntypeargs=0 (openai.internal._chat_apply_directives) - - 1081 5 load_var 2 (params) - 6 load_field 10 (request_body) - 7 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 8 call 351 ntypeargs=0 (baml.json.stringify) - 9 return -} - -function openai.internal.chat_stop_reason(reason: string) -> ai.content.StopReason { - 1105 0 load_var 1 (reason) - 1 load_const 0 ("tool_calls") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +36 (to 40) - 5 load_var 1 (reason) - 6 load_const 1 ("function_call") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +28 (to 37) - 10 load_var 1 (reason) - 11 load_const 2 ("length") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +20 (to 34) - 15 load_var 1 (reason) - 16 load_const 3 ("max_tokens") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +12 (to 31) - 20 load_var 1 (reason) - 21 load_const 4 ("content_filter") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +4 (to 28) - - 1109 25 load_const 5 (ai.content.StopReason.Complete) - 26 alloc_variant 774 (ai.content.StopReason) - - 1105 27 jump +15 (to 42) - - 1108 28 load_const 6 (ai.content.StopReason.Refused) - 29 alloc_variant 774 (ai.content.StopReason) - - 1105 30 jump +12 (to 42) - - 1107 31 load_const 7 (ai.content.StopReason.MaxTokens) - 32 alloc_variant 774 (ai.content.StopReason) - - 1105 33 jump +9 (to 42) - - 1107 34 load_const 7 (ai.content.StopReason.MaxTokens) - 35 alloc_variant 774 (ai.content.StopReason) - - 1105 36 jump +6 (to 42) - - 1106 37 load_const 8 (ai.content.StopReason.ToolUse) - 38 alloc_variant 774 (ai.content.StopReason) - - 1105 39 jump +3 (to 42) - - 1106 40 load_const 8 (ai.content.StopReason.ToolUse) - 41 alloc_variant 774 (ai.content.StopReason) - 42 return -} - -function openai.internal.images_invoke(c: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 404 0 load_var2 1 2 - 1 call 1150 ntypeargs=0 (openai.internal.images_render) - 2 store_var 3 (req) - - 405 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("openai-images") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - 7 store_var 4 (resp) - - 406 8 load_var2 1 4 - 9 call 1154 ntypeargs=0 (openai.internal.images_parse) - 10 return -} - -function openai.internal.images_parse(c: openai.ImageClient, resp: openai.internal.OaImagesResponse) -> ai.ModelTurn { - 367 0 load_var 2 (resp) - 1 load_field 3 (output_format) - 2 store_var_load_var 4 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (c) - 7 load_field 7 (output_format) - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 call 1151 ntypeargs=0 (openai.internal._oai_images_mime) - 11 store_var 3 (mime) - - 368 12 load_var 2 (resp) - 13 load_field 1 (data) - 14 store_var_load_var 5 (_9) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +4 (to 21) - 18 load_type 1 - 19 alloc_array 0 - 20 store_var 5 (_9) - - 369 21 load_type 2 - 22 alloc_array 0 - 23 store_var 6 (content) - - 368 24 load_var 5 (_9) - 25 load_type 3 - 26 load_const 4 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 7 (_14) - - 370 29 load_var 7 (_14) - 30 load_type 5 - 31 load_const 6 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 8 (_15) - 34 load_var 8 (_15) - 35 is_type 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +12 (to 49) - 38 load_var2 8 3 - - 371 39 call 1153 ntypeargs=0 (openai.internal._oai_images_block) - 40 store_var 9 (_22) - 41 load_var 9 (_22) - 42 narrow_bind 8 9 - 43 pop_jump_if_false -14 (to 29) - - 372 44 load_type 2 - 45 load_var2 6 9 - 46 call 4 ntypeargs=1 (baml.Array.push) - 47 pop 1 - 48 jump -19 (to 29) - - 375 49 load_var 6 (content) - 50 container_len - 51 store_var 10 (_28) - 52 load_var 10 (_28) - 53 load_const 9 (0) - 54 cmp_int_op == - 55 pop_jump_if_false +2 (to 57) - 56 jump +41 (to 97) - - 381 57 load_var 2 (resp) - 58 load_field 6 (usage) - 59 store_var 12 (_32) - 60 load_var 12 (_32) - 61 narrow_bind 10 12 - 62 pop_jump_if_false +2 (to 64) - 63 jump +4 (to 67) - - 389 64 load_const 0 (null) - 65 store_var 11 (usage) - - 381 66 jump +25 (to 91) - 67 load_var 12 (_32) - 68 store_var_load_var 13 (reported) - - 383 69 load_field 0 (input_tokens) - 70 store_var_load_var 15 (_35) - 71 load_const 0 (null) - 72 cmp_op == - 73 pop_jump_if_false +3 (to 76) - 74 load_const 9 (0) - 75 store_var 15 (_35) - 76 load_var 15 (_35) - 77 store_var 14 (_34) - - 384 78 load_var 13 (reported) - 79 load_field 1 (output_tokens) - 80 store_var_load_var 16 (_39) - 81 load_const 0 (null) - 82 cmp_op == - 83 pop_jump_if_false +3 (to 86) - 84 load_const 9 (0) - 85 store_var 16 (_39) - - 382 86 load_var2 14 16 - - 384 87 load_const 0 (null) - 88 load_const 0 (null) - 89 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 90 store_var 11 (usage) - - 392 91 load_var 6 (content) - 92 load_const 9 (ai.content.StopReason.Complete) - 93 alloc_variant 774 (ai.content.StopReason) - - 394 94 load_var 11 (usage) - 95 init_instance 1 (ai.ModelTurn .content, .stop_reason, .usage) - 96 return - - 376 97 load_const 11 ("openai-images") - 98 load_const 12 ("the images response contained no image data in data[]") - 99 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 100 throw -} - -function openai.internal.images_render(c: openai.ImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - 259 0 load_var 2 (input) - 1 load_field 2 (toolbox) - 2 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 3 unary_op ! - 4 pop_jump_if_false +2 (to 6) - 5 jump +98 (to 103) - - 267 6 load_var 2 (input) - 7 load_field 1 (journal) - 8 store_var 4 (_8) - 9 load_var 1 (c) - 10 call 1141 ntypeargs=0 (openai.internal._oai_images_client_id) - 11 store_var 5 (_9) - 12 load_var2 4 5 - 13 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 14 store_var 3 (journal) - - 271 15 load_const 0 ("") - 16 load_var 2 (input) - 17 load_field 0 (prompt) - 18 call_indirect - 19 load_var 3 (journal) - 20 call 1144 ntypeargs=0 (openai.internal._oai_images_prompt_text) - 21 store_var 6 (text) - - 273 22 load_var 1 (c) - 23 load_field 0 (model) - 24 store_var 7 (_15) - - 275 25 load_var 1 (c) - 26 load_field 3 (n) - 27 store_var 8 (_17) - - 276 28 load_var 1 (c) - 29 load_field 4 (size) - 30 store_var 9 (_18) - - 277 31 load_var 1 (c) - 32 load_field 5 (quality) - 33 store_var 10 (_19) - - 278 34 load_var 1 (c) - 35 load_field 6 (background) - 36 store_var 11 (_20) - - 279 37 load_var 1 (c) - 38 load_field 7 (output_format) - 39 store_var 12 (_21) - - 280 40 load_var 1 (c) - 41 load_field 8 (output_compression) - 42 store_var 13 (_22) - - 281 43 load_var 1 (c) - 44 load_field 9 (moderation) - 45 store_var 14 (_23) - - 282 46 load_var 1 (c) - 47 load_field 10 (style) - 48 store_var 15 (_24) - - 283 49 load_var 1 (c) - 50 load_field 11 (user) - 51 store_var 16 (_25) - - 284 52 load_var 1 (c) - 53 load_field 0 (model) - 54 load_var 1 (c) - 55 load_field 12 (response_format) - 56 call 1145 ntypeargs=0 (openai.internal._oai_images_response_format) - 57 store_var 17 (_26) - - 286 58 load_type 1 - - 272 59 load_var2 7 6 - - 274 60 load_var2 8 9 - 61 load_var2 10 11 - 62 load_var2 12 13 - 63 load_var2 14 15 - 64 load_var2 16 17 - 65 init_instance 0 (openai.internal.OaImagesRequest .model, .prompt, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format) - - 286 66 call 355 ntypeargs=1 (baml.json.to_json) - 67 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - - 287 68 load_var 1 (c) - 69 load_field 13 (request_body) - 70 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 71 store_var 18 (merged) - - 289 72 load_var 1 (c) - 73 call 1094 ntypeargs=0 (openai.ImageClient.resolved_base_url) - 74 store_var_load_var 21 (_41) - 75 load_const 2 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 3 ("https://api.openai.com/v1") - 79 store_var 21 (_41) - 80 load_var 21 (_41) - 81 call 1146 ntypeargs=0 (openai.internal._oai_images_trim_slash) - 82 store_var 20 (_39) - 83 load_type 4 - 84 load_var 20 (_39) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 load_const 5 ("/images/generations") - 87 bin_op + - - 290 88 load_var 1 (c) - 89 load_field 15 (query_params) - - 288 90 call 1148 ntypeargs=0 (openai.internal._oai_images_with_query) - 91 store_var 19 (url) - - 295 92 load_var 1 (c) - 93 call 1149 ntypeargs=0 (openai.internal._oai_images_headers) - 94 store_var 22 (_47) - - 296 95 load_var 18 (merged) - 96 call 351 ntypeargs=0 (baml.json.stringify) - 97 store_var 23 (_48) - - 292 98 load_const 6 ("POST") - - 294 99 load_var2 19 22 - 100 load_var 23 (_48) - 101 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 102 return - - 260 103 load_const 7 ("openai-images") - 104 load_const 2 (null) - 105 load_const 8 ("the Images API has no tool calling; run tools with a chat client instead") - 106 load_const 2 (null) - 107 init_instance 2 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 108 throw -} - -function openai.internal.invoke(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 930 0 load_var2 1 2 - 1 call 1036 ntypeargs=0 (openai.internal.openai_render) - 2 store_var 3 (req) - - 931 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("openai") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - - 932 7 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 8 return -} - -function openai.internal.invoke_stream(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 1151 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1037 ntypeargs=0 (openai.internal._openai_request) - - 1152 6 sys_op 252 (baml.http.fetch_sse) - 7 store_var 3 (sse) - 8 jump +6 (to 14) - 9 load_var 4 (e) - 10 throw_if_panic - - 1153 11 load_var 4 (e) - 12 call 1049 ntypeargs=0 (openai.internal._openai_sse_failure) - 13 throw - - 1155 14 call 1044 ntypeargs=0 (openai.internal.OaStreamState.new) - 15 store_deref 5 - - 1163 16 load_var2 3 5 - - 1164 17 make_closure 2756 1 - 18 load_const 1 ("openai") - - 1162 19 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 20 return -} - -function openai.internal.openai_lower_journal(j: ai.Journal) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - 523 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (items) - - 524 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +146 (to 163) - 18 load_var 4 (_5) - 19 store_var 5 (e) - - 525 20 load_var 5 (e) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +125 (to 150) - 26 load_var 5 (e) - 27 store_var 7 (_17) - 28 load_var 7 (_17) - 29 narrow_bind 7 7 - 30 pop_jump_if_false +2 (to 32) - 31 jump +55 (to 86) - 32 load_var 5 (e) - 33 store_var 17 (_44) - 34 load_var 17 (_44) - 35 narrow_bind 8 17 - 36 pop_jump_if_false +2 (to 38) - 37 jump +36 (to 73) - 38 load_var 5 (e) - 39 store_var 19 (_51) - 40 load_var 19 (_51) - 41 narrow_bind 9 19 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 19 (_51) - 44 store_var 20 (f) - - 578 45 load_type 10 - 46 load_type 11 - 47 alloc_map 0 - 48 store_var 21 (err) - - 579 49 load_type 10 - 50 load_type 11 - 51 load_var 21 (err) - 52 load_const 12 ("error") - 53 load_var 20 (f) - 54 load_field 1 (message) - 55 call 37 ntypeargs=2 (baml.Map.set) - 56 pop 1 - - 583 57 load_var 20 (f) - 58 load_field 0 (id) - 59 store_var 22 (_60) - - 584 60 load_type 13 - 61 load_var 21 (err) - 62 call 355 ntypeargs=1 (baml.json.to_json) - 63 call 351 ntypeargs=0 (baml.json.stringify) - 64 store_var 23 (_61) - - 580 65 load_type 0 - 66 load_var 2 (items) - - 581 67 load_const 14 ("function_call_output") - 68 load_var2 22 23 - 69 init_instance 0 (openai.internal.OaFunctionCallOutputItem .type, .call_id, .output) - - 580 70 call 4 ntypeargs=1 (baml.Array.push) - 71 pop 1 - 72 jump -63 (to 9) - - 525 73 load_var 17 (_44) - 74 store_var 18 (c) - - 568 75 load_type 0 - 76 load_var 2 (items) - - 569 77 load_const 15 ("function_call_output") - - 571 78 load_var 18 (c) - 79 load_field 0 (id) - - 572 80 load_var 18 (c) - 81 load_field 1 (output) - 82 init_instance 1 (openai.internal.OaFunctionCallOutputItem .type, .call_id, .output) - - 568 83 call 4 ntypeargs=1 (baml.Array.push) - 84 pop 1 - 85 jump -76 (to 9) - - 525 86 load_var 7 (_17) - 87 load_field 0 (content) - 88 load_type 16 - 89 load_const 17 ("iter") - 90 virtual_call nargs=1 ntypeargs=0 - 91 store_var 8 (_20) - - 536 92 load_var 8 (_20) - 93 load_type 18 - 94 load_const 19 ("next") - 95 virtual_call nargs=1 ntypeargs=0 - 96 store_var 9 (_21) - 97 load_var 9 (_21) - 98 is_type 5 - 99 pop_jump_if_false +2 (to 101) - 100 jump -91 (to 9) - 101 load_var 9 (_21) - 102 store_var 10 (b) - - 537 103 load_var 10 (b) - 104 store_var 11 (_25) - 105 load_var 11 (_25) - 106 narrow_bind 20 11 - 107 pop_jump_if_false +2 (to 109) - 108 jump +29 (to 137) - 109 load_var 10 (b) - 110 store_var 12 (_33) - 111 load_var 12 (_33) - 112 narrow_bind 21 12 - 113 pop_jump_if_false -21 (to 92) - 114 load_var 12 (_33) - 115 store_var 13 (use) - - 551 116 load_var 13 (use) - 117 load_field 0 (id) - 118 store_var 14 (_37) - - 552 119 load_var 13 (use) - 120 load_field 1 (name) - 121 store_var 15 (_38) - - 553 122 load_type 13 - 123 load_var 13 (use) - 124 load_field 2 (args) - 125 call 355 ntypeargs=1 (baml.json.to_json) - 126 call 351 ntypeargs=0 (baml.json.stringify) - 127 store_var 16 (_39) - - 548 128 load_type 0 - 129 load_var 2 (items) - - 549 130 load_const 22 ("function_call") - 131 load_var2 14 15 - 132 load_var 16 (_39) - 133 init_instance 2 (openai.internal.OaFunctionCallItem .type, .call_id, .name, .arguments) - - 548 134 call 4 ntypeargs=1 (baml.Array.push) - 135 pop 1 - 136 jump -44 (to 92) - - 539 137 load_type 0 - 138 load_var 2 (items) - - 540 139 load_const 23 ("assistant") - - 542 140 load_const 24 ("output_text") - - 537 141 load_var 11 (_25) - 142 load_field 0 (text) - 143 init_instance 3 (openai.internal.OaOutputText .type, .text) - 144 load_type 25 - 145 alloc_array 1 - 146 init_instance 4 (openai.internal.OaMessageItem .role, .content) - - 539 147 call 4 ntypeargs=1 (baml.Array.push) - 148 pop 1 - 149 jump -57 (to 92) - - 527 150 load_type 0 - 151 load_var 2 (items) - - 528 152 load_const 26 ("user") - - 530 153 load_const 27 ("input_text") - - 525 154 load_var 6 (_9) - 155 load_field 0 (content) - 156 init_instance 5 (openai.internal.OaInputText .type, .text) - 157 load_type 25 - 158 alloc_array 1 - 159 init_instance 6 (openai.internal.OaMessageItem .role, .content) - - 527 160 call 4 ntypeargs=1 (baml.Array.push) - 161 pop 1 - 162 jump -153 (to 9) - - 592 163 load_var 2 (items) - 164 return -} - -function openai.internal.openai_lower_prompt(prompt: ai.Prompt) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - 438 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (items) - - 439 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +36 (to 53) - 18 load_var 4 (_5) - 19 store_var 5 (message) - - 440 20 load_var 5 (message) - 21 load_field 0 (role) - 22 store_var_load_var 7 (_10) - 23 load_const 6 ("") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +13 (to 39) - 27 load_var 7 (_10) - 28 load_const 7 ("tool") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +5 (to 36) - - 442 32 load_var 5 (message) - 33 load_field 0 (role) - 34 store_var 6 (role) - - 440 35 jump +6 (to 41) - - 441 36 load_const 8 ("user") - 37 store_var 6 (role) - - 440 38 jump +3 (to 41) - - 441 39 load_const 9 ("user") - 40 store_var 6 (role) - - 444 41 load_var 6 (role) - 42 store_var 8 (_15) - 43 load_var2 5 6 - 44 call 1023 ntypeargs=0 (openai.internal._openai_prompt_content) - 45 store_var 9 (_16) - 46 load_type 0 - 47 load_var2 2 8 - 48 load_var 9 (_16) - 49 init_instance 0 (openai.internal.OaMessageItem .role, .content) - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -43 (to 9) - - 446 53 load_var 2 (items) - 54 return -} - -function openai.internal.openai_parse(resp: openai.internal.OaResponse) -> ai.ModelTurn { - 819 0 load_var 1 (resp) - 1 load_field 2 (status) - 2 store_var_load_var 2 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("") - 7 store_var 2 (_5) - 8 load_var 2 (_5) - 9 load_const 2 ("failed") - 10 cmp_op == - 11 jump_if_false +2 (to 13) - 12 jump +7 (to 19) - 13 pop 1 - 14 load_var 1 (resp) - 15 load_field 6 (error) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 unary_op ! - 19 pop_jump_if_false +2 (to 21) - 20 jump +361 (to 381) - - 822 21 load_type 3 - 22 alloc_array 0 - 23 store_var 3 (content) - - 823 24 load_const 4 (false) - 25 store_var 4 (has_call) - - 824 26 load_const 4 (false) - 27 store_var 5 (refused) - - 825 28 load_var 1 (resp) - 29 load_field 3 (output) - 30 store_var_load_var 6 (_15) - 31 load_const 0 (null) - 32 cmp_op == - 33 pop_jump_if_false +4 (to 37) - 34 load_type 5 - 35 alloc_array 0 - 36 store_var 6 (_15) - 37 load_var 6 (_15) - 38 load_type 6 - 39 load_const 7 ("iter") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 7 (_19) - - 826 42 load_var 7 (_19) - 43 load_type 8 - 44 load_const 9 ("next") - 45 virtual_call nargs=1 ntypeargs=0 - 46 store_var 8 (_20) - 47 load_var 8 (_20) - 48 is_type 10 - 49 pop_jump_if_false +2 (to 51) - 50 jump +206 (to 256) - 51 load_var 8 (_20) - 52 store_var 9 (item) - - 827 53 load_var 9 (item) - 54 load_field 0 (type) - 55 store_var_load_var 10 (_24) - 56 load_const 11 ("function_call") - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +147 (to 206) - 60 load_var 10 (_24) - 61 load_const 12 ("message") - 62 cmp_op == - 63 pop_jump_if_false +2 (to 65) - 64 jump +70 (to 134) - 65 load_var 10 (_24) - 66 load_const 13 ("reasoning") - 67 cmp_op == - 68 pop_jump_if_false +2 (to 70) - 69 jump +30 (to 99) - 70 load_var 10 (_24) - 71 load_const 14 ("image_generation_call") - 72 cmp_op == - 73 pop_jump_if_false -31 (to 42) - - 884 74 load_var 9 (item) - 75 load_field 8 (result) - 76 store_var 30 (_98) - 77 load_var 30 (_98) - 78 narrow_bind 15 30 - 79 pop_jump_if_false -37 (to 42) - 80 load_var 30 (_98) - 81 store_var 31 (encoded) - - 885 82 load_var 9 (item) - 83 load_field 10 (output_format) - 84 call 1038 ntypeargs=0 (openai.internal._openai_image_mime) - 85 store_var 32 (mime) - - 888 86 load_var2 31 32 - 87 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 889 88 load_var 9 (item) - 89 load_field 1 (id) - - 890 90 load_var 9 (item) - 91 load_field 9 (revised_prompt) - - 887 92 call 904 ntypeargs=0 (ai.content.Media.new) - 93 store_var 33 (_103) - - 886 94 load_type 3 - 95 load_var2 3 33 - 96 call 4 ntypeargs=1 (baml.Array.push) - 97 pop 1 - 98 jump -56 (to 42) - - 870 99 load_var 9 (item) - 100 load_field 7 (summary) - 101 store_var_load_var 26 (_80) - 102 load_const 0 (null) - 103 cmp_op == - 104 pop_jump_if_false +4 (to 108) - 105 load_type 16 - 106 alloc_array 0 - 107 store_var 26 (_80) - 108 load_var 26 (_80) - 109 load_type 17 - 110 load_const 18 ("iter") - 111 virtual_call nargs=1 ntypeargs=0 - 112 store_var 27 (_84) - - 871 113 load_var 27 (_84) - 114 load_type 19 - 115 load_const 20 ("next") - 116 virtual_call nargs=1 ntypeargs=0 - 117 store_var 28 (_85) - 118 load_var 28 (_85) - 119 is_type 10 - 120 pop_jump_if_false +2 (to 122) - 121 jump -79 (to 42) - 122 load_var 28 (_85) - 123 load_field 1 (text) - 124 store_var 29 (_90) - - 872 125 load_var 29 (_90) - 126 narrow_bind 15 29 - 127 pop_jump_if_false -14 (to 113) - - 873 128 load_type 3 - 129 load_var2 3 29 - - 872 130 init_instance 0 (ai.content.Reasoning .summary) - - 873 131 call 4 ntypeargs=1 (baml.Array.push) - 132 pop 1 - 133 jump -20 (to 113) - - 851 134 load_var 9 (item) - 135 load_field 6 (content) - 136 store_var_load_var 18 (_49) - 137 load_const 0 (null) - 138 cmp_op == - 139 pop_jump_if_false +4 (to 143) - 140 load_type 16 - 141 alloc_array 0 - 142 store_var 18 (_49) - 143 load_var 18 (_49) - 144 load_type 17 - 145 load_const 21 ("iter") - 146 virtual_call nargs=1 ntypeargs=0 - 147 store_var 19 (_53) - - 852 148 load_var 19 (_53) - 149 load_type 19 - 150 load_const 22 ("next") - 151 virtual_call nargs=1 ntypeargs=0 - 152 store_var 20 (_54) - 153 load_var 20 (_54) - 154 is_type 10 - 155 pop_jump_if_false +2 (to 157) - 156 jump -114 (to 42) - 157 load_var 20 (_54) - 158 store_var_load_var 21 (part) - - 853 159 load_field 0 (type) - 160 store_var_load_var 23 (_59) - 161 load_const 0 (null) - 162 cmp_op == - 163 pop_jump_if_false +3 (to 166) - 164 load_const 23 ("") - 165 store_var 23 (_59) - 166 load_var 23 (_59) - 167 store_var_load_var 22 (kind) - - 854 168 load_const 24 ("output_text") - 169 cmp_op == - 170 pop_jump_if_false +2 (to 172) - 171 jump +21 (to 192) - 172 load_var 22 (kind) - 173 load_const 25 ("refusal") - 174 cmp_op == - 175 pop_jump_if_false -27 (to 148) - - 860 176 load_const 26 (true) - 177 store_var 5 (refused) - - 861 178 load_var 21 (part) - 179 load_field 2 (refusal) - 180 store_var_load_var 25 (_74) - 181 load_const 0 (null) - 182 cmp_op == - 183 pop_jump_if_false +3 (to 186) - 184 load_const 27 ("") - 185 store_var 25 (_74) - 186 load_type 3 - 187 load_var2 3 25 - 188 init_instance 1 (ai.content.Text .text) - 189 call 4 ntypeargs=1 (baml.Array.push) - 190 pop 1 - 191 jump -43 (to 148) - - 856 192 load_var 21 (part) - 193 load_field 1 (text) - 194 store_var_load_var 24 (_66) - 195 load_const 0 (null) - 196 cmp_op == - 197 pop_jump_if_false +3 (to 200) - 198 load_const 28 ("") - 199 store_var 24 (_66) - 200 load_type 3 - 201 load_var2 3 24 - 202 init_instance 2 (ai.content.Text .text) - 203 call 4 ntypeargs=1 (baml.Array.push) - 204 pop 1 - 205 jump -57 (to 148) - - 829 206 load_const 26 (true) - 207 store_var 4 (has_call) - - 830 208 load_type 29 - 209 load_type 30 - 210 alloc_map 0 - 211 store_var 11 (args) - - 831 212 load_var 9 (item) - 213 load_field 5 (arguments) - 214 store_var 12 (_28) - 215 load_var 12 (_28) - 216 narrow_bind 15 12 - 217 pop_jump_if_false +14 (to 231) - 218 load_var 12 (_28) - 219 store_var 13 (s) - - 837 220 load_type 31 - 221 load_var 13 (s) - 222 call 357 ntypeargs=1 (baml.json.from_string) - 223 store_var 11 (args) - 224 jump +7 (to 231) - 225 load_var 14 (e) - 226 throw_if_panic - - 838 227 load_const 32 ("openai") - 228 load_var 13 (s) - 229 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 230 throw - - 843 231 load_var 9 (item) - 232 load_field 3 (call_id) - 233 store_var_load_var 16 (_38) - 234 load_const 0 (null) - 235 cmp_op == - 236 pop_jump_if_false +3 (to 239) - 237 load_const 33 ("") - 238 store_var 16 (_38) - 239 load_var 16 (_38) - 240 store_var 15 (_37) - - 844 241 load_var 9 (item) - 242 load_field 4 (name) - 243 store_var_load_var 17 (_42) - 244 load_const 0 (null) - 245 cmp_op == - 246 pop_jump_if_false +3 (to 249) - 247 load_const 34 ("") - 248 store_var 17 (_42) - - 841 249 load_type 3 - 250 load_var2 3 15 - - 844 251 load_var2 17 11 - - 845 252 init_instance 4 (ai.content.ToolUse .id, .name, .args) - - 841 253 call 4 ntypeargs=1 (baml.Array.push) - 254 pop 1 - 255 jump -213 (to 42) - - 902 256 load_var 4 (has_call) - 257 pop_jump_if_false +2 (to 259) - 258 jump +55 (to 313) - - 904 259 load_var 5 (refused) - 260 pop_jump_if_false +2 (to 262) - 261 jump +48 (to 309) - - 906 262 load_var 1 (resp) - 263 load_field 2 (status) - 264 store_var_load_var 35 (_115) - 265 load_const 0 (null) - 266 cmp_op == - 267 pop_jump_if_false +3 (to 270) - 268 load_const 35 ("") - 269 store_var 35 (_115) - 270 load_var 35 (_115) - 271 load_const 36 ("incomplete") - 272 cmp_op == - 273 pop_jump_if_false +2 (to 275) - 274 jump +5 (to 279) - - 913 275 load_const 37 (ai.content.StopReason.Complete) - 276 alloc_variant 774 (ai.content.StopReason) - 277 store_var 34 (stop) - - 906 278 jump +38 (to 316) - - 907 279 load_var 1 (resp) - 280 load_field 5 (incomplete_details) - 281 load_const 0 (null) - 282 cmp_op == - 283 pop_jump_if_false +2 (to 285) - 284 jump +5 (to 289) - 285 load_var 1 (resp) - 286 load_field 5 (incomplete_details) - 287 load_field 0 (0) - 288 jump +2 (to 290) - 289 load_const 0 (null) - 290 store_var_load_var 36 (_120) - 291 load_const 0 (null) - 292 cmp_op == - 293 pop_jump_if_false +3 (to 296) - 294 load_const 38 ("") - 295 store_var 36 (_120) - 296 load_var 36 (_120) - 297 load_const 39 ("content_filter") - 298 cmp_op == - 299 pop_jump_if_false +2 (to 301) - 300 jump +5 (to 305) - - 910 301 load_const 40 (ai.content.StopReason.MaxTokens) - 302 alloc_variant 774 (ai.content.StopReason) - 303 store_var 34 (stop) - - 907 304 jump +12 (to 316) - - 908 305 load_const 41 (ai.content.StopReason.Refused) - 306 alloc_variant 774 (ai.content.StopReason) - 307 store_var 34 (stop) - - 907 308 jump +8 (to 316) - - 905 309 load_const 41 (ai.content.StopReason.Refused) - 310 alloc_variant 774 (ai.content.StopReason) - 311 store_var 34 (stop) - - 904 312 jump +4 (to 316) - - 903 313 load_const 15 (ai.content.StopReason.ToolUse) - 314 alloc_variant 774 (ai.content.StopReason) - 315 store_var 34 (stop) - - 915 316 load_var 1 (resp) - 317 load_field 4 (usage) - 318 store_var 38 (_128) - 319 load_var 38 (_128) - 320 narrow_bind 42 38 - 321 pop_jump_if_false +2 (to 323) - 322 jump +4 (to 326) - - 923 323 load_const 0 (null) - 324 store_var 37 (usage) - - 915 325 jump +52 (to 377) - 326 load_var 38 (_128) - 327 store_var_load_var 39 (u) - - 917 328 load_field 0 (input_tokens) - 329 store_var_load_var 41 (_131) - 330 load_const 0 (null) - 331 cmp_op == - 332 pop_jump_if_false +3 (to 335) - 333 load_const 37 (0) - 334 store_var 41 (_131) - 335 load_var 41 (_131) - 336 store_var 40 (_130) - - 918 337 load_var 39 (u) - 338 load_field 1 (output_tokens) - 339 store_var_load_var 43 (_135) - 340 load_const 0 (null) - 341 cmp_op == - 342 pop_jump_if_false +3 (to 345) - 343 load_const 37 (0) - 344 store_var 43 (_135) - 345 load_var 43 (_135) - 346 store_var 42 (_134) - - 919 347 load_var 39 (u) - 348 load_field 3 (input_tokens_details) - 349 load_const 0 (null) - 350 cmp_op == - 351 pop_jump_if_false +2 (to 353) - 352 jump +6 (to 358) - 353 load_var 39 (u) - 354 load_field 3 (input_tokens_details) - 355 load_field 0 (0) - 356 store_var 44 (_138) - 357 jump +3 (to 360) - 358 load_const 0 (null) - 359 store_var 44 (_138) - - 920 360 load_var 39 (u) - 361 load_field 4 (output_tokens_details) - 362 load_const 0 (null) - 363 cmp_op == - 364 pop_jump_if_false +2 (to 366) - 365 jump +6 (to 371) - 366 load_var 39 (u) - 367 load_field 4 (output_tokens_details) - 368 load_field 0 (0) - 369 store_var 45 (_142) - 370 jump +3 (to 373) - 371 load_const 0 (null) - 372 store_var 45 (_142) - - 916 373 load_var2 40 42 - 374 load_var2 44 45 - 375 init_instance 5 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 376 store_var 37 (usage) - - 925 377 load_var2 3 34 - 378 load_var 37 (usage) - 379 init_instance 6 (ai.ModelTurn .content, .stop_reason, .usage) - 380 return - - 820 381 load_var 1 (resp) - 382 call 1041 ntypeargs=0 (openai.internal._openai_response_failure) - 383 throw -} - -function openai.internal.openai_prompt_metadata(prompt: ai.Prompt) -> map[] { - 461 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 462 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +7 (to 24) - - 463 18 load_type 0 - 19 load_var2 2 4 - - 462 20 load_field 3 (metadata) - - 463 21 call 4 ntypeargs=1 (baml.Array.push) - 22 pop 1 - 23 jump -14 (to 9) - - 465 24 load_var 2 (out) - 25 return -} - -function openai.internal.openai_render(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> baml.http.Request { - 693 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1037 ntypeargs=0 (openai.internal._openai_request) - 3 return -} - -function testing.$invoke_collector(collector: (testing.TestCollector) -> void throws unknown, c: testing.TestCollector) -> void { - 143 0 load_var2 2 1 - 1 call_indirect - 2 return -} - -function testing.FailFast() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 104 0 make_closure 2063 0 - 1 return -} - -function testing.PassRate(threshold: float) -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 70 3 load_deref 1 - 4 load_const 0 (0.0) - 5 cmp_float_op < - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_deref 1 - 10 load_const 1 (1.0) - 11 cmp_float_op > - 12 pop_jump_if_false +4 (to 16) - - 71 13 load_const 2 ("testing.PassRate requires 0.0 <= threshold <= 1.0") - 14 call 277 ntypeargs=0 (baml.sys.panic) - 15 pop 1 - - 76 16 load_var 1 (threshold) - 17 make_closure 2058 1 - 18 return -} - -function testing.Quorum(n: int, m: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 2 6 load_deref 1 - 7 load_const 0 (0) - 8 cmp_int_op <= - 9 pop_jump_if_false +2 (to 11) - 10 jump +15 (to 25) - - 4 11 load_deref 2 - 12 load_const 0 (0) - 13 cmp_int_op < - 14 jump_if_false +2 (to 16) - 15 jump +5 (to 20) - 16 pop 1 - 17 load_deref 2 - 18 load_deref 1 - 19 cmp_int_op > - 20 pop_jump_if_false +8 (to 28) - - 5 21 load_const 1 ("testing.Quorum requires 0 <= m <= n") - 22 call 277 ntypeargs=0 (baml.sys.panic) - 23 pop 1 - 24 jump +4 (to 28) - - 3 25 load_const 2 ("testing.Quorum requires n > 0") - 26 call 277 ntypeargs=0 (baml.sys.panic) - 27 pop 1 - - 10 28 load_var2 1 2 - 29 make_closure 2042 2 - 30 return -} - -function testing.Retry(max_attempts: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 36 3 load_deref 1 - 4 load_const 0 (0) - 5 cmp_int_op <= - 6 pop_jump_if_false +4 (to 10) - - 37 7 load_const 1 ("testing.Retry requires max_attempts > 0") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 pop 1 - - 42 10 load_var 1 (max_attempts) - 11 make_closure 2052 1 - 12 return -} - -function testing.Sequential() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 98 0 make_closure 2061 0 - 1 return -} - -function testing.TestCollector.find_test(self: testing.TestCollector, name: string) -> testing.TestRegistration { - 131 0 load_var 1 (self) - 1 load_field 1 (tests) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 3 (_4) - 6 load_var 3 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 4 (_5) - 11 load_var 4 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +9 (to 23) - 15 load_var 4 (_5) - 16 store_var_load_var 5 (t) - - 132 17 load_field 0 (name) - 18 load_var 2 (name) - 19 cmp_op == - 20 pop_jump_if_false -14 (to 6) - - 133 21 load_var 5 (t) - 22 return - - 136 23 load_const 5 ("Test not found: ") - 24 load_var 2 (name) - 25 bin_op + - 26 throw -} - -function testing.TestCollector.find_testset(self: testing.TestCollector, name: string) -> testing.TestSetRegistration { - 122 0 load_var 1 (self) - 1 load_field 2 (testsets) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 3 (_4) - 6 load_var 3 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 4 (_5) - 11 load_var 4 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +9 (to 23) - 15 load_var 4 (_5) - 16 store_var_load_var 5 (ts) - - 123 17 load_field 0 (name) - 18 load_var 2 (name) - 19 cmp_op == - 20 pop_jump_if_false -14 (to 6) - - 124 21 load_var 5 (ts) - 22 return - - 127 23 load_const 5 ("TestSet not found: ") - 24 load_var 2 (name) - 25 bin_op + - 26 throw -} - -function testing.TestCollector.new(prefix: string) -> testing.TestCollector { - 30 0 load_var 1 (prefix) - 1 load_type 0 - 2 alloc_array 0 - 3 load_type 1 - 4 alloc_array 0 - 5 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 6 return -} - -function testing.TestCollector.register_test(self: testing.TestCollector, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - 34 0 load_var 2 (name) - 1 load_const 0 ("::") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 pop_jump_if_false +2 (to 5) - 4 jump +87 (to 91) - - 39 5 load_var 1 (self) - 6 load_field 0 (prefix) - 7 load_const 1 ("") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +9 (to 19) - - 42 11 load_var 1 (self) - 12 load_field 0 (prefix) - 13 load_const 2 ("::") - 14 bin_op + - 15 load_var 2 (name) - 16 bin_op + - 17 store_var 5 (full_name) - - 39 18 jump +3 (to 21) - - 40 19 load_var 2 (name) - 20 store_var 5 (full_name) - - 44 21 load_const 3 (0) - 22 store_var 6 (count) - - 45 23 load_var 5 (full_name) - 24 load_const 4 ("#") - 25 bin_op + - 26 store_var 7 (hash_prefix) - - 46 27 load_var 1 (self) - 28 load_field 1 (tests) - 29 load_type 5 - 30 load_const 6 ("iter") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 8 (_17) - 33 load_var 8 (_17) - 34 load_type 7 - 35 load_const 8 ("next") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 9 (_18) - 38 load_var 9 (_18) - 39 is_type 9 - 40 pop_jump_if_false +2 (to 42) - 41 jump +19 (to 60) - 42 load_var 9 (_18) - 43 store_var_load_var 10 (t) - - 47 44 load_field 0 (name) - 45 load_var 5 (full_name) - 46 cmp_op == - 47 jump_if_false +2 (to 49) - 48 jump +6 (to 54) - 49 pop 1 - 50 load_var 10 (t) - 51 load_field 0 (name) - 52 load_var 7 (hash_prefix) - 53 call 148 ntypeargs=0 (baml.String.starts_with) - 54 pop_jump_if_false -21 (to 33) - - 48 55 load_var 6 (count) - 56 load_const 10 (1) - 57 add_int - 58 store_var 6 (count) - - 47 59 jump -26 (to 33) - - 53 60 load_var 6 (count) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 56 65 load_var 5 (full_name) - 66 store_var 11 (final_name) - - 53 67 jump +14 (to 81) - - 54 68 load_var 5 (full_name) - 69 load_const 11 ("#") - 70 bin_op + - 71 store_var 12 (_31) - 72 load_type 12 - 73 load_var 6 (count) - 74 load_const 10 (1) - 75 add_int - 76 call 138 ntypeargs=1 (baml.String.from) - 77 store_var 13 (_33) - 78 load_var2 12 13 - 79 bin_op + - 80 store_var 11 (final_name) - - 58 81 load_type 13 - 82 load_var 1 (self) - 83 load_field 1 (tests) - 84 load_var2 11 3 - 85 load_var 4 (runner) - 86 init_instance 0 (testing.TestRegistration .name, .body, .runner) - 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - - 33 89 load_const 14 (null) - 90 return - - 35 91 load_const 15 ("test name may not contain reserved separator `::`: ") - 92 load_var 2 (name) - 93 bin_op + - 94 init_instance 1 (testing.InvalidTestName .message) - 95 throw -} - -function testing.TestCollector.register_test_at(self: testing.TestCollector, owner: string, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - 106 0 load_var2 2 1 - 1 load_field 1 (tests) - 2 load_var 1 (self) - 3 load_field 2 (testsets) - 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 5 load_var2 3 4 - 6 load_var 5 (runner) - - 107 7 call 840 ntypeargs=0 (testing.TestCollector.register_test) - 8 return -} - -function testing.TestCollector.register_test_set(self: testing.TestCollector, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - 67 0 load_var 2 (name) - 1 load_const 0 ("::") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 pop_jump_if_false +2 (to 5) - 4 jump +87 (to 91) - - 72 5 load_var 1 (self) - 6 load_field 0 (prefix) - 7 load_const 1 ("") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +9 (to 19) - - 75 11 load_var 1 (self) - 12 load_field 0 (prefix) - 13 load_const 2 ("::") - 14 bin_op + - 15 load_var 2 (name) - 16 bin_op + - 17 store_var 5 (full_name) - - 72 18 jump +3 (to 21) - - 73 19 load_var 2 (name) - 20 store_var 5 (full_name) - - 77 21 load_const 3 (0) - 22 store_var 6 (count) - - 78 23 load_var 5 (full_name) - 24 load_const 4 ("#") - 25 bin_op + - 26 store_var 7 (hash_prefix) - - 79 27 load_var 1 (self) - 28 load_field 2 (testsets) - 29 load_type 5 - 30 load_const 6 ("iter") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 8 (_17) - 33 load_var 8 (_17) - 34 load_type 7 - 35 load_const 8 ("next") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 9 (_18) - 38 load_var 9 (_18) - 39 is_type 9 - 40 pop_jump_if_false +2 (to 42) - 41 jump +19 (to 60) - 42 load_var 9 (_18) - 43 store_var_load_var 10 (ts) - - 80 44 load_field 0 (name) - 45 load_var 5 (full_name) - 46 cmp_op == - 47 jump_if_false +2 (to 49) - 48 jump +6 (to 54) - 49 pop 1 - 50 load_var 10 (ts) - 51 load_field 0 (name) - 52 load_var 7 (hash_prefix) - 53 call 148 ntypeargs=0 (baml.String.starts_with) - 54 pop_jump_if_false -21 (to 33) - - 81 55 load_var 6 (count) - 56 load_const 10 (1) - 57 add_int - 58 store_var 6 (count) - - 80 59 jump -26 (to 33) - - 86 60 load_var 6 (count) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 89 65 load_var 5 (full_name) - 66 store_var 11 (final_name) - - 86 67 jump +14 (to 81) - - 87 68 load_var 5 (full_name) - 69 load_const 11 ("#") - 70 bin_op + - 71 store_var 12 (_31) - 72 load_type 12 - 73 load_var 6 (count) - 74 load_const 10 (1) - 75 add_int - 76 call 138 ntypeargs=1 (baml.String.from) - 77 store_var 13 (_33) - 78 load_var2 12 13 - 79 bin_op + - 80 store_var 11 (final_name) - - 91 81 load_type 13 - 82 load_var 1 (self) - 83 load_field 2 (testsets) - - 92 84 load_var2 11 3 - 85 load_var 4 (runner) - 86 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) - - 91 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - - 66 89 load_const 14 (null) - 90 return - - 68 91 load_const 15 ("testset name may not contain reserved separator `::`: ") - 92 load_var 2 (name) - 93 bin_op + - 94 init_instance 1 (testing.InvalidTestName .message) - 95 throw -} - -function testing.TestCollector.register_test_set_at(self: testing.TestCollector, owner: string, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - 117 0 load_var2 2 1 - 1 load_field 1 (tests) - 2 load_var 1 (self) - 3 load_field 2 (testsets) - 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 5 load_var2 3 4 - 6 load_var 5 (runner) - - 118 7 call 841 ntypeargs=0 (testing.TestCollector.register_test_set) - 8 return -} - -function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: string) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - 288 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 2 (testsets) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +13 (to 28) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (ts) - - 289 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 290 22 load_var2 1 5 - 23 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 24 pop 1 - - 291 25 load_var 1 (self) - 26 call 848 ntypeargs=0 (testing.TestRegistry.serialize) - 27 jump +33 (to 60) - - 295 28 load_type 5 - 29 load_type 6 - 30 load_var 1 (self) - 31 load_field 1 (expansions) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 7 - 34 load_const 8 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 6 (_17) - 37 load_var 6 (_17) - 38 load_type 9 - 39 load_const 10 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 7 (_18) - 42 load_var 7 (_18) - 43 is_type 4 - 44 pop_jump_if_false +2 (to 46) - 45 jump +16 (to 61) - 46 load_var 7 (_18) - 47 store_var 8 (k) - - 296 48 load_var 1 (self) - 49 load_field 1 (expansions) - 50 load_var 8 (k) - 51 load_map_element - 52 store_var 9 (sub) - - 297 53 load_var2 2 8 - 54 load_const 11 ("::") - 55 bin_op + - 56 call 148 ntypeargs=0 (baml.String.starts_with) - 57 pop_jump_if_false -20 (to 37) - - 298 58 load_var2 9 2 - 59 call 855 ntypeargs=0 (testing.TestRegistry.expand_set) - 60 return - - 301 61 load_const 12 ("TestSet not found for expansion: ") - 62 load_var 2 (name) - 63 bin_op + - 64 throw -} - -function testing.TestRegistry.expand_testset_registry(self: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestRegistry { - 305 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (self) - 3 load_field 1 (expansions) - 4 load_var 2 (ts) - 5 load_field 0 (name) - 6 call 38 ntypeargs=2 (baml.Map.get) - 7 store_var 3 (_8) - 8 load_var 3 (_8) - 9 narrow_bind 2 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +51 (to 62) - - 308 12 sys_op 539 (baml.time.Instant.now) - 13 store_var 4 (start) - - 309 14 load_var 2 (ts) - 15 load_field 0 (name) - 16 load_type 3 - 17 alloc_array 0 - 18 load_type 4 - 19 alloc_array 0 - 20 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 21 store_var_load_var 5 (sub_collector) - - 310 22 load_var 2 (ts) - 23 load_field 1 (collector) - 24 call_indirect - 25 pop 1 - - 315 26 load_var 4 (start) - 27 call 540 ntypeargs=0 (baml.time.Instant.elapsed) - 28 call 527 ntypeargs=0 (baml.time.Duration.to_milliseconds) - 29 call 92 ntypeargs=0 (baml.Bigint.to_int) - 30 store_var 6 (elapsed) - 31 jump +13 (to 44) - 32 load_var 7 (_) - 33 is_type 5 - 34 pop_jump_if_false +2 (to 36) - 35 jump +3 (to 38) - 36 load_var 7 (_) - 37 rethrow - - 317 38 load_const 6 ("testing: expansion duration: ") - - 315 39 load_var 7 (_) - 40 load_field 0 (0) - 41 bin_op + - - 317 42 call 277 ntypeargs=0 (baml.sys.panic) - 43 store_var 6 (elapsed) - - 320 44 load_var 5 (sub_collector) - 45 load_type 0 - 46 load_type 1 - 47 alloc_map 0 - 48 load_var 6 (elapsed) - 49 init_instance 1 (testing.TestRegistry .collector, .expansions, .loading_time_ms) - 50 store_var 8 (sub_registry) - - 321 51 load_type 0 - 52 load_type 1 - 53 load_var 1 (self) - 54 load_field 1 (expansions) - 55 load_var 2 (ts) - 56 load_field 0 (name) - 57 load_var 8 (sub_registry) - 58 call 37 ntypeargs=2 (baml.Map.set) - 59 pop 1 - - 322 60 load_var 8 (sub_registry) - - 305 61 jump +2 (to 63) - 62 load_var 3 (_8) - 63 return -} - -function testing.TestRegistry.list_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 281 0 load_var2 1 2 - 1 load_var2 3 4 - 2 load_var 5 (cli_exclude) - 3 call 876 ntypeargs=0 (testing.select_names_layered) - 4 return -} - -function testing.TestRegistry.new(collector: testing.TestCollector) -> testing.TestRegistry { - 169 0 load_var 1 (collector) - 1 load_type 0 - 2 load_type 1 - 3 alloc_map 0 - 4 load_const 2 (0) - 5 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) - 6 return -} - -function testing.TestRegistry.run_all(self: testing.TestRegistry) -> testing.TestSetReport { - 237 0 load_var 1 (self) - 1 call 857 ntypeargs=0 (testing.testset_children) - 2 load_const 0 (null) - 3 call 867 ntypeargs=0 (testing.run_testset) - 4 return -} - -function testing.TestRegistry.run_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> testing.FlatTestReport { - 259 0 load_var2 1 2 - 1 load_var2 3 4 - 2 load_var 5 (cli_exclude) - 3 call 876 ntypeargs=0 (testing.select_names_layered) - 4 store_var 6 (selected_names) - - 261 5 load_var 2 (profile_include) - 6 container_len - 7 store_var 7 (_12) - 8 load_var 7 (_12) - 9 load_const 0 (0) - 10 cmp_int_op == - 11 jump_if_false +8 (to 19) - 12 pop 1 - - 262 13 load_var 3 (profile_exclude) - 14 container_len - 15 store_var 8 (_13) - 16 load_var 8 (_13) - 17 load_const 0 (0) - 18 cmp_int_op == - - 261 19 jump_if_false +8 (to 27) - 20 pop 1 - - 263 21 load_var 4 (cli_include) - 22 container_len - 23 store_var 9 (_14) - 24 load_var 9 (_14) - 25 load_const 0 (0) - 26 cmp_int_op == - - 261 27 jump_if_false +8 (to 35) - 28 pop 1 - - 264 29 load_var 5 (cli_exclude) - 30 container_len - 31 store_var 10 (_15) - 32 load_var 10 (_15) - 33 load_const 0 (0) - 34 cmp_int_op == - - 260 35 pop_jump_if_false +2 (to 37) - 36 jump +4 (to 40) - - 268 37 load_var2 1 6 - 38 call 852 ntypeargs=0 (testing.TestRegistry.run_selected) - 39 jump +3 (to 42) - - 266 40 load_var 1 (self) - 41 call 851 ntypeargs=0 (testing.TestRegistry.run_all) - - 270 42 load_var 6 (selected_names) - 43 call 882 ntypeargs=0 (testing.flatten_with_tolerated) - 44 return -} - -function testing.TestRegistry.run_selected(self: testing.TestRegistry, names: string[]) -> testing.TestSetReport { - 241 0 load_var2 1 2 - 1 call 858 ntypeargs=0 (testing.testset_children_selected) - 2 load_const 0 (null) - 3 call 867 ntypeargs=0 (testing.run_testset) - 4 return -} - -function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) -> testing.TestReport { - 205 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 1 (tests) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +13 (to 28) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (t) - - 206 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 207 22 load_var 5 (t) - 23 load_field 1 (body) - 24 load_var 5 (t) - 25 load_field 2 (runner) - 26 call 866 ntypeargs=0 (testing.run_test) - 27 jump +33 (to 60) - - 211 28 load_type 5 - 29 load_type 6 - 30 load_var 1 (self) - 31 load_field 1 (expansions) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 7 - 34 load_const 8 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 6 (_17) - 37 load_var 6 (_17) - 38 load_type 9 - 39 load_const 10 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 7 (_18) - 42 load_var 7 (_18) - 43 is_type 4 - 44 pop_jump_if_false +2 (to 46) - 45 jump +16 (to 61) - 46 load_var 7 (_18) - 47 store_var 8 (k) - - 212 48 load_var 1 (self) - 49 load_field 1 (expansions) - 50 load_var 8 (k) - 51 load_map_element - 52 store_var 9 (sub) - - 214 53 load_var2 2 8 - 54 load_const 11 ("::") - 55 bin_op + - 56 call 148 ntypeargs=0 (baml.String.starts_with) - 57 pop_jump_if_false -20 (to 37) - - 215 58 load_var2 9 2 - 59 call 849 ntypeargs=0 (testing.TestRegistry.run_test) - 60 return - - 218 61 load_const 12 ("Test not found: ") - 62 load_var 2 (name) - 63 bin_op + - 64 throw -} - -function testing.TestRegistry.run_testset(self: testing.TestRegistry, name: string) -> testing.TestSetReport { - 222 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 2 (testsets) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +14 (to 29) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (ts) - - 223 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 224 22 load_var2 1 5 - 23 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 24 call 857 ntypeargs=0 (testing.testset_children) - 25 load_var 5 (ts) - 26 load_field 2 (runner) - 27 call 867 ntypeargs=0 (testing.run_testset) - 28 jump +33 (to 61) - - 227 29 load_type 5 - 30 load_type 6 - 31 load_var 1 (self) - 32 load_field 1 (expansions) - 33 call 35 ntypeargs=2 (baml.Map.keys) - 34 load_type 7 - 35 load_const 8 ("iter") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 6 (_19) - 38 load_var 6 (_19) - 39 load_type 9 - 40 load_const 10 ("next") - 41 virtual_call nargs=1 ntypeargs=0 - 42 store_var 7 (_20) - 43 load_var 7 (_20) - 44 is_type 4 - 45 pop_jump_if_false +2 (to 47) - 46 jump +16 (to 62) - 47 load_var 7 (_20) - 48 store_var 8 (k) - - 228 49 load_var 1 (self) - 50 load_field 1 (expansions) - 51 load_var 8 (k) - 52 load_map_element - 53 store_var 9 (sub) - - 229 54 load_var2 2 8 - 55 load_const 11 ("::") - 56 bin_op + - 57 call 148 ntypeargs=0 (baml.String.starts_with) - 58 pop_jump_if_false -20 (to 38) - - 230 59 load_var2 9 2 - 60 call 850 ntypeargs=0 (testing.TestRegistry.run_testset) - 61 return - - 233 62 load_const 12 ("TestSet not found: ") - 63 load_var 2 (name) - 64 bin_op + - 65 throw -} - -function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - 178 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (items) - - 179 3 load_var 1 (self) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_4) - 10 load_var 3 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_5) - 15 load_var 4 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +10 (to 28) - - 180 19 load_type 0 - 20 load_var 2 (items) - 21 load_const 6 ("test") - - 179 22 load_var 4 (_5) - 23 load_field 0 (name) - 24 init_instance 0 (testing.SerializedTest .type, .name) - - 180 25 call 4 ntypeargs=1 (baml.Array.push) - 26 pop 1 - 27 jump -17 (to 10) - - 182 28 load_var 1 (self) - 29 load_field 0 (collector) - 30 load_field 2 (testsets) - 31 load_type 7 - 32 load_const 8 ("iter") - 33 virtual_call nargs=1 ntypeargs=0 - 34 store_var 5 (_14) - 35 load_var 5 (_14) - 36 load_type 9 - 37 load_const 10 ("next") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 6 (_15) - 40 load_var 6 (_15) - 41 is_type 5 - 42 pop_jump_if_false +2 (to 44) - 43 jump +40 (to 83) - 44 load_var 6 (_15) - 45 store_var 7 (ts) - - 183 46 load_type 11 - 47 load_type 12 - 48 load_var 1 (self) - 49 load_field 1 (expansions) - 50 load_var 7 (ts) - 51 load_field 0 (name) - 52 call 38 ntypeargs=2 (baml.Map.get) - - 184 53 store_var 8 (_25) - 54 load_var 8 (_25) - 55 narrow_bind 13 8 - 56 pop_jump_if_false +2 (to 58) - 57 jump +10 (to 67) - - 195 58 load_type 0 - 59 load_var 2 (items) - 60 load_const 14 ("lazyTestSet") - 61 load_var 7 (ts) - 62 load_field 0 (name) - 63 init_instance 1 (testing.SerializedTest .type, .name) - 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - 66 jump -31 (to 35) - - 184 67 load_var 8 (_25) - 68 store_var 9 (sub) - - 188 69 load_var 7 (ts) - 70 load_field 0 (name) - 71 store_var 10 (_28) - - 189 72 load_var 9 (sub) - 73 call 848 ntypeargs=0 (testing.TestRegistry.serialize) - 74 store_var 11 (_29) - - 186 75 load_type 0 - 76 load_var2 2 10 - - 187 77 load_var2 11 9 - - 190 78 load_field 2 (loading_time_ms) - 79 init_instance 2 (testing.SerializedTestSet .name, .items, .loadingTimeMs) - - 186 80 call 4 ntypeargs=1 (baml.Array.push) - 81 pop 1 - 82 jump -47 (to 35) - - 199 83 load_var 2 (items) - 84 return -} - -function testing._has_selected_descendant(prefix: string, names: string[]) -> bool { - 416 0 load_var 2 (names) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_4) - 5 load_var 3 (_4) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_5) - 10 load_var 4 (_5) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - 14 load_var2 4 1 - - 415 15 load_const 5 ("::") - 16 bin_op + - - 417 17 call 148 ntypeargs=0 (baml.String.starts_with) - 18 pop_jump_if_false -13 (to 5) - - 418 19 load_const 6 (true) - 20 jump +2 (to 22) - - 423 21 load_const 7 (false) - 22 return -} - -function testing._int_to_float(value: int) -> float { - 128 0 load_type 0 - 1 load_var 1 (value) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 call 130 ntypeargs=0 (baml.Float.parse) - 4 jump +5 (to 9) - 5 load_var 2 (e) - 6 throw_if_panic - - 129 7 load_const 1 ("failed to convert int to float") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function testing._name_selected(name: string, names: string[]) -> bool { - 404 0 load_var 2 (names) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +6 (to 19) - 14 load_var2 4 1 - 15 cmp_op == - 16 pop_jump_if_false -11 (to 5) - - 406 17 load_const 5 (true) - 18 jump +2 (to 20) - - 411 19 load_const 6 (false) - 20 return -} - -function testing.aggregate_reports(named_results: testing.NamedChildReport[]) -> testing.TestSetReport { - 427 0 load_const 0 (0) - 1 store_var 2 (passed) - - 428 2 load_const 0 (0) - 3 store_var 3 (failed) - - 429 4 load_const 1 (false) - 5 store_var 4 (has_error) - - 430 6 load_type 2 - 7 alloc_array 0 - 8 store_var 5 (failed_names) - - 431 9 load_type 3 - 10 alloc_array 0 - 11 store_var 6 (results) - - 432 12 load_type 2 - 13 alloc_array 0 - 14 store_var 7 (result_names) - - 433 15 load_var 1 (named_results) - 16 load_type 4 - 17 load_const 5 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 8 (_8) - 20 load_var 8 (_8) - 21 load_type 6 - 22 load_const 7 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 9 (_9) - 25 load_var 9 (_9) - 26 is_type 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +95 (to 123) - 29 load_var 9 (_9) - 30 store_var 10 (named_result) - - 434 31 load_var 10 (named_result) - 32 load_field 1 (report) - 33 store_var 11 (result) - - 435 34 load_type 3 - 35 load_var2 6 11 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - - 436 38 load_type 2 - 39 load_var2 7 10 - 40 load_field 0 (name) - 41 call 4 ntypeargs=1 (baml.Array.push) - 42 pop 1 - - 437 43 load_var 11 (result) - 44 store_var 13 (_21) - 45 load_var 13 (_21) - 46 narrow_bind 9 13 - 47 pop_jump_if_false +2 (to 49) - 48 jump +5 (to 53) - 49 load_var 11 (result) - 50 load_field 0 (outcome) - 51 store_var 12 (outcome) - 52 jump +4 (to 56) - 53 load_var 13 (_21) - 54 load_field 0 (outcome) - 55 store_var 12 (outcome) - - 441 56 load_var 12 (outcome) - 57 load_const 10 ("pass") - 58 call 672 ntypeargs=0 (baml.ops.equals_equals) - 59 pop_jump_if_false +2 (to 61) - 60 jump +58 (to 118) - - 444 61 load_var 3 (failed) - 62 load_const 11 (1) - 63 add_int - 64 store_var 3 (failed) - - 445 65 load_var 11 (result) - 66 store_var 14 (_27) - 67 load_var 14 (_27) - 68 narrow_bind 9 14 - 69 pop_jump_if_false +2 (to 71) - 70 jump +19 (to 89) - 71 load_var 11 (result) - 72 store_var_load_var 15 (report) - - 448 73 load_field 4 (failed_names) - 74 container_len - 75 store_var 16 (_31) - 76 load_var 16 (_31) - 77 load_const 0 (0) - 78 cmp_int_op > - 79 pop_jump_if_false +2 (to 81) - 80 jump +6 (to 86) - - 451 81 load_var 10 (named_result) - 82 load_field 0 (name) - 83 load_type 2 - 84 alloc_array 1 - - 448 85 jump +8 (to 93) - - 449 86 load_var 15 (report) - 87 load_field 4 (failed_names) - - 448 88 jump +5 (to 93) - - 446 89 load_var 10 (named_result) - 90 load_field 0 (name) - 91 load_type 2 - 92 alloc_array 1 - - 455 93 load_type 12 - 94 load_const 13 ("iter") - 95 virtual_call nargs=1 ntypeargs=0 - 96 store_var 17 (_35) - 97 load_var 17 (_35) - 98 load_type 14 - 99 load_const 15 ("next") - 100 virtual_call nargs=1 ntypeargs=0 - 101 store_var 18 (_36) - 102 load_var 18 (_36) - 103 is_type 8 - 104 pop_jump_if_false +2 (to 106) - 105 jump +6 (to 111) - - 456 106 load_type 2 - 107 load_var2 5 18 - 108 call 4 ntypeargs=1 (baml.Array.push) - 109 pop 1 - 110 jump -13 (to 97) - - 458 111 load_var 12 (outcome) - 112 load_const 16 ("error") - 113 call 672 ntypeargs=0 (baml.ops.equals_equals) - 114 pop_jump_if_false -94 (to 20) - - 459 115 load_const 17 (true) - 116 store_var 4 (has_error) - - 458 117 jump -97 (to 20) - - 442 118 load_var 2 (passed) - 119 load_const 11 (1) - 120 add_int - 121 store_var 2 (passed) - - 441 122 jump -102 (to 20) - - 465 123 load_var 4 (has_error) - 124 pop_jump_if_false +2 (to 126) - 125 jump +10 (to 135) - - 467 126 load_var 3 (failed) - 127 load_const 0 (0) - 128 cmp_int_op == - 129 pop_jump_if_false +2 (to 131) - 130 jump +3 (to 133) - - 470 131 load_const 18 ("fail") - - 467 132 jump +4 (to 136) - - 468 133 load_const 19 ("pass") - - 467 134 jump +2 (to 136) - - 466 135 load_const 20 ("error") - - 473 136 store_var 19 (_49) - - 474 137 load_var 2 (passed) - 138 store_var 20 (_50) - - 475 139 load_var 3 (failed) - 140 store_var 21 (_51) - - 476 141 load_var 6 (results) - 142 container_len - 143 store_var 22 (_52) - - 472 144 load_var2 19 20 - 145 load_var2 21 22 - - 477 146 load_var2 5 6 - - 479 147 load_var 7 (result_names) - 148 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) - 149 return -} - -function testing.any_pattern_matches(pats: string[], canonical_id: string) -> bool { - 607 0 load_var 1 (pats) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +6 (to 19) - - 608 14 load_var2 2 4 - 15 call 869 ntypeargs=0 (testing.glob_match) - 16 pop_jump_if_false -11 (to 5) - - 609 17 load_const 5 (true) - 18 jump +2 (to 20) - - 612 19 load_const 6 (false) - 20 return -} - -function testing.classify_selected_names(selected_names: string[], hard_failed_names: string[], all_failed_names: string[]) -> testing.LeafIdentities { - 947 0 load_type 0 - 1 alloc_array 0 - 2 load_type 0 - 3 alloc_array 0 - 4 load_type 0 - 5 alloc_array 0 - 6 init_instance 0 (testing.LeafIdentities .passed, .failed, .tolerated) - 7 store_var 4 (out) - - 948 8 load_var 1 (selected_names) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_8) - 13 load_var 5 (_8) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_9) - 18 load_var 6 (_9) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +32 (to 53) - 22 load_var 6 (_9) - 23 store_var_load_var 7 (name) - - 949 24 load_var 3 (all_failed_names) - 25 call 885 ntypeargs=0 (testing.failure_matches_selected) - 26 pop_jump_if_false +2 (to 28) - 27 jump +8 (to 35) - - 956 28 load_type 0 - 29 load_var 4 (out) - 30 load_field 0 (passed) - 31 load_var 7 (name) - 32 call 4 ntypeargs=1 (baml.Array.push) - 33 pop 1 - 34 jump -21 (to 13) - - 950 35 load_var2 7 2 - 36 call 885 ntypeargs=0 (testing.failure_matches_selected) - 37 pop_jump_if_false +2 (to 39) - 38 jump +8 (to 46) - - 953 39 load_type 0 - 40 load_var 4 (out) - 41 load_field 2 (tolerated) - 42 load_var 7 (name) - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -32 (to 13) - - 951 46 load_type 0 - 47 load_var 4 (out) - 48 load_field 1 (failed) - 49 load_var 7 (name) - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -39 (to 13) - - 959 53 load_var 4 (out) - 54 return -} - -function testing.collect_all_failed_names(report: testing.TestSetReport, out: string[]) -> void { - 1049 0 load_var 1 (report) - 1 load_field 4 (failed_names) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 3 (_4) - 6 load_var 3 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 4 (_5) - 11 load_var 4 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +12 (to 26) - 15 load_var 4 (_5) - 16 store_var_load_var 5 (name) - - 1050 17 load_var 2 (out) - 18 call 884 ntypeargs=0 (testing.name_in) - 19 unary_op ! - 20 pop_jump_if_false -14 (to 6) - - 1051 21 load_type 5 - 22 load_var2 2 5 - 23 call 4 ntypeargs=1 (baml.Array.push) - 24 pop 1 - 25 jump -19 (to 6) - - 1054 26 load_var 1 (report) - 27 load_field 5 (results) - 28 load_type 6 - 29 load_const 7 ("iter") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 6 (_16) - 32 load_var 6 (_16) - 33 load_type 8 - 34 load_const 9 ("next") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 7 (_17) - 37 load_var 7 (_17) - 38 is_type 4 - 39 pop_jump_if_false +2 (to 41) - 40 jump +10 (to 50) - 41 load_var 7 (_17) - 42 store_var_load_var 8 (child) - - 1055 43 is_type 10 - 44 pop_jump_if_false +2 (to 46) - 45 jump -13 (to 32) - 46 load_var2 8 2 - - 1057 47 call 887 ntypeargs=0 (testing.collect_all_failed_names) - 48 pop 1 - 49 jump -17 (to 32) - - 1048 50 load_const 11 (null) - 51 return -} - -function testing.collect_leaf_identities(report: testing.TestSetReport, tolerated_by_parent: bool, selected_names: string[], out: testing.LeafIdentities) -> void { - 993 0 load_var 1 (report) - 1 load_field 6 (result_names) - 2 store_var_load_var 5 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +2 (to 7) - 6 jump +156 (to 162) - 7 load_var 5 (_5) - 8 store_var 6 (names) - - 996 9 load_var 6 (names) - 10 container_len - 11 store_var 8 (_10) - 12 load_var 1 (report) - 13 load_field 5 (results) - 14 container_len - 15 store_var 9 (_11) - 16 load_var2 8 9 - 17 cmp_int_op < - 18 pop_jump_if_false +2 (to 20) - 19 jump +6 (to 25) - - 999 20 load_var 1 (report) - 21 load_field 5 (results) - 22 container_len - 23 store_var 7 (limit) - 24 jump +4 (to 28) - - 997 25 load_var 6 (names) - 26 container_len - 27 store_var 7 (limit) - - 1001 28 load_const 1 (0) - 29 store_var 10 (i) - 30 load_var2 10 7 - 31 cmp_int_op < - 32 pop_jump_if_false +2 (to 34) - 33 jump +3 (to 36) - - 995 34 load_const 0 (null) - - 993 35 jump +128 (to 163) - - 1002 36 load_var2 6 10 - 37 load_array_element - 38 store_var 11 (name) - - 1003 39 load_var 1 (report) - 40 load_field 5 (results) - 41 load_var 10 (i) - 42 load_array_element - 43 store_var 12 (_22) - 44 load_var 12 (_22) - 45 store_var 13 (_25) - 46 load_var 13 (_25) - 47 narrow_bind 2 13 - 48 pop_jump_if_false +2 (to 50) - 49 jump +79 (to 128) - 50 load_var 12 (_22) - 51 store_var 14 (nested) - - 1014 52 load_var 2 (tolerated_by_parent) - 53 jump_if_false +3 (to 56) - 54 store_var 15 (nested_tolerated) - 55 jump +7 (to 62) - 56 pop 1 - 57 load_var 14 (nested) - 58 load_field 0 (outcome) - 59 load_const 3 ("pass") - 60 call 672 ntypeargs=0 (baml.ops.equals_equals) - 61 store_var 15 (nested_tolerated) - - 1015 62 load_var 14 (nested) - 63 load_field 5 (results) - 64 container_len - 65 store_var 16 (_42) - 66 load_var 16 (_42) - 67 load_const 1 (0) - 68 cmp_int_op > - 69 pop_jump_if_false +2 (to 71) - 70 jump +53 (to 123) - - 1022 71 load_var 14 (nested) - 72 load_field 2 (failed) - 73 load_const 1 (0) - 74 cmp_int_op > - 75 pop_jump_if_false +82 (to 157) - - 1023 76 load_var 11 (name) - 77 load_const 4 ("::(failed to expand)") - 78 bin_op + - 79 store_var_load_var 17 (sentinel) - - 1024 80 load_var 3 (selected_names) - 81 call 884 ntypeargs=0 (testing.name_in) - 82 pop_jump_if_false +2 (to 84) - 83 jump +21 (to 104) - - 1026 84 load_var 14 (nested) - 85 load_field 4 (failed_names) - 86 container_len - 87 store_var 19 (_54) - 88 load_var 19 (_54) - 89 load_const 1 (0) - 90 cmp_int_op > - 91 pop_jump_if_false +2 (to 93) - 92 jump +6 (to 98) - - 1029 93 load_var 11 (name) - 94 load_const 5 ("::(testset error)") - 95 bin_op + - 96 store_var 18 (identity) - - 1026 97 jump +9 (to 106) - - 1027 98 load_var 14 (nested) - 99 load_field 4 (failed_names) - 100 load_const 1 (0) - 101 load_array_element - 102 store_var 18 (identity) - - 1026 103 jump +3 (to 106) - - 1025 104 load_var 17 (sentinel) - 105 store_var 18 (identity) - - 1031 106 load_var 15 (nested_tolerated) - 107 pop_jump_if_false +2 (to 109) - 108 jump +8 (to 116) - - 1034 109 load_type 6 - 110 load_var 4 (out) - 111 load_field 1 (failed) - 112 load_var 18 (identity) - 113 call 4 ntypeargs=1 (baml.Array.push) - 114 pop 1 - 115 jump +42 (to 157) - - 1032 116 load_type 6 - 117 load_var 4 (out) - 118 load_field 2 (tolerated) - 119 load_var 18 (identity) - 120 call 4 ntypeargs=1 (baml.Array.push) - 121 pop 1 - 122 jump +35 (to 157) - - 1017 123 load_var2 14 15 - - 1018 124 load_var2 3 4 - - 1016 125 call 886 ntypeargs=0 (testing.collect_leaf_identities) - 126 pop 1 - 127 jump +30 (to 157) - - 1003 128 load_var 13 (_25) - 129 load_field 0 (outcome) - 130 load_const 7 ("pass") - - 1005 131 call 672 ntypeargs=0 (baml.ops.equals_equals) - 132 pop_jump_if_false +2 (to 134) - 133 jump +18 (to 151) - - 1007 134 load_var 2 (tolerated_by_parent) - 135 pop_jump_if_false +2 (to 137) - 136 jump +8 (to 144) - - 1010 137 load_type 6 - 138 load_var 4 (out) - 139 load_field 1 (failed) - 140 load_var 11 (name) - 141 call 4 ntypeargs=1 (baml.Array.push) - 142 pop 1 - 143 jump +14 (to 157) - - 1008 144 load_type 6 - 145 load_var 4 (out) - 146 load_field 2 (tolerated) - 147 load_var 11 (name) - 148 call 4 ntypeargs=1 (baml.Array.push) - 149 pop 1 - 150 jump +7 (to 157) - - 1006 151 load_type 6 - 152 load_var 4 (out) - 153 load_field 0 (passed) - 154 load_var 11 (name) - 155 call 4 ntypeargs=1 (baml.Array.push) - 156 pop 1 - - 1001 157 load_var 10 (i) - 158 load_const 8 (1) - 159 add_int - 160 store_var 10 (i) - 161 jump -131 (to 30) - - 994 162 load_const 0 (null) - 163 return -} - -function testing.collect_leaf_messages(results: (testing.TestReport | testing.TestSetReport)[], out: string[]) -> void { - 1065 0 load_var 1 (results) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +48 (to 61) - 14 load_var 4 (_4) - 15 store_var 5 (r) - - 1066 16 load_var 5 (r) - 17 store_var 6 (_8) - 18 load_var 6 (_8) - 19 narrow_bind 5 6 - 20 pop_jump_if_false +2 (to 22) - 21 jump +7 (to 28) - 22 load_var 5 (r) - 23 load_field 5 (results) - 24 load_var 2 (out) - - 1077 25 call 888 ntypeargs=0 (testing.collect_leaf_messages) - 26 pop 1 - 27 jump -22 (to 5) - - 1066 28 load_var 6 (_8) - 29 load_field 1 (runs) - 30 load_type 6 - 31 load_const 7 ("iter") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 7 (_11) - - 1068 34 load_var 7 (_11) - 35 load_type 8 - 36 load_const 9 ("next") - 37 virtual_call nargs=1 ntypeargs=0 - 38 store_var 8 (_12) - 39 load_var 8 (_12) - 40 is_type 4 - 41 pop_jump_if_false +2 (to 43) - 42 jump -37 (to 5) - 43 load_var 8 (_12) - 44 store_var_load_var 9 (run) - - 1069 45 load_field 0 (outcome) - 46 load_const 10 ("pass") - 47 call 672 ntypeargs=0 (baml.ops.equals_equals) - 48 unary_op ! - 49 pop_jump_if_false -15 (to 34) - - 1070 50 load_var 9 (run) - 51 load_field 2 (message) - 52 store_var 10 (_20) - 53 load_var 10 (_20) - 54 narrow_bind 11 10 - 55 pop_jump_if_false -21 (to 34) - - 1071 56 load_type 12 - 57 load_var2 2 10 - 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -26 (to 34) - - 1064 61 load_const 13 (null) - 62 return -} - -function testing.collect_leaf_names(registry: testing.TestRegistry) -> string[] { - 744 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (out) - - 745 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_4) - 10 load_var 3 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_5) - 15 load_var 4 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +7 (to 25) - - 746 19 load_type 0 - 20 load_var2 2 4 - - 745 21 load_field 0 (name) - - 746 22 call 4 ntypeargs=1 (baml.Array.push) - 23 pop 1 - 24 jump -14 (to 10) - - 748 25 load_var 1 (registry) - 26 load_field 0 (collector) - 27 load_field 2 (testsets) - 28 load_type 6 - 29 load_const 7 ("iter") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 5 (_13) - 32 load_var 5 (_13) - 33 load_type 8 - 34 load_const 9 ("next") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 6 (_14) - 37 load_var 6 (_14) - 38 is_type 5 - 39 pop_jump_if_false +2 (to 41) - 40 jump +21 (to 61) - - 749 41 load_var2 1 6 - 42 call 879 ntypeargs=0 (testing.collect_subtree_names) - 43 load_type 10 - 44 load_const 11 ("iter") - 45 virtual_call nargs=1 ntypeargs=0 - 46 store_var 7 (_20) - 47 load_var 7 (_20) - 48 load_type 12 - 49 load_const 13 ("next") - 50 virtual_call nargs=1 ntypeargs=0 - 51 store_var 8 (_21) - 52 load_var 8 (_21) - 53 is_type 5 - 54 pop_jump_if_false +2 (to 56) - 55 jump -23 (to 32) - - 750 56 load_type 0 - 57 load_var2 2 8 - 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -13 (to 47) - - 753 61 load_var 2 (out) - 62 return -} - -function testing.collect_subtree_names(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> string[] { - 762 0 load_var2 1 2 - 1 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 2 call 878 ntypeargs=0 (testing.collect_leaf_names) - 3 jump +89 (to 92) - 4 load_var 3 (e) - 5 store_var 4 (_5) - 6 load_var 4 (_5) - 7 narrow_bind 0 4 - 8 pop_jump_if_false +2 (to 10) - 9 jump +81 (to 90) - 10 load_var 3 (e) - 11 is_type 1 - 12 pop_jump_if_false +2 (to 14) - 13 jump +70 (to 83) - 14 load_var 3 (e) - 15 is_type 2 - 16 pop_jump_if_false +2 (to 18) - 17 jump +66 (to 83) - 18 load_var 3 (e) - 19 is_type 3 - 20 pop_jump_if_false +2 (to 22) - 21 jump +62 (to 83) - 22 load_var 3 (e) - 23 is_type 4 - 24 pop_jump_if_false +2 (to 26) - 25 jump +58 (to 83) - 26 load_var 3 (e) - 27 is_type 5 - 28 pop_jump_if_false +2 (to 30) - 29 jump +54 (to 83) - 30 load_var 3 (e) - 31 is_type 6 - 32 pop_jump_if_false +2 (to 34) - 33 jump +50 (to 83) - 34 load_var 3 (e) - 35 is_type 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +46 (to 83) - 38 load_var 3 (e) - 39 is_type 8 - 40 pop_jump_if_false +2 (to 42) - 41 jump +42 (to 83) - 42 load_var 3 (e) - 43 is_type 9 - 44 pop_jump_if_false +2 (to 46) - 45 jump +38 (to 83) - 46 load_var 3 (e) - 47 is_type 10 - 48 pop_jump_if_false +2 (to 50) - 49 jump +34 (to 83) - 50 load_var 3 (e) - 51 is_type 11 - 52 pop_jump_if_false +2 (to 54) - 53 jump +30 (to 83) - 54 load_var 3 (e) - 55 is_type 12 - 56 pop_jump_if_false +2 (to 58) - 57 jump +26 (to 83) - 58 load_var 3 (e) - 59 is_type 13 - 60 pop_jump_if_false +2 (to 62) - 61 jump +22 (to 83) - 62 load_var 3 (e) - 63 is_type 14 - 64 pop_jump_if_false +2 (to 66) - 65 jump +18 (to 83) - 66 load_var 3 (e) - 67 is_type 15 - 68 pop_jump_if_false +2 (to 70) - 69 jump +14 (to 83) - 70 load_var 3 (e) - 71 is_type 16 - 72 pop_jump_if_false +2 (to 74) - 73 jump +10 (to 83) - 74 load_var 3 (e) - 75 throw_if_panic - - 765 76 load_var 2 (ts) - 77 load_field 0 (name) - 78 load_const 17 ("::(failed to expand)") - 79 bin_op + - 80 load_type 18 - 81 alloc_array 1 - - 762 82 jump +10 (to 92) - - 764 83 load_var 2 (ts) - 84 load_field 0 (name) - 85 load_const 19 ("::(failed to expand)") - 86 bin_op + - 87 load_type 18 - 88 alloc_array 1 - - 762 89 jump +3 (to 92) - 90 load_var 4 (_5) - 91 throw - 92 return -} - -function testing.collect_subtree_names_layered(registry: testing.TestRegistry, ts: testing.TestSetRegistration, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 778 0 load_var2 1 2 - 1 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - - 777 2 load_var2 3 4 - 3 load_var2 5 6 - 4 call 876 ntypeargs=0 (testing.select_names_layered) - 5 jump +109 (to 114) - 6 load_var 7 (e) - 7 store_var 8 (_9) - 8 load_var 8 (_9) - 9 narrow_bind 0 8 - 10 pop_jump_if_false +2 (to 12) - 11 jump +101 (to 112) - 12 load_var 7 (e) - 13 is_type 1 - 14 pop_jump_if_false +2 (to 16) - 15 jump +80 (to 95) - 16 load_var 7 (e) - 17 is_type 2 - 18 pop_jump_if_false +2 (to 20) - 19 jump +76 (to 95) - 20 load_var 7 (e) - 21 is_type 3 - 22 pop_jump_if_false +2 (to 24) - 23 jump +72 (to 95) - 24 load_var 7 (e) - 25 is_type 4 - 26 pop_jump_if_false +2 (to 28) - 27 jump +68 (to 95) - 28 load_var 7 (e) - 29 is_type 5 - 30 pop_jump_if_false +2 (to 32) - 31 jump +64 (to 95) - 32 load_var 7 (e) - 33 is_type 6 - 34 pop_jump_if_false +2 (to 36) - 35 jump +60 (to 95) - 36 load_var 7 (e) - 37 is_type 7 - 38 pop_jump_if_false +2 (to 40) - 39 jump +56 (to 95) - 40 load_var 7 (e) - 41 is_type 8 - 42 pop_jump_if_false +2 (to 44) - 43 jump +52 (to 95) - 44 load_var 7 (e) - 45 is_type 9 - 46 pop_jump_if_false +2 (to 48) - 47 jump +48 (to 95) - 48 load_var 7 (e) - 49 is_type 10 - 50 pop_jump_if_false +2 (to 52) - 51 jump +44 (to 95) - 52 load_var 7 (e) - 53 is_type 11 - 54 pop_jump_if_false +2 (to 56) - 55 jump +40 (to 95) - 56 load_var 7 (e) - 57 is_type 12 - 58 pop_jump_if_false +2 (to 60) - 59 jump +36 (to 95) - 60 load_var 7 (e) - 61 is_type 13 - 62 pop_jump_if_false +2 (to 64) - 63 jump +32 (to 95) - 64 load_var 7 (e) - 65 is_type 14 - 66 pop_jump_if_false +2 (to 68) - 67 jump +28 (to 95) - 68 load_var 7 (e) - 69 is_type 15 - 70 pop_jump_if_false +2 (to 72) - 71 jump +24 (to 95) - 72 load_var 7 (e) - 73 is_type 16 - 74 pop_jump_if_false +2 (to 76) - 75 jump +20 (to 95) - 76 load_var 7 (e) - 77 throw_if_panic - - 802 78 load_var 2 (ts) - 79 load_field 0 (name) - 80 load_const 17 ("::(failed to expand)") - 81 bin_op + - 82 store_var_load_var 10 (sentinel) - - 805 83 load_var2 3 4 - 84 load_var2 5 6 - - 804 85 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 803 86 pop_jump_if_false +2 (to 88) - 87 jump +4 (to 91) - - 814 88 load_type 18 - 89 alloc_array 0 - - 803 90 jump +24 (to 114) - - 812 91 load_var 10 (sentinel) - 92 load_type 18 - 93 alloc_array 1 - - 803 94 jump +20 (to 114) - - 786 95 load_var 2 (ts) - 96 load_field 0 (name) - 97 load_const 19 ("::(failed to expand)") - 98 bin_op + - 99 store_var_load_var 9 (sentinel) - - 789 100 load_var2 3 4 - 101 load_var2 5 6 - - 788 102 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 787 103 pop_jump_if_false +2 (to 105) - 104 jump +4 (to 108) - - 798 105 load_type 18 - 106 alloc_array 0 - - 787 107 jump +7 (to 114) - - 796 108 load_var 9 (sentinel) - 109 load_type 18 - 110 alloc_array 1 - - 787 111 jump +3 (to 114) - - 777 112 load_var 8 (_9) - 113 throw - 114 return -} - -function testing.count_leaves(results: (testing.TestReport | testing.TestSetReport)[], tolerated_by_parent: bool) -> testing.LeafCounts { - 838 0 load_const 0 (0) - 1 store_var 3 (passed) - - 839 2 load_const 0 (0) - 3 store_var 4 (failed) - - 840 4 load_const 0 (0) - 5 store_var 5 (tolerated) - - 841 6 load_const 0 (0) - 7 store_var 6 (total) - - 842 8 load_var 1 (results) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 7 (_7) - 13 load_var 7 (_7) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 8 (_8) - 18 load_var 8 (_8) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +105 (to 126) - 22 load_var 8 (_8) - 23 store_var 9 (r) - - 843 24 load_var 9 (r) - 25 store_var 11 (_13) - 26 load_var 11 (_13) - 27 narrow_bind 6 11 - 28 pop_jump_if_false +2 (to 30) - 29 jump +51 (to 80) - 30 load_var 9 (r) - 31 store_var 12 (tsr) - - 854 32 load_var 2 (tolerated_by_parent) - 33 jump_if_false +3 (to 36) - 34 store_var 13 (ft) - 35 jump +7 (to 42) - 36 pop 1 - 37 load_var 12 (tsr) - 38 load_field 0 (outcome) - 39 load_const 7 ("pass") - 40 call 672 ntypeargs=0 (baml.ops.equals_equals) - 41 store_var 13 (ft) - - 855 42 load_var 12 (tsr) - 43 load_field 5 (results) - 44 container_len - 45 store_var 14 (_21) - 46 load_var 14 (_21) - 47 load_const 0 (0) - 48 cmp_int_op > - 49 pop_jump_if_false +2 (to 51) - 50 jump +24 (to 74) - - 857 51 load_var 13 (ft) - 52 pop_jump_if_false +2 (to 54) - 53 jump +11 (to 64) - - 866 54 load_var 12 (tsr) - 55 load_field 1 (passed) - - 867 56 load_var 12 (tsr) - 57 load_field 2 (failed) - 58 load_const 0 (0) - - 869 59 load_var 12 (tsr) - 60 load_field 3 (total) - 61 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 62 store_var 10 (delta) - - 857 63 jump +46 (to 109) - - 859 64 load_var 12 (tsr) - 65 load_field 1 (passed) - 66 load_const 0 (0) - - 861 67 load_var 12 (tsr) - 68 load_field 2 (failed) - - 862 69 load_var 12 (tsr) - 70 load_field 3 (total) - 71 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 72 store_var 10 (delta) - - 857 73 jump +36 (to 109) - - 856 74 load_var 12 (tsr) - 75 load_field 5 (results) - 76 load_var 13 (ft) - 77 call 881 ntypeargs=0 (testing.count_leaves) - 78 store_var 10 (delta) - 79 jump +30 (to 109) - - 843 80 load_var 11 (_13) - 81 load_field 0 (outcome) - 82 load_const 8 ("pass") - - 845 83 call 672 ntypeargs=0 (baml.ops.equals_equals) - 84 pop_jump_if_false +2 (to 86) - 85 jump +18 (to 103) - - 847 86 load_var 2 (tolerated_by_parent) - 87 pop_jump_if_false +2 (to 89) - 88 jump +8 (to 96) - - 850 89 load_const 0 (0) - 90 load_const 9 (1) - 91 load_const 0 (0) - 92 load_const 9 (1) - 93 init_instance 2 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 94 store_var 10 (delta) - - 847 95 jump +14 (to 109) - - 848 96 load_const 0 (0) - 97 load_const 0 (0) - 98 load_const 9 (1) - 99 load_const 9 (1) - 100 init_instance 3 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 101 store_var 10 (delta) - - 847 102 jump +7 (to 109) - - 846 103 load_const 9 (1) - 104 load_const 0 (0) - 105 load_const 0 (0) - 106 load_const 9 (1) - 107 init_instance 4 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 108 store_var 10 (delta) - - 874 109 load_var2 3 10 - 110 load_field 0 (passed) - 111 add_int - 112 store_var 3 (passed) - - 875 113 load_var2 4 10 - 114 load_field 1 (failed) - 115 add_int - 116 store_var 4 (failed) - - 876 117 load_var2 5 10 - 118 load_field 2 (tolerated) - 119 add_int - 120 store_var 5 (tolerated) - - 877 121 load_var2 6 10 - 122 load_field 3 (total) - 123 add_int - 124 store_var 6 (total) - - 842 125 jump -112 (to 13) - - 879 126 load_var2 3 4 - 127 load_var2 5 6 - 128 init_instance 5 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 129 return -} - -function testing.expansion_error_report(name: string) -> testing.TestSetReport { - 553 0 load_const 0 ("error") - 1 load_const 1 (0) - 2 load_const 2 (1) - 3 load_const 2 (1) - - 564 4 load_var 1 (name) - 5 load_const 3 ("::(testset error)") - 6 bin_op + - 7 load_type 4 - 8 alloc_array 1 - - 565 9 load_type 5 - 10 alloc_array 0 - - 566 11 load_type 4 - 12 alloc_array 0 - 13 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) - 14 return -} - -function testing.failure_matches_selected(selected: string, failed_names: string[]) -> bool { - 972 0 load_var2 1 2 - 1 call 884 ntypeargs=0 (testing.name_in) - 2 pop_jump_if_false +2 (to 4) - 3 jump +40 (to 43) - - 976 4 load_var 1 (selected) - - 975 5 load_const 0 ("::(failed to expand)") - - 976 6 call 149 ntypeargs=0 (baml.String.ends_with) - 7 pop_jump_if_false +34 (to 41) - - 977 8 load_var 1 (selected) - 9 call 139 ntypeargs=0 (baml.String.length) - 10 store_var 4 (_10) - - 975 11 load_const 1 ("::(failed to expand)") - - 977 12 call 139 ntypeargs=0 (baml.String.length) - 13 store_var 5 (_11) - 14 load_var 1 (selected) - 15 load_const 2 (0) - 16 load_var2 4 5 - 17 sub_int - 18 call 153 ntypeargs=0 (baml.String.slice) - 19 store_var 3 (_8) - - 978 20 load_var 2 (failed_names) - 21 load_type 3 - 22 load_const 4 ("iter") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 6 (_12) - 25 load_var 6 (_12) - 26 load_type 5 - 27 load_const 6 ("next") - 28 virtual_call nargs=1 ntypeargs=0 - 29 store_var 7 (_13) - 30 load_var 7 (_13) - 31 is_type 7 - 32 pop_jump_if_false +2 (to 34) - 33 jump +8 (to 41) - 34 load_var2 7 3 - - 977 35 load_const 8 ("::") - 36 bin_op + - - 979 37 call 148 ntypeargs=0 (baml.String.starts_with) - 38 pop_jump_if_false -13 (to 25) - - 980 39 load_const 9 (true) - 40 jump +4 (to 44) - - 984 41 load_const 10 (false) - 42 jump +2 (to 44) - - 973 43 load_const 9 (true) - 44 return -} - -function testing.flatten_with_tolerated(report: testing.TestSetReport, selected_names: string[]) -> testing.FlatTestReport { - 887 0 load_var 1 (report) - 1 load_field 0 (outcome) - 2 load_const 0 ("pass") - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 store_var 3 (top_tolerated) - - 888 5 load_var 1 (report) - 6 load_field 5 (results) - 7 container_len - 8 store_var 5 (_7) - 9 load_var 5 (_7) - 10 load_const 1 (0) - 11 cmp_int_op > - 12 pop_jump_if_false +2 (to 14) - 13 jump +24 (to 37) - - 890 14 load_var 3 (top_tolerated) - 15 pop_jump_if_false +2 (to 17) - 16 jump +11 (to 27) - - 899 17 load_var 1 (report) - 18 load_field 1 (passed) - - 900 19 load_var 1 (report) - 20 load_field 2 (failed) - 21 load_const 1 (0) - - 902 22 load_var 1 (report) - 23 load_field 3 (total) - 24 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 25 store_var 4 (counts) - - 890 26 jump +16 (to 42) - - 892 27 load_var 1 (report) - 28 load_field 1 (passed) - 29 load_const 1 (0) - - 894 30 load_var 1 (report) - 31 load_field 2 (failed) - - 895 32 load_var 1 (report) - 33 load_field 3 (total) - 34 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 35 store_var 4 (counts) - - 890 36 jump +6 (to 42) - - 889 37 load_var 1 (report) - 38 load_field 5 (results) - 39 load_var 3 (top_tolerated) - 40 call 881 ntypeargs=0 (testing.count_leaves) - 41 store_var 4 (counts) - - 905 42 load_type 2 - 43 alloc_array 0 - 44 store_var 6 (messages) - - 906 45 load_var 1 (report) - 46 load_field 5 (results) - 47 load_var 6 (messages) - 48 call 888 ntypeargs=0 (testing.collect_leaf_messages) - 49 pop 1 - - 907 50 load_type 2 - 51 alloc_array 0 - 52 store_var 7 (all_failed_names) - - 908 53 load_var2 1 7 - 54 call 887 ntypeargs=0 (testing.collect_all_failed_names) - 55 pop 1 - - 909 56 load_type 2 - 57 alloc_array 0 - 58 load_type 2 - 59 alloc_array 0 - 60 load_type 2 - 61 alloc_array 0 - 62 init_instance 2 (testing.LeafIdentities .passed, .failed, .tolerated) - 63 store_var 8 (executed) - - 910 64 load_var2 1 3 - 65 load_var2 2 8 - 66 call 886 ntypeargs=0 (testing.collect_leaf_identities) - 67 pop 1 - - 916 68 load_var 8 (executed) - 69 load_field 0 (passed) - 70 container_len - 71 store_var 10 (_36) - 72 load_var2 10 4 - 73 load_field 0 (passed) - 74 cmp_int_op == - 75 jump_if_false +9 (to 84) - 76 pop 1 - - 917 77 load_var 8 (executed) - 78 load_field 1 (failed) - 79 container_len - 80 store_var 11 (_39) - 81 load_var2 11 4 - 82 load_field 1 (failed) - 83 cmp_int_op == - - 916 84 jump_if_false +9 (to 93) - 85 pop 1 - - 918 86 load_var 8 (executed) - 87 load_field 2 (tolerated) - 88 container_len - 89 store_var 12 (_42) - 90 load_var2 12 4 - 91 load_field 2 (tolerated) - 92 cmp_int_op == - - 915 93 pop_jump_if_false +2 (to 95) - 94 jump +24 (to 118) - - 921 95 load_var 2 (selected_names) - 96 container_len - 97 store_var 13 (_46) - 98 load_var2 13 4 - 99 load_field 3 (total) - 100 cmp_int_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +10 (to 112) - - 927 103 load_type 2 - 104 alloc_array 0 - 105 load_type 2 - 106 alloc_array 0 - 107 load_type 2 - 108 alloc_array 0 - 109 init_instance 3 (testing.LeafIdentities .passed, .failed, .tolerated) - 110 store_var 9 (identities) - - 921 111 jump +9 (to 120) - - 922 112 load_var2 2 1 - 113 load_field 4 (failed_names) - 114 load_var 7 (all_failed_names) - 115 call 883 ntypeargs=0 (testing.classify_selected_names) - 116 store_var 9 (identities) - 117 jump +3 (to 120) - - 920 118 load_var 8 (executed) - 119 store_var 9 (identities) - - 930 120 load_var 1 (report) - 121 load_field 0 (outcome) - - 931 122 load_var 4 (counts) - 123 load_field 0 (passed) - - 932 124 load_var 4 (counts) - 125 load_field 1 (failed) - - 933 126 load_var 4 (counts) - 127 load_field 2 (tolerated) - - 934 128 load_var 4 (counts) - 129 load_field 3 (total) - - 935 130 load_var 9 (identities) - 131 load_field 0 (passed) - - 936 132 load_var 9 (identities) - 133 load_field 1 (failed) - - 937 134 load_var 9 (identities) - 135 load_field 2 (tolerated) - - 938 136 load_var 6 (messages) - 137 init_instance 4 (testing.FlatTestReport .outcome, .passed, .failed, .tolerated, .total, .passed_names, .failed_names, .tolerated_names, .messages) - 138 return -} - -function testing.glob_match(subject: string, pattern: string) -> bool { - 574 0 load_var 2 (pattern) - 1 load_const 0 ("*") - 2 call 150 ntypeargs=0 (baml.String.split) - 3 store_var 3 (parts) - - 575 4 load_var 3 (parts) - 5 container_len - 6 store_var 4 (n) - - 576 7 load_var 4 (n) - 8 load_const 1 (1) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +85 (to 96) - - 579 12 load_var 3 (parts) - 13 load_const 2 (0) - 14 load_array_element - 15 store_var 5 (first) - - 580 16 load_var2 3 4 - 17 load_const 1 (1) - 18 sub_int - 19 load_array_element - 20 store_var 6 (last) - - 581 21 load_var2 1 5 - 22 call 148 ntypeargs=0 (baml.String.starts_with) - 23 unary_op ! - 24 pop_jump_if_false +2 (to 26) - 25 jump +69 (to 94) - - 584 26 load_var2 1 6 - 27 call 149 ntypeargs=0 (baml.String.ends_with) - 28 unary_op ! - 29 pop_jump_if_false +2 (to 31) - 30 jump +62 (to 92) - - 587 31 load_var 5 (first) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 store_var 7 (start) - - 588 34 load_var 1 (subject) - 35 call 139 ntypeargs=0 (baml.String.length) - 36 store_var 9 (_24) - 37 load_var 6 (last) - 38 call 139 ntypeargs=0 (baml.String.length) - 39 store_var 10 (_25) - 40 load_var2 9 10 - 41 sub_int - 42 store_var 8 (end_limit) - - 589 43 load_var2 7 8 - 44 cmp_int_op > - 45 pop_jump_if_false +2 (to 47) - 46 jump +44 (to 90) - - 592 47 load_var 7 (start) - 48 store_var 11 (pos) - - 593 49 load_const 1 (1) - 50 store_var 12 (i) - 51 load_var2 12 4 - 52 load_const 1 (1) - 53 sub_int - 54 cmp_int_op < - 55 pop_jump_if_false +2 (to 57) - 56 jump +3 (to 59) - - 603 57 load_const 3 (true) - 58 jump +43 (to 101) - - 594 59 load_var2 3 12 - 60 load_array_element - 61 store_var_load_var 13 (part) - - 595 62 load_const 4 ("") - 63 cmp_op != - 64 pop_jump_if_false +21 (to 85) - - 596 65 load_var2 1 11 - 66 load_var 8 (end_limit) - 67 call 153 ntypeargs=0 (baml.String.slice) - 68 load_var 13 (part) - 69 call 155 ntypeargs=0 (baml.String.index_of) - 70 store_var 14 (_45) - 71 load_var 14 (_45) - 72 narrow_bind 2 14 - 73 pop_jump_if_false +2 (to 75) - 74 jump +3 (to 77) - - 599 75 load_const 5 (false) - 76 jump +25 (to 101) - - 597 77 load_var2 11 14 - - 596 78 add_int - 79 store_var 15 (_47) - - 597 80 load_var 13 (part) - 81 call 139 ntypeargs=0 (baml.String.length) - 82 load_var 15 (_47) - 83 add_int - 84 store_var 11 (pos) - - 593 85 load_var 12 (i) - 86 load_const 1 (1) - 87 add_int - 88 store_var 12 (i) - 89 jump -38 (to 51) - - 590 90 load_const 5 (false) - 91 jump +10 (to 101) - - 585 92 load_const 5 (false) - 93 jump +8 (to 101) - - 582 94 load_const 5 (false) - 95 jump +6 (to 101) - - 577 96 load_var2 1 2 - 97 call 155 ntypeargs=0 (baml.String.index_of) - 98 load_const 6 (null) - 99 call 672 ntypeargs=0 (baml.ops.equals_equals) - 100 unary_op ! - 101 return -} - -function testing.leaf_selected(name: string, include: string[], exclude: string[]) -> bool { - 618 0 load_var2 3 1 - 1 call 870 ntypeargs=0 (testing.any_pattern_matches) - 2 pop_jump_if_false +2 (to 4) - 3 jump +14 (to 17) - - 621 4 load_var 2 (include) - 5 container_len - 6 store_var 4 (_6) - 7 load_var 4 (_6) - 8 load_const 0 (0) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +4 (to 15) - - 624 12 load_var2 2 1 - 13 call 870 ntypeargs=0 (testing.any_pattern_matches) - 14 jump +4 (to 18) - - 622 15 load_const 1 (true) - 16 jump +2 (to 18) - - 619 17 load_const 2 (false) - 18 return -} - -function testing.leaf_selected_layered(name: string, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> bool { - 637 0 load_var2 1 2 - 1 load_var 3 (profile_exclude) - 2 call 871 ntypeargs=0 (testing.leaf_selected) - 3 jump_if_false +5 (to 8) - 4 pop 1 - - 638 5 load_var2 1 4 - 6 load_var 5 (cli_exclude) - 7 call 871 ntypeargs=0 (testing.leaf_selected) - 8 return -} - -function testing.name_in(name: string, names: string[]) -> bool { - 963 0 load_var 2 (names) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +6 (to 19) - 14 load_var2 4 1 - 15 cmp_op == - 16 pop_jump_if_false -11 (to 5) - - 965 17 load_const 5 (true) - 18 jump +2 (to 20) - - 968 19 load_const 6 (false) - 20 return -} - -function testing.pattern_may_match_descendant(pattern: string, prefix: string) -> bool { - 666 0 load_var 2 (prefix) - 1 load_const 0 ("::") - 2 bin_op + - 3 store_var 3 (descendant_prefix) - - 667 4 load_var 1 (pattern) - 5 load_const 1 ("*") - 6 call 155 ntypeargs=0 (baml.String.index_of) - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 load_const 2 (null) - 10 cmp_op == - 11 pop_jump_if_false +2 (to 13) - 12 jump +14 (to 26) - - 670 13 load_var 1 (pattern) - 14 load_const 3 (0) - - 667 15 load_var 4 (_4) - - 670 16 call 153 ntypeargs=0 (baml.String.slice) - 17 store_var 5 (literal) - - 671 18 load_var2 3 5 - 19 call 148 ntypeargs=0 (baml.String.starts_with) - 20 jump_if_false +2 (to 22) - 21 jump +6 (to 27) - 22 pop 1 - 23 load_var2 5 3 - 24 call 148 ntypeargs=0 (baml.String.starts_with) - 25 jump +2 (to 27) - - 668 26 load_const 4 (true) - 27 return -} - -function testing.run_children_parallel(children: testing.TestSetChild[]) -> testing.TestSetReport { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 484 3 load_type 0 - 4 alloc_array 0 - 5 store_var 2 (futures) - - 485 6 load_var 1 (children) - 7 load_type 1 - 8 load_const 2 ("iter") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 3 (_3) - 11 load_var 3 (_3) - 12 load_type 3 - 13 load_const 4 ("next") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 4 (_4) - 16 load_var 4 (_4) - 17 is_type 5 - 18 pop_jump_if_false +2 (to 20) - 19 jump +19 (to 38) - 20 load_const 6 (null) - 21 make_cell - 22 store_var 5 (child) - 23 load_var 4 (_4) - 24 store_deref 5 - - 486 25 load_var 5 (child) - 26 make_closure 1942 1 - 27 load_const 6 (null) - 28 load_const 6 (null) - 29 load_type 7 - 30 load_type 8 - 31 spawn - 32 store_var 6 (_11) - 33 load_type 0 - 34 load_var2 2 6 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -26 (to 11) - - 490 38 load_type 7 - 39 load_type 8 - 40 load_var 2 (futures) - 41 call 501 ntypeargs=2 (baml.future.all_complete) - 42 await - - 491 43 call 864 ntypeargs=0 (testing.aggregate_reports) - 44 return -} - -function testing.run_children_sequential(children: testing.TestSetChild[], fail_fast: bool) -> testing.TestSetReport { - 110 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (named_results) - - 111 3 load_var 1 (children) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_5) - 13 load_var 5 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +37 (to 53) - 17 load_var 5 (_5) - 18 store_var_load_var 6 (child) - - 112 19 load_field 1 (run) - 20 call_indirect - 21 store_var 7 (report) - - 113 22 load_type 0 - 23 load_var2 3 6 - 24 load_field 0 (name) - 25 load_var 7 (report) - 26 init_instance 0 (testing.NamedChildReport .name, .report) - 27 call 4 ntypeargs=1 (baml.Array.push) - 28 pop 1 - - 114 29 load_var 7 (report) - 30 store_var 9 (_17) - 31 load_var 9 (_17) - 32 narrow_bind 6 9 - 33 pop_jump_if_false +2 (to 35) - 34 jump +5 (to 39) - 35 load_var 7 (report) - 36 load_field 0 (outcome) - 37 store_var 8 (outcome) - 38 jump +4 (to 42) - 39 load_var 9 (_17) - 40 load_field 0 (outcome) - 41 store_var 8 (outcome) - - 118 42 load_var 2 (fail_fast) - 43 jump_if_false +6 (to 49) - 44 pop 1 - 45 load_var 8 (outcome) - 46 load_const 7 ("pass") - 47 call 672 ntypeargs=0 (baml.ops.equals_equals) - 48 unary_op ! - 49 pop_jump_if_false -41 (to 8) - - 119 50 load_var 3 (named_results) - 51 call 864 ntypeargs=0 (testing.aggregate_reports) - 52 jump +3 (to 55) - - 124 53 load_var 3 (named_results) - 54 call 864 ntypeargs=0 (testing.aggregate_reports) - 55 return -} - -function testing.run_test(body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestReport { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 496 3 load_var 1 (body) - 4 make_closure 1954 1 - 5 store_var 3 (base_run) - - 527 6 load_var 2 (runner) - 7 load_const 0 (null) - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +5 (to 15) - - 530 11 load_var2 3 2 - 12 call_indirect - - 531 13 call_indirect - 14 jump +3 (to 17) - - 528 15 load_var 3 (base_run) - 16 call_indirect - 17 return -} - -function testing.run_testset(children: testing.TestSetChild[], runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> testing.TestSetReport { - 538 0 load_var 2 (runner) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 540 5 load_var2 1 2 - 6 call_indirect - 7 jump +3 (to 10) - - 539 8 load_var 1 (children) - 9 call 865 ntypeargs=0 (testing.run_children_parallel) - 10 return -} - -function testing.select_names(registry: testing.TestRegistry, include: string[], exclude: string[]) -> string[] { - 739 0 load_var 1 (registry) - 1 load_type 0 - 2 alloc_array 0 - 3 load_type 0 - 4 alloc_array 0 - 5 load_var2 2 3 - 6 call 876 ntypeargs=0 (testing.select_names_layered) - 7 return -} - -function testing.select_names_layered(registry: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 700 0 load_type 0 - 1 alloc_array 0 - 2 store_var 6 (out) - - 701 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 7 (_8) - 10 load_var 7 (_8) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 8 (_9) - 15 load_var 8 (_9) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +14 (to 32) - 19 load_var 8 (_9) - 20 store_var_load_var 9 (t) - - 704 21 load_field 0 (name) - 22 load_var2 2 3 - 23 load_var2 4 5 - - 703 24 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 702 25 pop_jump_if_false -15 (to 10) - - 711 26 load_type 0 - 27 load_var2 6 9 - 28 load_field 0 (name) - 29 call 4 ntypeargs=1 (baml.Array.push) - 30 pop 1 - 31 jump -21 (to 10) - - 714 32 load_var 1 (registry) - 33 load_field 0 (collector) - 34 load_field 2 (testsets) - 35 load_type 6 - 36 load_const 7 ("iter") - 37 virtual_call nargs=1 ntypeargs=0 - 38 store_var 10 (_19) - 39 load_var 10 (_19) - 40 load_type 8 - 41 load_const 9 ("next") - 42 virtual_call nargs=1 ntypeargs=0 - 43 store_var 11 (_20) - 44 load_var 11 (_20) - 45 is_type 5 - 46 pop_jump_if_false +2 (to 48) - 47 jump +35 (to 82) - 48 load_var 11 (_20) - 49 store_var_load_var 12 (ts) - - 718 50 load_field 0 (name) - 51 load_var2 2 3 - 52 call 875 ntypeargs=0 (testing.subtree_may_be_selected) - 53 jump_if_false +6 (to 59) - 54 pop 1 - - 719 55 load_var 12 (ts) - 56 load_field 0 (name) - 57 load_var2 4 5 - 58 call 875 ntypeargs=0 (testing.subtree_may_be_selected) - - 717 59 pop_jump_if_false -20 (to 39) - - 721 60 load_var2 1 12 - - 723 61 load_var2 2 3 - 62 load_var2 4 5 - - 721 63 call 880 ntypeargs=0 (testing.collect_subtree_names_layered) - - 729 64 load_type 10 - 65 load_const 11 ("iter") - 66 virtual_call nargs=1 ntypeargs=0 - 67 store_var 13 (_31) - 68 load_var 13 (_31) - 69 load_type 12 - 70 load_const 13 ("next") - 71 virtual_call nargs=1 ntypeargs=0 - 72 store_var 14 (_32) - 73 load_var 14 (_32) - 74 is_type 5 - 75 pop_jump_if_false +2 (to 77) - 76 jump -37 (to 39) - - 730 77 load_type 0 - 78 load_var2 6 14 - 79 call 4 ntypeargs=1 (baml.Array.push) - 80 pop 1 - 81 jump -13 (to 68) - - 734 82 load_var 6 (out) - 83 return -} - -function testing.subtree_excluded(prefix: string, excludes: string[]) -> bool { - 645 0 load_var 1 (prefix) - 1 load_const 0 ("::") - 2 bin_op + - 3 store_var 3 (descendant_prefix) - - 646 4 load_var 2 (excludes) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +29 (to 46) - 18 load_var 5 (_5) - 19 store_var 6 (pattern) - - 649 20 load_var 6 (pattern) - 21 load_const 6 ("*") - 22 call 155 ntypeargs=0 (baml.String.index_of) - 23 load_const 7 (null) - 24 call 672 ntypeargs=0 (baml.ops.equals_equals) - 25 jump_if_false +7 (to 32) - 26 pop 1 - 27 load_var2 3 6 - 28 call 155 ntypeargs=0 (baml.String.index_of) - 29 load_const 7 (null) - 30 call 672 ntypeargs=0 (baml.ops.equals_equals) - 31 unary_op ! - 32 pop_jump_if_false +2 (to 34) - 33 jump +11 (to 44) - - 654 34 load_var 6 (pattern) - 35 load_const 8 ("*") - 36 call 149 ntypeargs=0 (baml.String.ends_with) - 37 jump_if_false +4 (to 41) - 38 pop 1 - 39 load_var2 3 6 - 40 call 869 ntypeargs=0 (testing.glob_match) - 41 pop_jump_if_false -32 (to 9) - - 655 42 load_const 9 (true) - 43 jump +4 (to 47) - - 650 44 load_const 9 (true) - 45 jump +2 (to 47) - - 658 46 load_const 10 (false) - 47 return -} - -function testing.subtree_may_be_selected(prefix: string, include: string[], exclude: string[]) -> bool { - 677 0 load_var2 1 3 - 1 call 873 ntypeargs=0 (testing.subtree_excluded) - 2 pop_jump_if_false +2 (to 4) - 3 jump +32 (to 35) - - 680 4 load_var 2 (include) - 5 container_len - 6 store_var 4 (_6) - 7 load_var 4 (_6) - 8 load_const 0 (0) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +22 (to 33) - - 683 12 load_var 2 (include) - 13 load_type 1 - 14 load_const 2 ("iter") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_7) - 17 load_var 5 (_7) - 18 load_type 3 - 19 load_const 4 ("next") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 6 (_8) - 22 load_var 6 (_8) - 23 is_type 5 - 24 pop_jump_if_false +2 (to 26) - 25 jump +6 (to 31) - 26 load_var2 6 1 - - 684 27 call 874 ntypeargs=0 (testing.pattern_may_match_descendant) - 28 pop_jump_if_false -11 (to 17) - - 685 29 load_const 6 (true) - 30 jump +6 (to 36) - - 688 31 load_const 7 (false) - 32 jump +4 (to 36) - - 681 33 load_const 6 (true) - 34 jump +2 (to 36) - - 678 35 load_const 7 (false) - 36 return -} - -function testing.test_child(name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestSetChild { - 0 load_var 2 - 1 make_cell - 2 store_var 2 - 3 load_var 3 - 4 make_cell - 5 store_var 3 - - 364 6 load_var2 1 2 - - 366 7 load_var 3 (runner) - 8 make_closure 1919 2 - 9 init_instance 0 (testing.TestSetChild .name, .run) - 10 return -} - -function testing.testset_child(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestSetChild { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 374 6 load_deref 2 - 7 load_field 0 (name) - - 375 8 load_var2 1 2 - 9 make_closure 1921 2 - 10 init_instance 0 (testing.TestSetChild .name, .run) - 11 return -} - -function testing.testset_child_selected(registry: testing.TestRegistry, ts: testing.TestSetRegistration, names: string[]) -> testing.TestSetChild { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - 6 load_var 3 - 7 make_cell - 8 store_var 3 - - 390 9 load_deref 2 - 10 load_field 0 (name) - - 391 11 load_var2 1 2 - 12 load_var 3 (names) - 13 make_closure 1923 3 - 14 init_instance 0 (testing.TestSetChild .name, .run) - 15 return -} - -function testing.testset_children(registry: testing.TestRegistry) -> testing.TestSetChild[] { - 329 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (children) - - 330 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_4) - 10 load_var 3 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_5) - 15 load_var 4 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +15 (to 33) - 19 load_var 4 (_5) - 20 store_var_load_var 5 (t) - - 331 21 load_field 0 (name) - 22 load_var 5 (t) - 23 load_field 1 (body) - 24 load_var 5 (t) - 25 load_field 2 (runner) - 26 call 859 ntypeargs=0 (testing.test_child) - 27 store_var 6 (_10) - 28 load_type 0 - 29 load_var2 2 6 - 30 call 4 ntypeargs=1 (baml.Array.push) - 31 pop 1 - 32 jump -22 (to 10) - - 333 33 load_var 1 (registry) - 34 load_field 0 (collector) - 35 load_field 2 (testsets) - 36 load_type 6 - 37 load_const 7 ("iter") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 7 (_16) - 40 load_var 7 (_16) - 41 load_type 8 - 42 load_const 9 ("next") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 8 (_17) - 45 load_var 8 (_17) - 46 is_type 5 - 47 pop_jump_if_false +2 (to 49) - 48 jump +9 (to 57) - - 334 49 load_var2 1 8 - 50 call 860 ntypeargs=0 (testing.testset_child) - 51 store_var 9 (_22) - 52 load_type 0 - 53 load_var2 2 9 - 54 call 4 ntypeargs=1 (baml.Array.push) - 55 pop 1 - 56 jump -16 (to 40) - - 336 57 load_var 2 (children) - 58 return -} - -function testing.testset_children_selected(registry: testing.TestRegistry, names: string[]) -> testing.TestSetChild[] { - 340 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (children) - - 341 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_5) - 10 load_var 4 (_5) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_6) - 15 load_var 5 (_6) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +20 (to 38) - 19 load_var 5 (_6) - 20 store_var_load_var 6 (t) - - 342 21 load_field 0 (name) - 22 load_var 2 (names) - 23 call 862 ntypeargs=0 (testing._name_selected) - 24 pop_jump_if_false -14 (to 10) - - 343 25 load_var 6 (t) - 26 load_field 0 (name) - 27 load_var 6 (t) - 28 load_field 1 (body) - 29 load_var 6 (t) - 30 load_field 2 (runner) - 31 call 859 ntypeargs=0 (testing.test_child) - 32 store_var 7 (_13) - 33 load_type 0 - 34 load_var2 3 7 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -27 (to 10) - - 348 38 load_var 1 (registry) - 39 load_field 0 (collector) - 40 load_field 2 (testsets) - 41 load_type 6 - 42 load_const 7 ("iter") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 8 (_19) - 45 load_var 8 (_19) - 46 load_type 8 - 47 load_const 9 ("next") - 48 virtual_call nargs=1 ntypeargs=0 - 49 store_var 9 (_20) - 50 load_var 9 (_20) - 51 is_type 5 - 52 pop_jump_if_false +2 (to 54) - 53 jump +16 (to 69) - 54 load_var 9 (_20) - 55 store_var_load_var 10 (ts) - - 354 56 load_field 0 (name) - 57 load_var 2 (names) - 58 call 863 ntypeargs=0 (testing._has_selected_descendant) - 59 pop_jump_if_false -14 (to 45) - - 355 60 load_var2 1 10 - 61 load_var 2 (names) - 62 call 861 ntypeargs=0 (testing.testset_child_selected) - 63 store_var 11 (_27) - 64 load_type 0 - 65 load_var2 3 11 - 66 call 4 ntypeargs=1 (baml.Array.push) - 67 pop 1 - 68 jump -23 (to 45) - - 360 69 load_var 3 (children) - 70 return -} - -function user.User.promote(self: User, bonus: int) -> Report { - 9 0 load_var 1 (self) - 1 copy 0 - 2 load_field 1 (age) - 3 load_const 0 (1) - 4 bin_op + - 5 store_field 1 (age) - - 10 6 load_var2 1 2 - 7 call 1373 ntypeargs=0 (user.score) - 8 store_var 3 (base) - - 11 9 load_var 3 (base) - 10 load_field 0 (score) - 11 load_var 2 (bonus) - 12 add_int - - 14 13 load_var 3 (base) - 14 load_field 1 (label) - - 15 15 load_var 3 (base) - 16 load_field 2 (breakdown) - 17 init_instance 0 (user.Report .score, .label, .breakdown) - 18 return -} - -function user.http_status(code: int) -> string { - 96 0 load_var 1 (code) - 1 dense_tag 0 - 2 jump_table 0 ([to 21, to 18, to 15, to 12, to 9, to 6], default to 3) - - 103 3 load_const 0 ("Unknown") - 4 store_var 2 (label) - - 96 5 jump +18 (to 23) - - 102 6 load_const 1 ("Internal Server Error") - 7 store_var 2 (label) - - 96 8 jump +15 (to 23) - - 101 9 load_const 2 ("Not Found") - 10 store_var 2 (label) - - 96 11 jump +12 (to 23) - - 100 12 load_const 3 ("Bad Request") - 13 store_var 2 (label) - - 96 14 jump +9 (to 23) - - 99 15 load_const 4 ("No Content") - 16 store_var 2 (label) - - 96 17 jump +6 (to 23) - - 98 18 load_const 5 ("Created") - 19 store_var 2 (label) - - 96 20 jump +3 (to 23) - - 97 21 load_const 6 ("OK") - 22 store_var 2 (label) - - 95 23 load_const 7 ("HTTP ") - - 105 24 load_var 2 (label) - 25 bin_op + - 26 return -} - -function user.score(input: User | ErrorInfo, threshold: int) -> Report { - 45 0 load_var 1 (input) - 1 store_var 4 (_4) - 2 load_var 4 (_4) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +5 (to 10) - - 47 6 load_var 1 (input) - 7 load_field 1 (message) - 8 store_var 3 (name) - - 45 9 jump +4 (to 13) - 10 load_var 4 (_4) - 11 load_field 0 (name) - 12 store_var 3 (name) - - 50 13 load_var 1 (input) - 14 store_var 6 (_8) - 15 load_var 6 (_8) - 16 narrow_bind 0 6 - 17 pop_jump_if_false +2 (to 19) - 18 jump +6 (to 24) - - 52 19 load_var 1 (input) - 20 load_field 0 (code) - 21 unary_op - - 22 store_var 5 (age) - - 50 23 jump +4 (to 27) - 24 load_var 6 (_8) - 25 load_field 1 (age) - 26 store_var 5 (age) - - 55 27 load_var 1 (input) - 28 store_var 8 (_13) - 29 load_var 8 (_13) - 30 narrow_bind 0 8 - 31 pop_jump_if_false +2 (to 33) - 32 jump +4 (to 36) - - 62 33 load_var 2 (threshold) - 34 store_var 7 (role_mult) - - 55 35 jump +16 (to 51) - 36 load_var 8 (_13) - 37 load_field 2 (role) - 38 discriminant - 39 jump_table 0 ([to 49, to 46, to 43, to 40], default to 102) - - 60 40 load_var 2 (threshold) - 41 store_var 7 (role_mult) - - 56 42 jump +9 (to 51) - - 59 43 load_var 2 (threshold) - 44 store_var 7 (role_mult) - - 56 45 jump +6 (to 51) - - 58 46 load_var 2 (threshold) - 47 store_var 7 (role_mult) - - 56 48 jump +3 (to 51) - - 57 49 load_var 2 (threshold) - 50 store_var 7 (role_mult) - - 65 51 load_var 5 (age) - 52 load_const 1 (2) - 53 mul_int - 54 load_var 7 (role_mult) - 55 add_int - 56 store_var_load_var 9 (base) - - 66 57 load_var 7 (role_mult) - 58 cmp_int_op > - 59 pop_jump_if_false +2 (to 61) - 60 jump +4 (to 64) - - 69 61 load_var 9 (base) - 62 store_var 10 (capped) - - 66 63 jump +3 (to 66) - - 67 64 load_var 7 (role_mult) - 65 store_var 10 (capped) - - 71 66 load_var2 10 7 - 67 add_int - 68 store_var_load_var 11 (total) - - 73 69 load_var 2 (threshold) - 70 cmp_int_op > - 71 load_const 2 (true) - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +4 (to 78) - - 75 75 load_const 3 (" [LOW]") - 76 store_var 12 (suffix) - - 73 77 jump +3 (to 80) - - 74 78 load_const 4 (" [HIGH]") - 79 store_var 12 (suffix) - - 79 80 load_var2 9 10 - 81 load_var 11 (total) - 82 load_type 5 - 83 alloc_array 3 - 84 store_var 13 (scores) - - 80 85 load_var 13 (scores) - 86 load_const 6 (0) - 87 load_var 11 (total) - 88 store_array_element - - 81 89 load_var 13 (scores) - 90 load_const 6 (0) - 91 load_array_element - - 77 92 load_var2 3 12 - 93 bin_op + - - 83 94 load_var2 9 7 - 95 load_const 7 ("base") - 96 load_const 8 ("role") - 97 load_type 9 - 98 load_type 5 - 99 alloc_map 2 - 100 init_instance 0 (user.Report .score, .label, .breakdown) - 101 return - 102 unreachable -} - -function vercel.AiGatewayImageClient.ai.Client.id(self: vercel.AiGatewayImageClient) -> string { - 105 0 load_var 1 (self) - 1 call 1335 ntypeargs=0 (vercel.internal._gw_images_client_id) - 2 return -} - -function vercel.AiGatewayImageClient.ai.Client.invoke(self: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 109 0 load_var2 1 2 - 1 call 1350 ntypeargs=0 (vercel.internal.gateway_images_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 110 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function vercel.AiGatewayImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, aspect_ratio: string | null, seed: int | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> vercel.AiGatewayImageClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 56 4 load_const 1 ("openai/gpt-image-1") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 57 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 58 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (n) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 59 22 load_const 2 (null) - 23 store_var 4 (n) - 24 load_var 5 (size) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 60 28 load_const 2 (null) - 29 store_var 5 (size) - 30 load_var 6 (aspect_ratio) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 61 34 load_const 2 (null) - 35 store_var 6 (aspect_ratio) - 36 load_var 7 (seed) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 62 40 load_const 2 (null) - 41 store_var 7 (seed) - 42 load_var 8 (request_body) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 63 46 load_const 2 (null) - 47 store_var 8 (request_body) - 48 load_var 9 (headers) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 64 52 load_const 2 (null) - 53 store_var 9 (headers) - 54 load_var 10 (query_params) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 65 58 load_const 2 (null) - 59 store_var 10 (query_params) - - 67 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 init_instance 0 (vercel.AiGatewayImageClient .model, .api_key, .base_url, .n, .size, .aspect_ratio, .seed, .request_body, .headers, .query_params) - 66 return -} - -function vercel.AiGatewayImageClient.resolved_api_key(self: vercel.AiGatewayImageClient) -> string { - 87 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("AI_GATEWAY_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 93 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("AI_GATEWAY_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 4 (_9) - 14 load_type 3 - 15 load_var 4 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 3 (_8) - - 90 18 load_const 4 ("ai-gateway-images") - 19 load_const 5 (null) - - 93 20 load_const 6 ("no AI Gateway API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — ") - 21 load_var 3 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 87 26 load_var 2 (_4) - 27 return -} - -function vercel.AiGatewayImageClient.resolved_base_url(self: vercel.AiGatewayImageClient) -> string | null { - 100 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function vercel.internal._gw_images_client_id(c: vercel.AiGatewayImageClient) -> string { - 93 0 load_type 0 - 1 load_var 1 (c) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 2 (_3) - 5 load_const 1 ("ai-gateway-images/") - 6 load_var 2 (_3) - 7 bin_op + - 8 return -} - -function vercel.internal._gw_images_drop_nulls(value: baml.json.json) -> baml.json.json { - 100 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +36 (to 41) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 122 12 load_var 1 (value) - - 100 13 jump +74 (to 87) - - 116 14 load_type 2 - 15 alloc_array 0 - 16 store_var 11 (out) - - 100 17 load_var 10 (_24) - 18 load_type 3 - 19 load_const 4 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 12 (_28) - - 117 22 load_var 12 (_28) - 23 load_type 5 - 24 load_const 6 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 13 (_29) - 27 load_var 13 (_29) - 28 is_type 7 - 29 pop_jump_if_false +2 (to 31) - 30 jump +9 (to 39) - 31 load_var 13 (_29) - - 118 32 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - 33 store_var 14 (_34) - 34 load_type 2 - 35 load_var2 11 14 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -16 (to 22) - - 120 39 load_var 11 (out) - - 100 40 jump +47 (to 87) - 41 load_var 2 (_2) - 42 store_var 3 (object) - - 102 43 load_type 8 - 44 load_type 2 - 45 alloc_map 0 - 46 store_var 4 (out) - - 103 47 load_type 8 - 48 load_type 2 - 49 load_var 3 (object) - 50 call 35 ntypeargs=2 (baml.Map.keys) - 51 load_type 9 - 52 load_const 10 ("iter") - 53 virtual_call nargs=1 ntypeargs=0 - 54 store_var 5 (_8) - 55 load_var 5 (_8) - 56 load_type 11 - 57 load_const 12 ("next") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 6 (_9) - 60 load_var 6 (_9) - 61 is_type 7 - 62 pop_jump_if_false +2 (to 64) - 63 jump +23 (to 86) - 64 load_var 6 (_9) - 65 store_var 7 (key) - - 104 66 load_type 8 - 67 load_type 2 - 68 load_var2 3 7 - 69 call 38 ntypeargs=2 (baml.Map.get) - 70 store_var 8 (entry) - - 105 71 load_var 8 (entry) - 72 load_const 13 (null) - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump -20 (to 55) - - 108 76 load_var 8 (entry) - 77 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - 78 store_var 9 (_20) - 79 load_type 8 - 80 load_type 2 - 81 load_var2 4 7 - 82 load_var 9 (_20) - 83 call 37 ntypeargs=2 (baml.Map.set) - 84 pop 1 - 85 jump -30 (to 55) - - 113 86 load_var 4 (out) - 87 return -} - -function vercel.internal._gw_images_escape_query(raw: string) -> string { - 228 0 load_var 1 (raw) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("&") - 8 load_const 5 ("%26") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("+") - 11 load_const 7 ("%2B") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("=") - 14 load_const 9 ("%3D") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("?") - 17 load_const 11 ("%3F") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - 19 load_const 12 ("#") - 20 load_const 13 ("%23") - 21 call 160 ntypeargs=0 (baml.String.replace_all) - - 239 22 return -} - -function vercel.internal._gw_images_file(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> vercel.internal.GwImagesFile { - 141 0 load_var 1 (media) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 2 (resolved) - - 142 4 load_var 2 (resolved) - 5 load_field 1 (base64) - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +20 (to 30) - - 150 11 load_var 2 (resolved) - 12 load_field 0 (url) - 13 store_var 4 (_9) - 14 load_var 4 (_9) - 15 narrow_bind 1 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +7 (to 24) - - 153 18 load_const 2 ("ai-gateway-images") - 19 load_const 3 (null) - 20 load_const 4 ("image input carried no base64 content, file, or URL") - 21 load_const 3 (null) - 22 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 23 throw - - 151 24 load_const 5 ("url") - 25 load_const 3 (null) - 26 load_const 3 (null) - - 150 27 load_var 4 (_9) - 28 init_instance 1 (vercel.internal.GwImagesFile .type, .mediaType, .data, .url) - - 151 29 jump +7 (to 36) - - 143 30 load_const 6 ("file") - - 145 31 load_var 2 (resolved) - 32 load_field 2 (mime_type) - - 142 33 load_var 3 (_4) - 34 load_const 3 (null) - 35 init_instance 2 (vercel.internal.GwImagesFile .type, .mediaType, .data, .url) - 36 return -} - -function vercel.internal._gw_images_find_output_format(value: baml.json.json | null) -> string | null { - 333 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +53 (to 57) - 5 load_var 2 (_2) - 6 store_var 3 (object) - - 334 7 load_type 1 - 8 load_type 2 - 9 load_var 3 (object) - 10 call 35 ntypeargs=2 (baml.Map.keys) - 11 load_type 3 - 12 load_const 4 ("iter") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_7) - 15 load_var 4 (_7) - 16 load_type 5 - 17 load_const 6 ("next") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 5 (_8) - 20 load_var 5 (_8) - 21 is_type 7 - 22 pop_jump_if_false +2 (to 24) - 23 jump +34 (to 57) - 24 load_var 5 (_8) - 25 store_var 6 (key) - - 335 26 load_type 1 - 27 load_type 2 - 28 load_var2 3 6 - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var 7 (entry) - - 336 31 load_var 6 (key) - 32 load_const 8 ("outputFormat") - 33 cmp_op == - 34 jump_if_false +2 (to 36) - 35 jump +5 (to 40) - 36 pop 1 - 37 load_var 6 (key) - 38 load_const 9 ("output_format") - 39 cmp_op == - 40 pop_jump_if_false +7 (to 47) - - 337 41 load_var 7 (entry) - 42 store_var 8 (_20) - 43 load_var 8 (_20) - 44 narrow_bind 10 8 - 45 pop_jump_if_false +2 (to 47) - 46 jump +9 (to 55) - - 341 47 load_var 7 (entry) - 48 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 49 store_var 9 (_24) - 50 load_var 9 (_24) - 51 narrow_bind 10 9 - 52 pop_jump_if_false -37 (to 15) - 53 load_var 9 (_24) - - 342 54 jump +4 (to 58) - - 337 55 load_var 8 (_20) - - 338 56 jump +2 (to 58) - - 346 57 load_const 11 (null) - 58 return -} - -function vercel.internal._gw_images_headers(c: vercel.AiGatewayImageClient) -> map { - 266 0 load_const 0 ("application/json") - 1 load_const 1 ("0.0.1") - 2 load_const 2 ("4") - - 270 3 load_var 1 (c) - 4 load_field 0 (model) - 5 load_const 3 ("content-type") - 6 load_const 4 ("ai-gateway-protocol-version") - 7 load_const 5 ("ai-image-model-specification-version") - 8 load_const 6 ("ai-model-id") - 9 load_type 7 - 10 load_type 7 - 11 alloc_map 4 - 12 store_var 2 (headers) - - 272 13 load_var 1 (c) - 14 load_field 8 (headers) - 15 store_var 3 (_5) - 16 load_var 3 (_5) - 17 narrow_bind 8 3 - 18 pop_jump_if_false +42 (to 60) - 19 load_var 3 (_5) - 20 store_var 4 (extra) - - 273 21 load_type 7 - 22 load_type 7 - 23 load_var 4 (extra) - 24 call 35 ntypeargs=2 (baml.Map.keys) - 25 load_type 9 - 26 load_const 10 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 5 (_10) - 29 load_var 5 (_10) - 30 load_type 11 - 31 load_const 12 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 6 (_11) - 34 load_var 6 (_11) - 35 is_type 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +23 (to 60) - 38 load_var 6 (_11) - 39 store_var 7 (name) - - 274 40 load_var 7 (name) - 41 call 142 ntypeargs=0 (baml.String.to_lower_case) - 42 store_var 8 (_16) - 43 load_type 7 - 44 load_type 7 - 45 load_var2 4 7 - 46 call 38 ntypeargs=2 (baml.Map.get) - 47 store_var_load_var 9 (_18) - 48 load_const 14 (null) - 49 cmp_op == - 50 pop_jump_if_false +3 (to 53) - 51 load_const 15 ("") - 52 store_var 9 (_18) - 53 load_type 7 - 54 load_type 7 - 55 load_var2 2 8 - 56 load_var 9 (_18) - 57 call 37 ntypeargs=2 (baml.Map.set) - 58 pop 1 - 59 jump -30 (to 29) - - 277 60 load_var 1 (c) - 61 call 1331 ntypeargs=0 (vercel.AiGatewayImageClient.resolved_api_key) - 62 store_var 11 (_29) - 63 load_type 7 - 64 load_var 11 (_29) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 10 (_28) - 67 load_type 7 - 68 load_type 7 - 69 load_var 2 (headers) - 70 load_const 16 ("authorization") - 71 load_const 17 ("Bearer ") - 72 load_var 10 (_28) - 73 bin_op + - 74 call 37 ntypeargs=2 (baml.Map.set) - 75 pop 1 - - 278 76 load_type 7 - 77 load_type 7 - 78 load_var 2 (headers) - 79 load_const 18 ("ai-gateway-auth-method") - 80 load_const 19 ("api-key") - 81 call 37 ntypeargs=2 (baml.Map.set) - 82 pop 1 - - 279 83 load_var 2 (headers) - 84 return -} - -function vercel.internal._gw_images_input(prompt: ai.Prompt, journal: ai.Journal) -> vercel.internal.GwImagesInput { - 171 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (parts) - - 172 3 load_type 1 - 4 alloc_array 0 - 5 store_var 4 (files) - - 173 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_6) - 12 load_var 5 (_6) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_7) - 17 load_var 6 (_7) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +71 (to 91) - 21 load_var 6 (_7) - 22 load_field 2 (parts) - 23 load_type 7 - 24 load_const 8 ("iter") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 7 (_12) - - 174 27 load_var 7 (_12) - 28 load_type 9 - 29 load_const 10 ("next") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 8 (_13) - 32 load_var 8 (_13) - 33 is_type 6 - 34 pop_jump_if_false +2 (to 36) - 35 jump -23 (to 12) - 36 load_var 8 (_13) - 37 store_var 9 (part) - - 175 38 load_var 9 (part) - 39 store_var 10 (_17) - 40 load_var 10 (_17) - 41 narrow_bind 11 10 - 42 pop_jump_if_false +2 (to 44) - 43 jump +36 (to 79) - 44 load_var 9 (part) - 45 store_var 12 (_25) - 46 load_var 12 (_25) - 47 narrow_bind 12 12 - 48 pop_jump_if_false +2 (to 50) - 49 jump +22 (to 71) - 50 load_var 9 (part) - 51 store_var 14 (_31) - 52 load_var 14 (_31) - 53 narrow_bind 13 14 - 54 pop_jump_if_false +2 (to 56) - 55 jump +13 (to 68) - 56 load_var 9 (part) - 57 store_var 15 (_33) - 58 load_var 15 (_33) - 59 narrow_bind 14 15 - 60 pop_jump_if_false +2 (to 62) - 61 jump +4 (to 65) - - 194 62 load_const 15 ("pdf") - 63 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 64 throw - - 191 65 load_const 16 ("video") - 66 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 67 throw - - 188 68 load_const 17 ("audio") - 69 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 70 throw - - 175 71 load_var 12 (_25) - - 184 72 call 1338 ntypeargs=0 (vercel.internal._gw_images_file) - 73 store_var 13 (_28) - 74 load_type 1 - 75 load_var2 4 13 - 76 call 4 ntypeargs=1 (baml.Array.push) - 77 pop 1 - 78 jump -51 (to 27) - - 175 79 load_var 10 (_17) - - 177 80 call 144 ntypeargs=0 (baml.String.trim) - 81 store_var 11 (trimmed) - - 178 82 load_var 11 (trimmed) - 83 load_const 18 ("") - 84 cmp_op != - 85 pop_jump_if_false -58 (to 27) - - 179 86 load_type 0 - 87 load_var2 3 11 - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -63 (to 27) - - 199 91 load_var 2 (journal) - 92 call 905 ntypeargs=0 (ai.Journal.entries) - 93 load_type 19 - 94 load_const 20 ("iter") - 95 virtual_call nargs=1 ntypeargs=0 - 96 store_var 16 (_37) - 97 load_var 16 (_37) - 98 load_type 21 - 99 load_const 22 ("next") - 100 virtual_call nargs=1 ntypeargs=0 - 101 store_var 17 (_38) - 102 load_var 17 (_38) - 103 is_type 6 - 104 pop_jump_if_false +2 (to 106) - 105 jump +19 (to 124) - 106 load_var 17 (_38) - 107 store_var 18 (_42) - - 200 108 load_var 18 (_42) - 109 narrow_bind 23 18 - 110 pop_jump_if_false -13 (to 97) - 111 load_var 18 (_42) - 112 load_field 0 (content) - - 201 113 call 144 ntypeargs=0 (baml.String.trim) - 114 store_var 19 (trimmed) - - 202 115 load_var 19 (trimmed) - 116 load_const 24 ("") - 117 cmp_op != - 118 pop_jump_if_false -21 (to 97) - - 203 119 load_type 0 - 120 load_var2 3 19 - 121 call 4 ntypeargs=1 (baml.Array.push) - 122 pop 1 - 123 jump -26 (to 97) - - 207 124 load_type 0 - 125 load_var 3 (parts) - 126 load_const 25 ("\n\n") - 127 call 15 ntypeargs=1 (baml.Array.join) - 128 store_var 20 (joined) - - 208 129 load_var 20 (joined) - 130 load_const 26 ("") - 131 cmp_op == - 132 pop_jump_if_false +2 (to 134) - 133 jump +4 (to 137) - - 216 134 load_var2 20 4 - 135 init_instance 0 (vercel.internal.GwImagesInput .text, .files) - 136 return - - 209 137 load_const 27 ("ai-gateway-images") - 138 load_const 28 (null) - 139 load_const 29 ("Images API request requires a text prompt") - 140 load_const 28 (null) - 141 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 142 throw -} - -function vercel.internal._gw_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - 127 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 2 (_4) - - 128 4 load_const 1 ("ai-gateway-images") - 5 load_const 2 (null) - - 127 6 load_const 3 ("Images API only supports text and image prompts; found ") - 7 load_var 2 (_4) - 8 bin_op + - 9 load_const 4 (" input") - 10 bin_op + - 11 load_const 2 (null) - 12 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 13 return -} - -function vercel.internal._gw_images_mime(format: string | null) -> string { - 350 0 load_var 1 (format) - 1 store_var_load_var 3 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("png") - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 call 142 ntypeargs=0 (baml.String.to_lower_case) - 9 store_var 2 (normalized) - - 351 10 load_var 2 (normalized) - 11 load_const 2 ("jpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 2 (normalized) - 16 load_const 3 ("jpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 2 (normalized) - 21 load_const 4 ("webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - 25 load_var 2 (normalized) - 26 load_const 5 ("gif") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +3 (to 32) - - 355 30 load_const 6 ("image/png") - - 351 31 jump +8 (to 39) - - 354 32 load_const 7 ("image/gif") - - 351 33 jump +6 (to 39) - - 353 34 load_const 8 ("image/webp") - - 351 35 jump +4 (to 39) - - 352 36 load_const 9 ("image/jpeg") - - 351 37 jump +2 (to 39) - - 352 38 load_const 10 ("image/jpeg") - 39 return -} - -function vercel.internal._gw_images_trim_slash(url: string) -> string { - 220 0 load_var 1 (url) - 1 load_const 0 ("/") - 2 call 149 ntypeargs=0 (baml.String.ends_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 223 5 load_var 1 (url) - 6 jump +10 (to 16) - - 221 7 load_var 1 (url) - 8 call 139 ntypeargs=0 (baml.String.length) - 9 store_var 2 (_4) - 10 load_var 1 (url) - 11 load_const 1 (0) - 12 load_var 2 (_4) - 13 load_const 2 (1) - 14 sub_int - 15 call 153 ntypeargs=0 (baml.String.slice) - 16 return -} - -function vercel.internal._gw_images_value(encoded: string, fallback_mime: string) -> image { - 365 0 load_var 1 (encoded) - 1 load_const 0 ("data:") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 381 5 load_var2 1 2 - 6 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 7 jump +58 (to 65) - - 366 8 load_var 1 (encoded) - 9 load_const 1 (";base64,") - 10 call 155 ntypeargs=0 (baml.String.index_of) - 11 store_var 3 (_5) - 12 load_var 3 (_5) - 13 narrow_bind 2 3 - 14 pop_jump_if_false +2 (to 16) - 15 jump +31 (to 46) - - 371 16 load_var 1 (encoded) - 17 call 139 ntypeargs=0 (baml.String.length) - 18 load_const 3 (48) - 19 cmp_int_op > - 20 pop_jump_if_false +2 (to 22) - 21 jump +4 (to 25) - - 374 22 load_var 1 (encoded) - 23 store_var 8 (preview) - - 371 24 jump +12 (to 36) - - 372 25 load_var 1 (encoded) - 26 load_const 2 (0) - 27 load_const 3 (48) - 28 call 153 ntypeargs=0 (baml.String.slice) - 29 store_var 9 (_19) - 30 load_type 4 - 31 load_var 9 (_19) - 32 call 138 ntypeargs=1 (baml.String.from) - 33 load_const 5 ("...") - 34 bin_op + - 35 store_var 8 (preview) - - 378 36 load_type 4 - 37 load_var 8 (preview) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 10 (_23) - - 376 40 load_const 6 ("ai-gateway-images") - - 378 41 load_const 7 ("images[] carried a data: URL with no ;base64, marker: ") - 42 load_var 10 (_23) - 43 bin_op + - 44 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 45 throw - - 366 46 load_var 3 (_5) - 47 store_var 4 (marker) - - 367 48 load_var 1 (encoded) - 49 load_const 8 (5) - 50 load_var 4 (marker) - 51 call 153 ntypeargs=0 (baml.String.slice) - 52 store_var 5 (mime) - - 368 53 load_var 4 (marker) - 54 load_const 9 (8) - 55 add_int - 56 store_var 6 (_10) - 57 load_var 1 (encoded) - 58 call 139 ntypeargs=0 (baml.String.length) - 59 store_var 7 (_12) - 60 load_var2 1 6 - 61 load_var 7 (_12) - 62 call 153 ntypeargs=0 (baml.String.slice) - - 369 63 load_var 5 (mime) - 64 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 65 return -} - -function vercel.internal._gw_images_with_query(url: string, params: map | null) -> string { - 243 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (pairs) - - 244 3 load_var 2 (params) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +54 (to 61) - 8 load_var 4 (_4) - 9 store_var 5 (configured) - - 245 10 load_type 0 - 11 load_type 0 - 12 load_var 5 (configured) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_9) - 18 load_var 6 (_9) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_10) - 23 load_var 7 (_10) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +35 (to 61) - 27 load_var 7 (_10) - 28 store_var_load_var 8 (key) - - 247 29 call 1341 ntypeargs=0 (vercel.internal._gw_images_escape_query) - 30 store_var 10 (_18) - 31 load_type 0 - 32 load_var 10 (_18) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 9 (_17) - 35 load_type 0 - 36 load_type 0 - 37 load_var2 5 8 - 38 call 38 ntypeargs=2 (baml.Map.get) - 39 store_var_load_var 13 (_24) - 40 load_const 7 (null) - 41 cmp_op == - 42 pop_jump_if_false +3 (to 45) - 43 load_const 8 ("") - 44 store_var 13 (_24) - 45 load_var 13 (_24) - 46 call 1341 ntypeargs=0 (vercel.internal._gw_images_escape_query) - 47 store_var 12 (_22) - 48 load_type 0 - 49 load_var 12 (_22) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 11 (_21) - - 246 52 load_type 0 - 53 load_var2 3 9 - - 247 54 load_const 9 ("=") - 55 bin_op + - 56 load_var 11 (_21) - 57 bin_op + - - 246 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -42 (to 18) - - 251 61 load_var 3 (pairs) - 62 container_len - 63 store_var 14 (_33) - 64 load_var 14 (_33) - 65 load_const 10 (0) - 66 cmp_int_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - - 254 69 load_var 1 (url) - 70 load_const 11 ("?") - 71 call 147 ntypeargs=0 (baml.String.includes) - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 257 74 load_const 12 ("?") - 75 store_var 15 (separator) - - 254 76 jump +3 (to 79) - - 255 77 load_const 13 ("&") - 78 store_var 15 (separator) - - 259 79 load_type 0 - 80 load_var 1 (url) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 16 (_37) - 83 load_type 0 - 84 load_var 15 (separator) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 17 (_39) - 87 load_type 0 - 88 load_var 3 (pairs) - 89 load_const 14 ("&") - 90 call 15 ntypeargs=1 (baml.Array.join) - 91 store_var 19 (_43) - 92 load_type 0 - 93 load_var 19 (_43) - 94 call 138 ntypeargs=1 (baml.String.from) - 95 store_var 18 (_42) - 96 load_var2 16 17 - 97 bin_op + - 98 load_var 18 (_42) - 99 bin_op + - 100 jump +2 (to 102) - - 252 101 load_var 1 (url) - 102 return -} - -function vercel.internal.gateway_images_invoke(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 457 0 load_var2 1 2 - 1 call 1344 ntypeargs=0 (vercel.internal.gateway_images_render) - 2 store_var 3 (req) - - 458 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("ai-gateway-images") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - 7 store_var 4 (resp) - - 459 8 load_var2 1 4 - 9 call 1349 ntypeargs=0 (vercel.internal.gateway_images_parse) - 10 return -} - -function vercel.internal.gateway_images_parse(c: vercel.AiGatewayImageClient, resp: vercel.internal.GwImagesResponse) -> ai.ModelTurn { - 412 0 load_var 2 (resp) - 1 load_field 1 (warnings) - 2 store_var_load_var 3 (_4) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_type 1 - 7 alloc_array 0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 2 - 11 load_const 3 ("iter") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_8) - - 413 14 load_var 4 (_8) - 15 load_type 4 - 16 load_const 5 ("next") - 17 virtual_call nargs=1 ntypeargs=0 - 18 store_var 5 (_9) - 19 load_var 5 (_9) - 20 is_type 6 - 21 pop_jump_if_false +2 (to 23) - 22 jump +15 (to 37) - 23 load_var 5 (_9) - - 414 24 call 1348 ntypeargs=0 (vercel.internal.gateway_images_warning_text) - 25 store_var 6 (_13) - 26 load_const 7 ("$baml_log") - 27 load_const 8 ("warn") - 28 load_var 6 (_13) - 29 load_const 9 ("level") - 30 load_const 10 ("data") - 31 load_type 11 - 32 load_type 12 - 33 alloc_map 2 - 34 send_event - 35 pop 1 - 36 jump -22 (to 14) - - 416 37 load_var 2 (resp) - 38 load_field 2 (providerMetadata) - 39 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 40 store_var_load_var 7 (_16) - 41 load_const 0 (null) - 42 cmp_op == - 43 pop_jump_if_false +5 (to 48) - - 417 44 load_var 1 (c) - 45 load_field 7 (request_body) - 46 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 47 store_var 7 (_16) - 48 load_var 7 (_16) - - 418 49 call 1346 ntypeargs=0 (vercel.internal._gw_images_mime) - 50 store_var 8 (fallback_mime) - - 419 51 load_var 2 (resp) - 52 load_field 0 (images) - 53 store_var_load_var 9 (_24) - 54 load_const 0 (null) - 55 cmp_op == - 56 pop_jump_if_false +4 (to 60) - 57 load_type 11 - 58 alloc_array 0 - 59 store_var 9 (_24) - - 420 60 load_type 13 - 61 alloc_array 0 - 62 store_var 10 (content) - - 419 63 load_var 9 (_24) - 64 load_type 14 - 65 load_const 15 ("iter") - 66 virtual_call nargs=1 ntypeargs=0 - 67 store_var 11 (_29) - - 421 68 load_var 11 (_29) - 69 load_type 16 - 70 load_const 17 ("next") - 71 virtual_call nargs=1 ntypeargs=0 - 72 store_var 12 (_30) - 73 load_var 12 (_30) - 74 is_type 6 - 75 pop_jump_if_false +2 (to 77) - 76 jump +19 (to 95) - 77 load_var 12 (_30) - 78 store_var 13 (encoded) - - 422 79 load_var 13 (encoded) - 80 call 144 ntypeargs=0 (baml.String.trim) - 81 load_const 18 ("") - 82 cmp_op != - 83 pop_jump_if_false -15 (to 68) - - 424 84 load_var2 13 8 - 85 call 1347 ntypeargs=0 (vercel.internal._gw_images_value) - 86 load_const 19 () - 87 load_const 19 () - 88 call 904 ntypeargs=0 (ai.content.Media.new) - 89 store_var 14 (_37) - - 423 90 load_type 13 - 91 load_var2 10 14 - 92 call 4 ntypeargs=1 (baml.Array.push) - 93 pop 1 - 94 jump -26 (to 68) - - 428 95 load_var 10 (content) - 96 container_len - 97 store_var 15 (_43) - 98 load_var 15 (_43) - 99 load_const 20 (0) - 100 cmp_int_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +41 (to 143) - - 434 103 load_var 2 (resp) - 104 load_field 3 (usage) - 105 store_var 17 (_47) - 106 load_var 17 (_47) - 107 narrow_bind 21 17 - 108 pop_jump_if_false +2 (to 110) - 109 jump +4 (to 113) - - 442 110 load_const 0 (null) - 111 store_var 16 (usage) - - 434 112 jump +25 (to 137) - 113 load_var 17 (_47) - 114 store_var_load_var 18 (reported) - - 436 115 load_field 0 (inputTokens) - 116 store_var_load_var 20 (_50) - 117 load_const 0 (null) - 118 cmp_op == - 119 pop_jump_if_false +3 (to 122) - 120 load_const 20 (0) - 121 store_var 20 (_50) - 122 load_var 20 (_50) - 123 store_var 19 (_49) - - 437 124 load_var 18 (reported) - 125 load_field 1 (outputTokens) - 126 store_var_load_var 21 (_54) - 127 load_const 0 (null) - 128 cmp_op == - 129 pop_jump_if_false +3 (to 132) - 130 load_const 20 (0) - 131 store_var 21 (_54) - - 435 132 load_var2 19 21 - - 437 133 load_const 0 (null) - 134 load_const 0 (null) - 135 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 136 store_var 16 (usage) - - 445 137 load_var 10 (content) - 138 load_const 20 (ai.content.StopReason.Complete) - 139 alloc_variant 774 (ai.content.StopReason) - - 447 140 load_var 16 (usage) - 141 init_instance 1 (ai.ModelTurn .content, .stop_reason, .usage) - 142 return - - 429 143 load_const 22 ("ai-gateway-images") - 144 load_const 23 ("response contained no images in images[]") - 145 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 146 throw -} - -function vercel.internal.gateway_images_render(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - 287 0 load_var 2 (input) - 1 load_field 2 (toolbox) - 2 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 3 unary_op ! - 4 pop_jump_if_false +2 (to 6) - 5 jump +90 (to 95) - - 295 6 load_var 2 (input) - 7 load_field 1 (journal) - 8 store_var 4 (_8) - 9 load_var 1 (c) - 10 call 1335 ntypeargs=0 (vercel.internal._gw_images_client_id) - 11 store_var 5 (_9) - 12 load_var2 4 5 - 13 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 14 store_var 3 (journal) - - 297 15 load_const 0 ("") - 16 load_var 2 (input) - 17 load_field 0 (prompt) - 18 call_indirect - 19 load_var 3 (journal) - 20 call 1339 ntypeargs=0 (vercel.internal._gw_images_input) - 21 store_var 6 (lowered) - - 298 22 load_var 6 (lowered) - 23 load_field 1 (files) - 24 container_len - 25 store_var 8 (_16) - 26 load_var 8 (_16) - 27 load_const 1 (0) - 28 cmp_int_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +5 (to 35) - - 301 31 load_var 6 (lowered) - 32 load_field 1 (files) - 33 store_var 7 (files) - - 298 34 jump +3 (to 37) - - 299 35 load_const 2 (null) - 36 store_var 7 (files) - - 304 37 load_var 6 (lowered) - 38 load_field 0 (text) - 39 store_var 9 (_19) - - 305 40 load_var 1 (c) - 41 load_field 3 (n) - 42 store_var_load_var 10 (_21) - 43 load_const 2 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 3 (1) - 47 store_var 10 (_21) - - 311 48 load_type 4 - - 303 49 load_var2 9 10 - - 306 50 load_var 1 (c) - 51 load_field 4 (size) - - 307 52 load_var 1 (c) - 53 load_field 5 (aspect_ratio) - - 308 54 load_var 1 (c) - 55 load_field 6 (seed) - - 309 56 load_var 7 (files) - 57 init_instance 0 (vercel.internal.GwImagesRequest .prompt, .n, .size, .aspectRatio, .seed, .files) - - 311 58 call 355 ntypeargs=1 (baml.json.to_json) - 59 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - - 312 60 load_var 1 (c) - 61 load_field 7 (request_body) - 62 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 63 store_var 11 (merged) - - 314 64 load_var 1 (c) - 65 call 1332 ntypeargs=0 (vercel.AiGatewayImageClient.resolved_base_url) - 66 store_var_load_var 14 (_40) - 67 load_const 2 (null) - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - 70 load_const 5 ("https://ai-gateway.vercel.sh/v4/ai") - 71 store_var 14 (_40) - 72 load_var 14 (_40) - 73 call 1340 ntypeargs=0 (vercel.internal._gw_images_trim_slash) - 74 store_var 13 (_38) - 75 load_type 6 - 76 load_var 13 (_38) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 load_const 7 ("/image-model") - 79 bin_op + - - 315 80 load_var 1 (c) - 81 load_field 9 (query_params) - - 313 82 call 1342 ntypeargs=0 (vercel.internal._gw_images_with_query) - 83 store_var 12 (url) - - 320 84 load_var 1 (c) - 85 call 1343 ntypeargs=0 (vercel.internal._gw_images_headers) - 86 store_var 15 (_46) - - 321 87 load_var 11 (merged) - 88 call 351 ntypeargs=0 (baml.json.stringify) - 89 store_var 16 (_47) - - 317 90 load_const 8 ("POST") - - 319 91 load_var2 12 15 - 92 load_var 16 (_47) - 93 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 94 return - - 288 95 load_const 9 ("ai-gateway-images") - 96 load_const 2 (null) - 97 load_const 10 ("the gateway image endpoint has no tool calling; run tools with a chat client instead") - 98 load_const 2 (null) - 99 init_instance 2 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 100 throw -} - -function vercel.internal.gateway_images_warning_text(warning: vercel.internal.GwImagesWarning) -> string { - 388 0 load_var 1 (warning) - 1 load_field 1 (feature) - 2 store_var_load_var 3 (_3) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (warning) - 7 load_field 3 (setting) - 8 store_var 3 (_3) - 9 load_var 3 (_3) - 10 store_var 2 (subject) - - 389 11 load_var 1 (warning) - 12 load_field 2 (details) - 13 store_var_load_var 5 (_7) - 14 load_const 0 (null) - 15 cmp_op == - 16 pop_jump_if_false +4 (to 20) - 17 load_var 1 (warning) - 18 load_field 4 (message) - 19 store_var 5 (_7) - 20 load_var 5 (_7) - 21 store_var 4 (detail) - - 390 22 load_var 1 (warning) - 23 load_field 0 (type) - 24 store_var_load_var 8 (_14) - 25 load_const 0 (null) - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - 28 load_const 1 ("other") - 29 store_var 8 (_14) - 30 load_type 2 - 31 load_var 8 (_14) - 32 call 138 ntypeargs=1 (baml.String.from) - 33 store_var 7 (_12) - 34 load_const 3 ("ai-gateway-images: ") - 35 load_var 7 (_12) - 36 bin_op + - 37 load_const 4 (" warning") - 38 bin_op + - 39 store_var 6 (head) - - 391 40 load_var 2 (subject) - 41 store_var 10 (_19) - 42 load_var 10 (_19) - 43 narrow_bind 5 10 - 44 pop_jump_if_false +2 (to 46) - 45 jump +4 (to 49) - - 394 46 load_var 6 (head) - 47 store_var 9 (named) - - 391 48 jump +17 (to 65) - 49 load_var 10 (_19) - 50 store_var 11 (subject_name) - - 392 51 load_type 2 - 52 load_var 6 (head) - 53 call 138 ntypeargs=1 (baml.String.from) - 54 store_var 12 (_22) - 55 load_type 2 - 56 load_var 11 (subject_name) - 57 call 138 ntypeargs=1 (baml.String.from) - 58 store_var 13 (_25) - 59 load_var 12 (_22) - 60 load_const 6 (" for ") - 61 bin_op + - 62 load_var 13 (_25) - 63 bin_op + - 64 store_var 9 (named) - - 396 65 load_var 4 (detail) - 66 store_var 14 (_28) - 67 load_var 14 (_28) - 68 narrow_bind 5 14 - 69 pop_jump_if_false +2 (to 71) - 70 jump +3 (to 73) - - 399 71 load_var 9 (named) - - 396 72 jump +16 (to 88) - 73 load_var 14 (_28) - 74 store_var 15 (text) - - 397 75 load_type 2 - 76 load_var 9 (named) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 16 (_31) - 79 load_type 2 - 80 load_var 15 (text) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 17 (_34) - 83 load_var 16 (_31) - 84 load_const 7 (": ") - 85 bin_op + - 86 load_var 17 (_34) - 87 bin_op + - 88 return -} diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap deleted file mode 100644 index 3b06257bcb7..00000000000 --- a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap +++ /dev/null @@ -1,34387 +0,0 @@ ---- -source: crates/baml_tests/tests/bytecode_format/main.rs ---- -function ai.Agent.Runner.run(self: ai.Agent<#0>, spec: ai.FunctionSpec<#0>) -> ai.RunResult<#0> { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - 6 load_var 5 - 7 make_cell - 8 store_var 5 - 9 load_var 20 - 10 make_cell - 11 store_var 20 - - 291 12 load_deref 1 - 13 load_field 1 (client) - 14 store_var_load_var 4 (_4) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +4 (to 21) - 18 load_deref 2 - 19 load_field 4 (default_client) - 20 store_var 4 (_4) - 21 load_var 4 (_4) - 22 store_var 3 (selected) - - 292 23 load_type 1 - 24 load_deref 2 - 25 call 906 ntypeargs=1 (ai.Journal.new) - 26 store_deref 5 - - 293 27 load_type 1 - 28 load_deref 1 - 29 load_deref 5 - 30 load_const 2 (0) - 31 call 956 ntypeargs=1 (ai.Agent._emit_from) - 32 store_var 6 (seen) - - 294 33 load_const 2 (0) - 34 store_var 7 (steps) - - 295 35 load_const 2 (0) - 36 load_const 2 (0) - 37 load_const 0 (null) - 38 load_const 0 (null) - 39 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 40 store_var 8 (total) - - 302 41 load_type 3 - 42 load_type 4 - 43 alloc_map 0 - 44 store_var 9 (fail_counts) - - 303 45 load_var 7 (steps) - 46 load_deref 1 - 47 load_field 0 (max_steps) - 48 cmp_int_op < - 49 pop_jump_if_false +2 (to 51) - 50 jump +4 (to 54) - - 373 51 load_var 7 (steps) - 52 init_instance 1 (ai.errors.StepBudgetExceeded .steps) - 53 throw - - 305 54 load_type 1 - 55 load_deref 1 - 56 load_var 3 (selected) - 57 load_deref 2 - 58 load_deref 5 - 59 load_var 8 (total) - 60 load_const 5 (2) - 61 call 955 ntypeargs=1 (ai.Agent._attempt_turn) - 62 store_var 10 (turn) - - 306 63 load_var 7 (steps) - 64 load_const 6 (1) - 65 add_int - 66 store_var 7 (steps) - - 307 67 load_type 1 - 68 load_deref 1 - 69 load_deref 5 - 70 load_var 6 (seen) - 71 call 956 ntypeargs=1 (ai.Agent._emit_from) - 72 store_var 6 (seen) - - 308 73 load_var 10 (turn) - 74 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 75 store_var 11 (calls) - - 309 76 load_var 11 (calls) - 77 container_len - 78 store_var 12 (_29) - 79 load_var 12 (_29) - 80 load_const 2 (0) - 81 cmp_int_op > - 82 pop_jump_if_false +2 (to 84) - 83 jump +78 (to 161) - - 344 84 load_var 10 (turn) - 85 call 925 ntypeargs=0 (ai.ModelTurn.terminal_text) - 86 store_var_load_var 33 (_98) - 87 load_const 0 (null) - 88 cmp_op == - 89 pop_jump_if_false +3 (to 92) - 90 load_const 7 ("") - 91 store_var 33 (_98) - 92 load_var 33 (_98) - 93 store_var 32 (candidate) - - 352 94 load_type 1 - 95 load_deref 1 - 96 load_var 10 (turn) - 97 call 952 ntypeargs=1 (ai.Agent._has_media_output) - 98 pop_jump_if_false +2 (to 100) - 99 jump +16 (to 115) - - 355 100 load_type 1 - 101 load_var 32 (candidate) - 102 call 445 ntypeargs=1 (baml.sap.parse) - 103 store_var 34 (value) - 104 jump +21 (to 125) - 105 load_var 36 (e) - 106 throw_if_panic - - 357 107 load_var 3 (selected) - 108 load_type 8 - 109 load_const 9 ("id") - 110 virtual_call nargs=1 ntypeargs=0 - 111 store_var 37 (_112) - 112 load_var2 37 32 - 113 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 114 throw - - 353 115 load_var 3 (selected) - 116 load_type 8 - 117 load_const 10 ("id") - 118 virtual_call nargs=1 ntypeargs=0 - 119 store_var 35 (_106) - 120 load_type 1 - 121 load_deref 1 - 122 load_var2 10 35 - 123 call 953 ntypeargs=1 (ai.Agent._media_value) - 124 store_var 34 (value) - - 361 125 load_type 1 - 126 load_var 34 (value) - 127 call 355 ntypeargs=1 (baml.json.to_json) - 128 jump +12 (to 140) - 129 load_var 38 (e) - 130 throw_if_panic - - 363 131 load_type 11 - 132 load_var 38 (e) - 133 call 138 ntypeargs=1 (baml.String.from) - 134 store_var 39 (_121) - 135 load_var2 38 39 - 136 load_type 3 - 137 alloc_array 1 - 138 init_instance 3 (baml.errors.UnknownError .data, .message) - 139 throw - - 367 140 call 351 ntypeargs=0 (baml.json.stringify) - 141 store_var 40 (_126) - - 366 142 load_deref 5 - - 367 143 load_var 40 (_126) - 144 init_instance 4 (ai.events.FinalProduced .value_json) - 145 load_type 12 - 146 alloc_array 1 - - 366 147 call 907 ntypeargs=0 (ai.Journal.append_all) - 148 pop 1 - - 369 149 load_type 1 - 150 load_deref 1 - 151 load_deref 5 - 152 load_var 6 (seen) - 153 call 956 ntypeargs=1 (ai.Agent._emit_from) - 154 store_var 6 (seen) - - 370 155 load_var 34 (value) - 156 load_deref 5 - 157 load_var 8 (total) - 158 load_type 1 - 159 init_instance 5 (ai.RunResult .value, .journal, .usage) - 160 return - - 310 161 load_deref 5 - 162 call 905 ntypeargs=0 (ai.Journal.entries) - 163 container_len - 164 store_var 13 (before) - - 312 165 load_type 13 - 166 load_type 14 - 167 load_type 15 - 168 load_var 11 (calls) - 169 load_type 1 - 170 load_var2 1 2 - 171 load_var 5 (j) - 172 make_closure 2263 captures=3 ntypeargs=1 - 173 call 16 ntypeargs=3 (baml.Array.map) - 174 store_var 14 (futures) - - 315 175 load_type 16 - 176 load_type 17 - 177 load_var 14 (futures) - 178 call 502 ntypeargs=2 (baml.future.all) - 179 await - 180 pop 1 - - 316 181 load_type 1 - 182 load_deref 1 - 183 load_deref 5 - 184 load_var 6 (seen) - 185 call 956 ntypeargs=1 (ai.Agent._emit_from) - 186 store_var 6 (seen) - - 320 187 load_deref 5 - 188 call 905 ntypeargs=0 (ai.Journal.entries) - 189 store_var 15 (entries) - - 321 190 load_var 13 (before) - 191 store_var 16 (i) - - 322 192 load_var 16 (i) - 193 store_var 17 (_48) - 194 load_var 15 (entries) - 195 container_len - 196 store_var 18 (_49) - 197 load_var2 17 18 - 198 cmp_int_op < - 199 pop_jump_if_false -154 (to 45) - - 323 200 load_type 12 - 201 load_var2 15 16 - 202 call 3 ntypeargs=1 (baml.Array.at) - 203 store_var 19 (_53) - 204 load_var 19 (_53) - 205 narrow_bind 18 19 - 206 pop_jump_if_false +57 (to 263) - 207 load_var 19 (_53) - 208 store_deref 20 - - 324 209 load_type 13 - 210 load_type 15 - 211 load_var 11 (calls) - 212 load_type 1 - 213 load_var 20 (f) - 214 make_closure 2264 captures=1 ntypeargs=1 - 215 call 19 ntypeargs=2 (baml.Array.find) - - 327 216 store_var 21 (_59) - 217 load_var 21 (_59) - 218 narrow_bind 19 21 - 219 pop_jump_if_false +44 (to 263) - 220 load_var 21 (_59) - 221 store_var 22 (known) - - 328 222 load_type 3 - 223 load_var 22 (known) - 224 load_field 1 (name) - 225 call 138 ntypeargs=1 (baml.String.from) - 226 store_var 24 (_63) - 227 load_type 3 - 228 load_deref 20 - 229 load_field 1 (message) - 230 call 138 ntypeargs=1 (baml.String.from) - 231 store_var 25 (_66) - 232 load_var 24 (_63) - 233 load_const 20 ("|") - 234 bin_op + - 235 load_var 25 (_66) - 236 bin_op + - 237 store_var 23 (key) - - 329 238 load_type 3 - 239 load_type 4 - 240 load_var2 9 23 - 241 call 38 ntypeargs=2 (baml.Map.get) - 242 store_var_load_var 27 (_71) - 243 load_const 0 (null) - 244 cmp_op == - 245 pop_jump_if_false +3 (to 248) - 246 load_const 2 (0) - 247 store_var 27 (_71) - 248 load_var 27 (_71) - 249 load_const 6 (1) - 250 add_int - 251 store_var 26 (n) - - 330 252 load_type 3 - 253 load_type 4 - 254 load_var2 9 23 - 255 load_var 26 (n) - 256 call 37 ntypeargs=2 (baml.Map.set) - 257 pop 1 - - 331 258 load_var 26 (n) - 259 load_const 21 (3) - 260 cmp_int_op >= - 261 pop_jump_if_false +2 (to 263) - 262 jump +6 (to 268) - - 341 263 load_var 16 (i) - 264 load_const 6 (1) - 265 add_int - 266 store_var 16 (i) - - 322 267 jump -75 (to 192) - - 333 268 load_var 22 (known) - 269 load_field 0 (id) - 270 store_var 28 (_85) - - 334 271 load_var 22 (known) - 272 load_field 1 (name) - 273 store_var 29 (_86) - - 335 274 load_type 4 - 275 load_var 26 (n) - 276 call 138 ntypeargs=1 (baml.String.from) - 277 store_var 30 (_90) - 278 load_type 3 - 279 load_deref 20 - 280 load_field 1 (message) - 281 call 138 ntypeargs=1 (baml.String.from) - 282 store_var 31 (_93) - - 332 283 load_var2 28 29 - - 335 284 load_const 22 ("the same tool call failed ") - 285 load_var 30 (_90) - 286 bin_op + - 287 load_const 23 (" times; stopping the run: ") - 288 bin_op + - 289 load_var 31 (_93) - 290 bin_op + - 291 load_const 0 (null) - 292 init_instance 6 (ai.errors.ToolFailedError .id, .name, .message, .cause) - 293 throw -} - -function ai.Agent._attempt_turn(self: ai.Agent<#0>, c: ai.Client, spec: ai.FunctionSpec<#0>, j: ai.Journal, total: ai.events.Usage, attempts_left: int) -> ai.ModelTurn { - 217 0 load_var 3 (spec) - 1 load_field 2 (prompt_template) - 2 store_var 8 (_9) - - 219 3 load_type 0 - 4 load_var 3 (spec) - 5 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 6 store_var 9 (_10) - - 220 7 load_type 0 - 8 load_var 3 (spec) - 9 call 915 ntypeargs=1 (ai.FunctionSpec.output_type) - 10 store_var 10 (_12) - - 215 11 load_var2 2 8 - - 216 12 load_var2 4 9 - 13 load_var 10 (_12) - 14 init_instance 0 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) - 15 load_type 1 - 16 load_const 2 ("invoke") - 17 virtual_call nargs=2 ntypeargs=0 - 18 store_var 7 (turn) - - 223 19 load_var 7 (turn) - 20 load_field 2 (usage) - 21 store_var 11 (_15) - 22 load_var 11 (_15) - 23 narrow_bind 3 11 - 24 pop_jump_if_false +57 (to 81) - 25 load_var 11 (_15) - 26 store_var 12 (u) - - 224 27 load_var 5 (total) - 28 copy 0 - 29 load_field 0 (input_tokens) - 30 load_var 12 (u) - 31 load_field 0 (input_tokens) - 32 bin_op + - 33 store_field 0 (input_tokens) - - 225 34 load_var 5 (total) - 35 copy 0 - 36 load_field 1 (output_tokens) - 37 load_var 12 (u) - 38 load_field 1 (output_tokens) - 39 bin_op + - 40 store_field 1 (output_tokens) - - 226 41 load_var 12 (u) - 42 load_field 2 (cached_input_tokens) - 43 store_var 13 (_20) - 44 load_var 13 (_20) - 45 narrow_bind 4 13 - 46 pop_jump_if_false +15 (to 61) - 47 load_var 13 (_20) - 48 store_var 14 (ci) - - 227 49 load_var 5 (total) - 50 load_field 2 (cached_input_tokens) - 51 store_var_load_var 15 (_23) - 52 load_const 5 (null) - 53 cmp_op == - 54 pop_jump_if_false +3 (to 57) - 55 load_const 4 (0) - 56 store_var 15 (_23) - 57 load_var2 5 15 - 58 load_var 14 (ci) - 59 bin_op + - 60 store_field 2 (cached_input_tokens) - - 229 61 load_var 12 (u) - 62 load_field 3 (reasoning_tokens) - 63 store_var 16 (_28) - 64 load_var 16 (_28) - 65 narrow_bind 4 16 - 66 pop_jump_if_false +15 (to 81) - 67 load_var 16 (_28) - 68 store_var 17 (rt) - - 230 69 load_var 5 (total) - 70 load_field 3 (reasoning_tokens) - 71 store_var_load_var 18 (_31) - 72 load_const 5 (null) - 73 cmp_op == - 74 pop_jump_if_false +3 (to 77) - 75 load_const 4 (0) - 76 store_var 18 (_31) - 77 load_var2 5 18 - 78 load_var 17 (rt) - 79 bin_op + - 80 store_field 3 (reasoning_tokens) - - 234 81 load_var 7 (turn) - 82 load_field 0 (content) - 83 store_var 20 (_37) - 84 load_var 2 (c) - 85 load_type 1 - 86 load_const 6 ("id") - 87 virtual_call nargs=1 ntypeargs=0 - 88 store_var 21 (_38) - 89 load_var2 20 21 - 90 init_instance 1 (ai.events.AssistantMessage .content, .client_id) - 91 load_type 7 - 92 alloc_array 1 - 93 store_var 19 (batch) - - 235 94 load_var 7 (turn) - 95 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 96 load_type 8 - 97 load_const 9 ("iter") - 98 virtual_call nargs=1 ntypeargs=0 - 99 store_var 22 (_40) - 100 load_var 22 (_40) - 101 load_type 10 - 102 load_const 11 ("next") - 103 virtual_call nargs=1 ntypeargs=0 - 104 store_var 23 (_41) - 105 load_var 23 (_41) - 106 is_type 12 - 107 pop_jump_if_false +2 (to 109) - 108 jump +14 (to 122) - 109 load_var 23 (_41) - 110 store_var 24 (u) - - 236 111 load_type 7 - 112 load_var2 19 24 - 113 load_field 0 (id) - 114 load_var 24 (u) - 115 load_field 1 (name) - 116 load_var 24 (u) - 117 load_field 2 (args) - 118 init_instance 2 (ai.events.ToolRequested .id, .name, .args) - 119 call 4 ntypeargs=1 (baml.Array.push) - 120 pop 1 - 121 jump -21 (to 100) - - 238 122 load_var 7 (turn) - 123 load_field 2 (usage) - 124 store_var 25 (_52) - 125 load_var 25 (_52) - 126 narrow_bind 3 25 - 127 pop_jump_if_false +7 (to 134) - 128 load_var 25 (_52) - 129 store_var 26 (u) - - 239 130 load_type 7 - 131 load_var2 19 26 - 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - - 241 134 load_var 7 (turn) - 135 call 925 ntypeargs=0 (ai.ModelTurn.terminal_text) - 136 store_var_load_var 28 (_58) - 137 load_const 5 (null) - 138 cmp_op == - 139 pop_jump_if_false +3 (to 142) - 140 load_const 13 ("") - 141 store_var 28 (_58) - 142 load_var 28 (_58) - 143 store_var 27 (candidate) - - 242 144 load_var 7 (turn) - 145 call 927 ntypeargs=0 (ai.ModelTurn.tool_uses) - 146 container_len - 147 store_var 29 (_65) - 148 load_var 29 (_65) - 149 load_const 4 (0) - 150 cmp_int_op > - 151 jump_if_false +2 (to 153) - 152 jump +7 (to 159) - 153 pop 1 - - 243 154 load_var 7 (turn) - 155 load_field 1 (stop_reason) - 156 load_const 14 (ai.content.StopReason.MaxTokens) - 157 alloc_variant 774 (ai.content.StopReason) - 158 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 242 159 jump_if_false +2 (to 161) - 160 jump +7 (to 167) - 161 pop 1 - - 244 162 load_var 7 (turn) - 163 load_field 1 (stop_reason) - 164 load_const 15 (ai.content.StopReason.Refused) - 165 alloc_variant 774 (ai.content.StopReason) - 166 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 242 167 jump_if_false +2 (to 169) - 168 jump +6 (to 174) - 169 pop 1 - - 245 170 load_type 0 - 171 load_var2 1 7 - 172 load_var 27 (candidate) - 173 call 954 ntypeargs=1 (ai.Agent._parses) - - 246 174 pop_jump_if_false +2 (to 176) - 175 jump +34 (to 209) - - 259 176 load_var 6 (attempts_left) - 177 load_const 16 (1) - 178 cmp_int_op > - 179 pop_jump_if_false +2 (to 181) - 180 jump +12 (to 192) - - 268 181 load_var2 4 19 - 182 call 907 ntypeargs=0 (ai.Journal.append_all) - 183 pop 1 - - 269 184 load_var 2 (c) - 185 load_type 1 - 186 load_const 17 ("id") - 187 virtual_call nargs=1 ntypeargs=0 - 188 store_var 32 (_93) - 189 load_var2 32 27 - 190 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 191 throw - - 260 192 load_type 7 - 193 load_var 19 (batch) - - 261 194 load_const 18 ("The reply did not match the required schema. Answer again with only the corrected value.") - 195 init_instance 4 (ai.events.UserMessage .content) - - 260 196 call 4 ntypeargs=1 (baml.Array.push) - 197 pop 1 - - 265 198 load_var2 4 19 - 199 call 907 ntypeargs=0 (ai.Journal.append_all) - 200 pop 1 - - 266 201 load_type 0 - 202 load_var2 1 2 - 203 load_var2 3 4 - 204 load_var2 5 6 - 205 load_const 16 (1) - 206 sub_int - 207 call 955 ntypeargs=1 (ai.Agent._attempt_turn) - 208 jump +19 (to 227) - - 247 209 load_var2 4 19 - 210 call 907 ntypeargs=0 (ai.Journal.append_all) - 211 pop 1 - - 249 212 load_var 7 (turn) - 213 load_field 1 (stop_reason) - 214 discriminant - 215 load_const 14 (StopReason.MaxTokens) - 216 cmp_int_op == - 217 pop_jump_if_false +2 (to 219) - 218 jump +20 (to 238) - 219 load_var 7 (turn) - 220 load_field 1 (stop_reason) - 221 discriminant - 222 load_const 15 (StopReason.Refused) - 223 cmp_int_op == - 224 pop_jump_if_false +2 (to 226) - 225 jump +3 (to 228) - - 258 226 load_var 7 (turn) - 227 return - - 254 228 load_var 2 (c) - 229 load_type 1 - 230 load_const 19 ("id") - 231 virtual_call nargs=1 ntypeargs=0 - 232 store_var 31 (_81) - 233 load_var 31 (_81) - 234 load_const 20 ("the model declined to answer") - 235 load_const 5 (null) - 236 init_instance 5 (ai.errors.Refused .provider, .reason, .raw_body) - 237 throw - - 251 238 load_var 2 (c) - 239 load_type 1 - 240 load_const 21 ("id") - 241 virtual_call nargs=1 ntypeargs=0 - 242 store_var 30 (_78) - 243 load_var2 30 27 - 244 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) - 245 throw -} - -function ai.Agent._emit_from(self: ai.Agent<#0>, j: ai.Journal, seen: int) -> int { - 275 0 load_var 2 (j) - 1 call 905 ntypeargs=0 (ai.Journal.entries) - 2 store_var 4 (entries) - - 276 3 load_var 3 (seen) - 4 store_var 5 (i) - - 277 5 load_var 5 (i) - 6 store_var 6 (_7) - 7 load_var 4 (entries) - 8 container_len - 9 store_var 7 (_8) - 10 load_var2 6 7 - 11 cmp_int_op < - 12 pop_jump_if_false +2 (to 14) - 13 jump +4 (to 17) - - 283 14 load_var 4 (entries) - 15 container_len - 16 return - - 278 17 load_type 0 - 18 load_var2 4 5 - 19 call 3 ntypeargs=1 (baml.Array.at) - 20 store_var 8 (_12) - 21 load_var 8 (_12) - 22 narrow_bind 1 8 - 23 pop_jump_if_false +2 (to 25) - 24 jump +28 (to 52) - 25 load_var 8 (_12) - 26 narrow_bind 2 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +24 (to 52) - 29 load_var 8 (_12) - 30 narrow_bind 3 8 - 31 pop_jump_if_false +2 (to 33) - 32 jump +20 (to 52) - 33 load_var 8 (_12) - 34 narrow_bind 4 8 - 35 pop_jump_if_false +2 (to 37) - 36 jump +16 (to 52) - 37 load_var 8 (_12) - 38 narrow_bind 5 8 - 39 pop_jump_if_false +2 (to 41) - 40 jump +12 (to 52) - 41 load_var 8 (_12) - 42 narrow_bind 6 8 - 43 pop_jump_if_false +2 (to 45) - 44 jump +8 (to 52) - 45 load_var 8 (_12) - 46 narrow_bind 7 8 - 47 pop_jump_if_false +2 (to 49) - 48 jump +4 (to 52) - 49 load_var 8 (_12) - 50 narrow_bind 8 8 - 51 pop_jump_if_false +7 (to 58) - 52 load_var 8 (_12) - 53 store_var_load_var 9 (e) - - 279 54 load_var 1 (self) - 55 load_field 3 (on_event) - 56 call_indirect - 57 pop 1 - - 281 58 load_var 5 (i) - 59 load_const 9 (1) - 60 add_int - 61 store_var 5 (i) - - 277 62 jump -57 (to 5) -} - -function ai.Agent._has_media_output(self: ai.Agent<#0>, turn: ai.ModelTurn) -> bool { - 104 0 load_type 0 - 1 call 985 ntypeargs=0 (ai.internal._media_shape) - 2 store_var 3 (shape) - - 105 3 load_var 3 (shape) - 4 load_const 1 (":") - 5 call 150 ntypeargs=0 (baml.String.split) - 6 store_var 6 (_8) - 7 load_type 2 - 8 load_var 6 (_8) - 9 load_const 3 (0) - 10 call 3 ntypeargs=1 (baml.Array.at) - 11 store_var_load_var 5 (_6) - 12 load_const 4 (null) - 13 cmp_op == - 14 pop_jump_if_false +3 (to 17) - 15 load_const 5 ("") - 16 store_var 5 (_6) - 17 load_var 5 (_6) - 18 store_var_load_var 4 (form) - - 106 19 load_const 6 ("") - 20 cmp_op == - 21 pop_jump_if_false +2 (to 23) - 22 jump +42 (to 64) - - 109 23 load_var 4 (form) - 24 load_const 7 ("mixed") - 25 cmp_op == - 26 jump_if_false +2 (to 28) - 27 jump +5 (to 32) - 28 pop 1 - 29 load_var 4 (form) - 30 load_const 8 ("mixedlist") - 31 cmp_op == - 32 pop_jump_if_false +2 (to 34) - 33 jump +23 (to 56) - - 112 34 load_var 3 (shape) - 35 load_const 9 (":") - 36 call 150 ntypeargs=0 (baml.String.split) - 37 store_var 10 (_24) - 38 load_type 2 - 39 load_var 10 (_24) - 40 load_const 10 (1) - 41 call 3 ntypeargs=1 (baml.Array.at) - 42 store_var_load_var 9 (_22) - 43 load_const 4 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 11 ("") - 47 store_var 9 (_22) - 48 load_var2 2 9 - 49 call 987 ntypeargs=0 (ai.internal._media_of_kind) - 50 container_len - 51 store_var 8 (_19) - 52 load_var 8 (_19) - 53 load_const 3 (0) - 54 cmp_int_op > - 55 jump +10 (to 65) - - 110 56 load_var 2 (turn) - 57 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - 58 container_len - 59 store_var 7 (_17) - 60 load_var 7 (_17) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 jump +2 (to 65) - - 107 64 load_const 12 (false) - 65 return -} - -function ai.Agent._media_value(self: ai.Agent<#0>, turn: ai.ModelTurn, provider: string) -> #0 { - 119 0 load_type 0 - 1 store_var 4 (t) - - 120 2 load_var 4 (t) - 3 call 985 ntypeargs=0 (ai.internal._media_shape) - 4 store_var 5 (shape) - - 121 5 load_var 5 (shape) - 6 load_const 1 (":") - 7 call 150 ntypeargs=0 (baml.String.split) - 8 store_var 8 (_10) - 9 load_type 2 - 10 load_var 8 (_10) - 11 load_const 3 (0) - 12 call 3 ntypeargs=1 (baml.Array.at) - 13 store_var_load_var 7 (_8) - 14 load_const 4 (null) - 15 cmp_op == - 16 pop_jump_if_false +3 (to 19) - 17 load_const 5 ("") - 18 store_var 7 (_8) - 19 load_var 7 (_8) - 20 store_var 6 (form) - - 122 21 load_var 5 (shape) - 22 load_const 6 (":") - 23 call 150 ntypeargs=0 (baml.String.split) - 24 store_var 11 (_16) - 25 load_type 2 - 26 load_var 11 (_16) - 27 load_const 7 (1) - 28 call 3 ntypeargs=1 (baml.Array.at) - 29 store_var_load_var 10 (_14) - 30 load_const 4 (null) - 31 cmp_op == - 32 pop_jump_if_false +3 (to 35) - 33 load_const 8 ("") - 34 store_var 10 (_14) - 35 load_var 10 (_14) - 36 store_var 9 (kind) - - 123 37 load_var 6 (form) - 38 load_const 9 ("mixedlist") - 39 cmp_op == - 40 pop_jump_if_false +2 (to 42) - 41 jump +205 (to 246) - 42 load_var 6 (form) - 43 load_const 10 ("mixed") - 44 cmp_op == - 45 pop_jump_if_false +2 (to 47) - 46 jump +131 (to 177) - 47 load_var 6 (form) - 48 load_const 11 ("list") - 49 cmp_op == - 50 pop_jump_if_false +2 (to 52) - 51 jump +118 (to 169) - - 152 52 load_var2 2 9 - 53 call 987 ntypeargs=0 (ai.internal._media_of_kind) - 54 store_var 23 (parts) - - 153 55 load_var2 2 9 - 56 load_var 3 (provider) - 57 call 991 ntypeargs=0 (ai.internal._media_reject_mixed) - 58 pop 1 - - 154 59 load_var 23 (parts) - 60 container_len - 61 store_var 24 (_57) - 62 load_var 24 (_57) - 63 load_const 7 (1) - 64 cmp_int_op != - 65 pop_jump_if_false +2 (to 67) - 66 jump +25 (to 91) - - 164 67 load_const 4 (null) - 68 store_var 36 (only) - - 165 69 load_var 23 (parts) - 70 load_type 12 - 71 load_const 13 ("iter") - 72 virtual_call nargs=1 ntypeargs=0 - 73 store_var 37 (_97) - 74 load_var 37 (_97) - 75 load_type 14 - 76 load_const 15 ("next") - 77 virtual_call nargs=1 ntypeargs=0 - 78 store_var 38 (_98) - 79 load_var 38 (_98) - 80 is_type 16 - 81 pop_jump_if_false +2 (to 83) - 82 jump +6 (to 88) - 83 load_var 38 (_98) - 84 store_var 39 (p) - - 166 85 load_var 39 (p) - 86 store_var 36 (only) - - 165 87 jump -13 (to 74) - - 168 88 load_var 36 (only) - 89 store_var 12 (payload) - - 123 90 jump +159 (to 249) - - 157 91 load_var 6 (form) - 92 load_const 17 ("one") - 93 cmp_op == - 94 pop_jump_if_false +2 (to 96) - 95 jump +42 (to 137) - - 160 96 load_type 2 - 97 load_var 9 (kind) - 98 call 138 ntypeargs=1 (baml.String.from) - 99 store_var 30 (_83) - 100 load_var 4 (t) - 101 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 102 store_var 32 (_87) - 103 load_type 2 - 104 load_var 32 (_87) - 105 call 138 ntypeargs=1 (baml.String.from) - 106 store_var 31 (_86) - 107 load_var 23 (parts) - 108 container_len - 109 store_var 34 (_90) - 110 load_type 18 - 111 load_var 34 (_90) - 112 call 138 ntypeargs=1 (baml.String.from) - 113 store_var 33 (_89) - 114 load_type 2 - 115 load_var 9 (kind) - 116 call 138 ntypeargs=1 (baml.String.from) - 117 store_var 35 (_92) - 118 load_const 19 ("Expected zero or one ") - 119 load_var 30 (_83) - 120 bin_op + - 121 load_const 20 (" output for ") - 122 bin_op + - 123 load_var 31 (_86) - 124 bin_op + - 125 load_const 21 (", got ") - 126 bin_op + - 127 load_var 33 (_89) - 128 bin_op + - 129 load_const 22 (". Use ") - 130 bin_op + - 131 load_var 35 (_92) - 132 bin_op + - 133 load_const 23 ("[] for multiple outputs.") - 134 bin_op + - 135 store_var 25 (_59) - - 157 136 jump +30 (to 166) - - 158 137 load_type 2 - 138 load_var 9 (kind) - 139 call 138 ntypeargs=1 (baml.String.from) - 140 store_var 26 (_67) - 141 load_var 23 (parts) - 142 container_len - 143 store_var 28 (_71) - 144 load_type 18 - 145 load_var 28 (_71) - 146 call 138 ntypeargs=1 (baml.String.from) - 147 store_var 27 (_70) - 148 load_type 2 - 149 load_var 9 (kind) - 150 call 138 ntypeargs=1 (baml.String.from) - 151 store_var 29 (_73) - 152 load_const 24 ("Expected exactly one ") - 153 load_var 26 (_67) - 154 bin_op + - 155 load_const 25 (" output, got ") - 156 bin_op + - 157 load_var 27 (_70) - 158 bin_op + - 159 load_const 26 (". Use ") - 160 bin_op + - 161 load_var 29 (_73) - 162 bin_op + - 163 load_const 27 ("[] for multiple outputs.") - 164 bin_op + - 165 store_var 25 (_59) - - 155 166 load_var2 3 25 - 167 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 168 throw - - 147 169 load_var2 2 9 - 170 load_var 3 (provider) - 171 call 991 ntypeargs=0 (ai.internal._media_reject_mixed) - 172 pop 1 - - 148 173 load_var2 2 9 - 174 call 987 ntypeargs=0 (ai.internal._media_of_kind) - - 149 175 store_var 12 (payload) - - 123 176 jump +73 (to 249) - - 129 177 load_var 2 (turn) - 178 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - 179 store_var 13 (items) - - 130 180 load_var 13 (items) - 181 container_len - 182 store_var 14 (_25) - 183 load_var 14 (_25) - 184 load_const 7 (1) - 185 cmp_int_op == - 186 pop_jump_if_false +2 (to 188) - 187 jump +35 (to 222) - - 136 188 load_var 13 (items) - 189 call 989 ntypeargs=0 (ai.internal._media_all_text) - 190 pop_jump_if_false +2 (to 192) - 191 jump +27 (to 218) - - 142 192 load_var 4 (t) - 193 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 194 store_var 20 (_42) - 195 load_type 2 - 196 load_var 20 (_42) - 197 call 138 ntypeargs=1 (baml.String.from) - 198 store_var 19 (_41) - 199 load_var 13 (items) - 200 container_len - 201 store_var 22 (_45) - 202 load_type 18 - 203 load_var 22 (_45) - 204 call 138 ntypeargs=1 (baml.String.from) - 205 store_var 21 (_44) - - 140 206 load_var 3 (provider) - - 142 207 load_const 28 ("Expected one text or image output for ") - 208 load_var 19 (_41) - 209 bin_op + - 210 load_const 29 (", got ") - 211 bin_op + - 212 load_var 21 (_44) - 213 bin_op + - 214 load_const 30 (" parts. Use (image | string)[] to preserve mixed outputs.") - 215 bin_op + - 216 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 217 throw - - 138 218 load_var 13 (items) - 219 call 990 ntypeargs=0 (ai.internal._media_join_text) - 220 store_var 12 (payload) - 221 jump +28 (to 249) - - 131 222 load_const 4 (null) - 223 store_var 15 (only) - - 132 224 load_var 13 (items) - 225 load_type 12 - 226 load_const 31 ("iter") - 227 virtual_call nargs=1 ntypeargs=0 - 228 store_var 16 (_28) - 229 load_var 16 (_28) - 230 load_type 14 - 231 load_const 32 ("next") - 232 virtual_call nargs=1 ntypeargs=0 - 233 store_var 17 (_29) - 234 load_var 17 (_29) - 235 is_type 16 - 236 pop_jump_if_false +2 (to 238) - 237 jump +6 (to 243) - 238 load_var 17 (_29) - 239 store_var 18 (i) - - 133 240 load_var 18 (i) - 241 store_var 15 (only) - - 132 242 jump -13 (to 229) - - 135 243 load_var 15 (only) - 244 store_var 12 (payload) - - 130 245 jump +4 (to 249) - - 125 246 load_var 2 (turn) - 247 call 988 ntypeargs=0 (ai.internal._media_mixed_parts) - - 126 248 store_var 12 (payload) - - 171 249 load_type 0 - 250 load_var 12 (payload) - 251 call 358 ntypeargs=1 (baml.json.from_json) - 252 jump +36 (to 288) - 253 load_var 40 (e) - 254 throw_if_panic - - 175 255 load_type 2 - 256 load_var 9 (kind) - 257 call 138 ntypeargs=1 (baml.String.from) - 258 store_var 41 (_111) - 259 load_var 4 (t) - 260 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 261 store_var 43 (_115) - 262 load_type 2 - 263 load_var 43 (_115) - 264 call 138 ntypeargs=1 (baml.String.from) - 265 store_var 42 (_114) - 266 load_type 33 - 267 load_var 40 (e) - 268 call 138 ntypeargs=1 (baml.String.from) - 269 store_var 45 (_118) - 270 load_type 2 - 271 load_var 45 (_118) - 272 call 138 ntypeargs=1 (baml.String.from) - 273 store_var 44 (_117) - - 173 274 load_var 3 (provider) - - 175 275 load_const 34 ("the ") - 276 load_var 41 (_111) - 277 bin_op + - 278 load_const 35 (" output did not fit ") - 279 bin_op + - 280 load_var 42 (_114) - 281 bin_op + - 282 load_const 36 (": ") - 283 bin_op + - 284 load_var 44 (_117) - 285 bin_op + - 286 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 287 throw - 288 return -} - -function ai.Agent._parses(self: ai.Agent<#0>, turn: ai.ModelTurn, candidate: string) -> bool { - 190 0 load_type 0 - 1 load_var2 1 2 - 2 call 952 ntypeargs=1 (ai.Agent._has_media_output) - 3 pop_jump_if_false +2 (to 5) - 4 jump +12 (to 16) - - 193 5 load_type 0 - 6 load_var 3 (candidate) - 7 call 445 ntypeargs=1 (baml.sap.parse) - 8 pop 1 - 9 jump +5 (to 14) - 10 load_var 4 (e) - 11 throw_if_panic - - 195 12 load_const 1 (false) - 13 jump +4 (to 17) - - 198 14 load_const 2 (true) - 15 jump +2 (to 17) - - 191 16 load_const 2 (true) - 17 return -} - -function ai.Agent._run_one_tool(self: ai.Agent<#0>, tb: ai.tools.Toolbox, call: ai.content.ToolUse, j: ai.Journal) -> void { - 56 0 load_var2 2 3 - 1 load_field 1 (name) - 2 call 923 ntypeargs=0 (ai.tools.Toolbox.get) - 3 store_var 5 (_7) - 4 load_var 5 (_7) - 5 narrow_bind 0 5 - 6 pop_jump_if_false +2 (to 8) - 7 jump +20 (to 27) - - 89 8 load_var 3 (call) - 9 load_field 0 (id) - 10 store_var 20 (_42) - - 90 11 load_type 1 - 12 load_var 3 (call) - 13 load_field 1 (name) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 21 (_44) - - 86 16 load_var2 4 20 - - 90 17 load_const 2 ("tool is not in the active toolbox: ") - 18 load_var 21 (_44) - 19 bin_op + - 20 init_instance 0 (ai.events.ToolFailed .id, .message) - 21 load_type 3 - 22 alloc_array 1 - - 86 23 call 907 ntypeargs=0 (ai.Journal.append_all) - 24 pop 1 - - 94 25 load_const 4 (null) - - 56 26 jump +85 (to 111) - 27 load_var 5 (_7) - 28 store_var 6 (t) - - 58 29 load_var2 6 3 - 30 load_field 2 (args) - 31 call 918 ntypeargs=0 (ai.tools.Tool.call) - 32 store_var 7 (outcome) - 33 jump +62 (to 95) - 34 load_var 8 (e) - 35 throw_if_panic - - 61 36 load_var 3 (call) - 37 load_field 0 (id) - 38 store_var 9 (_15) - 39 load_type 5 - 40 load_var 8 (e) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 10 (_16) - - 60 43 load_var2 4 9 - - 61 44 load_var 10 (_16) - 45 init_instance 1 (ai.events.ToolFailed .id, .message) - 46 load_type 3 - 47 alloc_array 1 - - 60 48 call 907 ntypeargs=0 (ai.Journal.append_all) - 49 pop 1 - - 64 50 load_var 6 (t) - 51 load_field 5 (on_error) - 52 store_var_load_var 11 (_20) - 53 load_const 4 (null) - 54 cmp_op == - 55 pop_jump_if_false +4 (to 59) - 56 load_var 1 (self) - 57 load_field 2 (tool_errors) - 58 store_var 11 (_20) - 59 load_var 11 (_20) - 60 load_const 6 (ai.tools.ErrorMode.Raise) - 61 alloc_variant 775 (ai.tools.ErrorMode) - 62 call 672 ntypeargs=0 (baml.ops.equals_equals) - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 76 65 load_const 4 (null) - 66 store_var 7 (outcome) - - 64 67 jump +28 (to 95) - - 65 68 load_var 8 (e) - 69 store_var 13 (_24) - 70 load_var 13 (_24) - 71 narrow_bind 7 13 - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 67 74 load_const 4 (null) - 75 store_var 12 (classified) - - 65 76 jump +5 (to 81) - 77 load_var 13 (_24) - 78 store_var 14 (f) - - 66 79 load_var 14 (f) - 80 store_var 12 (classified) - - 70 81 load_var 3 (call) - 82 load_field 0 (id) - 83 store_var 15 (_27) - - 71 84 load_var 3 (call) - 85 load_field 1 (name) - 86 store_var 16 (_28) - - 72 87 load_type 5 - 88 load_var 8 (e) - 89 call 138 ntypeargs=1 (baml.String.from) - 90 store_var 17 (_29) - - 69 91 load_var2 15 16 - 92 load_var2 17 12 - - 73 93 init_instance 2 (ai.errors.ToolFailedError .id, .name, .message, .cause) - 94 throw - - 80 95 load_var 7 (outcome) - 96 store_var 18 (_32) - 97 load_var 18 (_32) - 98 narrow_bind 6 18 - 99 pop_jump_if_false +11 (to 110) - 100 load_var 18 (_32) - 101 store_var 19 (output) - - 81 102 load_var2 4 3 - 103 load_field 0 (id) - 104 load_var 19 (output) - 105 init_instance 3 (ai.events.ToolCompleted .id, .output) - 106 load_type 3 - 107 alloc_array 1 - 108 call 907 ntypeargs=0 (ai.Journal.append_all) - 109 pop 1 - - 83 110 load_const 4 (null) - 111 return -} - -function ai.Agent.new(max_steps: int, client: ai.Client | null, tool_errors: ai.tools.ErrorMode, on_event: ((ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced) -> null throws never) | null) -> ai.Agent<#0> { - 0 load_var 1 (max_steps) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 30 4 load_const 1 (12) - 5 store_var 1 (max_steps) - 6 load_var 2 (client) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 31 10 load_const 2 (null) - 11 store_var 2 (client) - 12 load_var 3 (tool_errors) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +4 (to 19) - - 32 16 load_const 3 (ai.tools.ErrorMode.Report) - 17 alloc_variant 775 (ai.tools.ErrorMode) - 18 store_var 3 (tool_errors) - 19 load_var 4 (on_event) - 20 load_const 0 () - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - - 33 23 load_const 2 (null) - 24 store_var 4 (on_event) - - 39 25 load_var 4 (on_event) - 26 store_var_load_var 5 (_10) - 27 load_const 2 (null) - 28 cmp_op == - 29 pop_jump_if_false +4 (to 33) - - 41 30 load_type 4 - 31 make_closure 2209 captures=0 ntypeargs=1 - 32 store_var 5 (_10) - - 35 33 load_var2 1 2 - 34 load_var2 3 5 - - 39 35 load_type 4 - 36 init_instance 0 (ai.Agent .max_steps, .client, .tool_errors, .on_event) - 37 return -} - -function ai.Context.output_format_with(self: ai.Context, prefix: string | null, or_splitter: string | null, enum_value_prefix: string | null, hoisted_class_prefix: string | null, always_hoist_enums: bool | null, quote_class_fields: bool | null, hoist_classes: string[] | null, map_style: string | null, render_null_as: string | null) -> string { -} - -function ai.FunctionSpec.arguments(self: ai.FunctionSpec<#0>) -> map { - 108 0 load_var 1 (self) - 1 load_field 1 (args) - 2 return -} - -function ai.FunctionSpec.name(self: ai.FunctionSpec<#0>) -> string { - 104 0 load_var 1 (self) - 1 load_field 0 (spec_name) - 2 return -} - -function ai.FunctionSpec.output_type(self: ai.FunctionSpec<#0>) -> type { - 112 0 load_type 0 - 1 store_var 3 (output_type) - - 113 2 load_var 3 (output_type) - 3 call 1006 ntypeargs=0 (ai.internal.validate_output_type) - 4 pop 1 - - 114 5 load_var 3 (output_type) - 6 store_var 2 (_0) - 7 load_var 2 (_0) - 8 return -} - -function ai.FunctionSpec.prompt(self: ai.FunctionSpec<#0>, output_format: string) -> ai.Prompt { - 0 load_var 2 (output_format) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 117 4 load_const 1 ("") - 5 store_var 2 (output_format) - - 118 6 load_var2 2 1 - 7 load_field 2 (prompt_template) - 8 call_indirect - 9 return -} - -function ai.FunctionSpec.tools(self: ai.FunctionSpec<#0>) -> ai.tools.Toolbox { - 122 0 load_var 1 (self) - 1 load_field 3 (toolbox) - 2 return -} - -function ai.Journal.append_all(self: ai.Journal, events: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[]) -> void { - 27 0 load_var 2 (events) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 4 (_3) - 5 load_var 4 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 5 (_4) - 10 load_var 5 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +10 (to 23) - 14 load_var 5 (_4) - 15 store_var 6 (e) - - 28 16 load_type 5 - 17 load_var 1 (self) - 18 load_field 0 (log) - 19 load_var 6 (e) - 20 call 4 ntypeargs=1 (baml.Array.push) - 21 pop 1 - 22 jump -17 (to 5) - - 26 23 load_const 6 (null) - 24 store_var 3 (_0) - 25 load_var 3 (_0) - 26 return -} - -function ai.Journal.entries(self: ai.Journal) -> (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[] { - 15 0 load_var 1 (self) - 1 load_field 0 (log) - 2 return -} - -function ai.Journal.new(spec: ai.FunctionSpec<#0>) -> ai.Journal { - 21 0 load_type 0 - 1 load_var 1 (spec) - 2 call 913 ntypeargs=1 (ai.FunctionSpec.name) - 3 store_var 3 (_4) - 4 load_type 0 - 5 load_var 1 (spec) - 6 call 914 ntypeargs=1 (ai.FunctionSpec.arguments) - 7 store_var 4 (_6) - 8 load_var2 3 4 - 9 init_instance 0 (ai.events.RunStarted .spec_name, .arguments) - 10 load_type 1 - 11 alloc_array 1 - 12 init_instance 1 (ai.Journal .log) - 13 store_var 2 (_0) - 14 load_var 2 (_0) - 15 return -} - -function ai.ModelTurn.media(self: ai.ModelTurn) -> (baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf)[] { - 34 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 35 3 load_var 1 (self) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +16 (to 33) - 18 load_var 5 (_5) - 19 store_var 6 (b) - - 36 20 load_var 6 (b) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 7 (_9) - 26 store_var 8 (m) - - 37 27 load_type 0 - 28 load_var2 3 8 - 29 load_field 0 (media) - 30 call 4 ntypeargs=1 (baml.Array.push) - 31 pop 1 - 32 jump -23 (to 9) - - 40 33 load_var 3 (out) - 34 store_var 2 (_0) - 35 load_var 2 (_0) - 36 return -} - -function ai.ModelTurn.terminal_text(self: ai.ModelTurn) -> string | null { - 22 0 load_const 0 (null) - 1 store_var 2 (out) - - 23 2 load_var 1 (self) - 3 load_field 0 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_5) - 13 load_var 4 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +14 (to 30) - 17 load_var 4 (_5) - 18 store_var 5 (b) - - 24 19 load_var 5 (b) - 20 store_var 6 (_9) - 21 load_var 6 (_9) - 22 narrow_bind 6 6 - 23 pop_jump_if_false -15 (to 8) - 24 load_var 6 (_9) - 25 store_var 7 (t) - - 25 26 load_var 7 (t) - 27 load_field 0 (text) - 28 store_var 2 (out) - - 24 29 jump -21 (to 8) - - 28 30 load_var 2 (out) - 31 return -} - -function ai.ModelTurn.tool_uses(self: ai.ModelTurn) -> ai.content.ToolUse[] { - 45 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 46 3 load_var 1 (self) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +15 (to 32) - 18 load_var 5 (_5) - 19 store_var 6 (b) - - 47 20 load_var 6 (b) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 7 (_9) - 26 store_var 8 (u) - - 48 27 load_type 0 - 28 load_var2 3 8 - 29 call 4 ntypeargs=1 (baml.Array.push) - 30 pop 1 - 31 jump -22 (to 9) - - 51 32 load_var 3 (out) - 33 store_var 2 (_0) - 34 load_var 2 (_0) - 35 return -} - -function ai.Prompt.baml.ToString.to_string(self: ai.Prompt) -> string { - 70 0 load_var 1 (self) - 1 call 909 ntypeargs=0 (ai.Prompt.text) - 2 return -} - -function ai.Prompt.messages(self: ai.Prompt) -> ai.PromptMessage[] { -} - -function ai.Prompt.text(self: ai.Prompt) -> string { -} - -function ai.clients.Backoff.delay_ms(self: ai.clients.Backoff, attempt: int, f: ai.errors.Failure) -> int { - 71 0 load_var 3 (f) - 1 store_var 4 (_5) - 2 load_var 4 (_5) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 73 6 load_const 1 (null) - - 71 7 jump +5 (to 12) - 8 load_var 4 (_5) - 9 store_var 5 (r) - - 72 10 load_var 5 (r) - 11 load_field 1 (retry_after_ms) - - 75 12 store_var 6 (_7) - 13 load_var 6 (_7) - 14 narrow_bind 2 6 - 15 pop_jump_if_false +2 (to 17) - 16 jump +29 (to 45) - - 78 17 load_var 1 (self) - 18 load_field 0 (initial_ms) - 19 store_var 8 (d) - - 79 20 load_const 3 (1) - 21 store_var 9 (i) - - 80 22 load_var2 9 2 - 23 cmp_int_op < - 24 pop_jump_if_false +2 (to 26) - 25 jump +11 (to 36) - - 84 26 load_var2 8 1 - 27 load_field 2 (max_ms) - 28 cmp_int_op > - 29 pop_jump_if_false +2 (to 31) - 30 jump +3 (to 33) - - 87 31 load_var 8 (d) - - 84 32 jump +16 (to 48) - - 85 33 load_var 1 (self) - 34 load_field 2 (max_ms) - - 84 35 jump +13 (to 48) - - 81 36 load_var2 8 1 - 37 load_field 1 (multiplier) - 38 mul_int - 39 store_var 8 (d) - - 82 40 load_var 9 (i) - 41 load_const 3 (1) - 42 add_int - 43 store_var 9 (i) - - 80 44 jump -22 (to 22) - - 75 45 load_var 6 (_7) - 46 store_var 7 (h) - - 76 47 load_var 7 (h) - 48 return -} - -function ai.clients.Backoff.new(initial_ms: int, multiplier: int, max_ms: int) -> ai.clients.Backoff { - 0 load_var 1 (initial_ms) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 64 4 load_const 1 (250) - 5 store_var 1 (initial_ms) - 6 load_var 2 (multiplier) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - 10 load_const 2 (2) - 11 store_var 2 (multiplier) - 12 load_var 3 (max_ms) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - 16 load_const 3 (10000) - 17 store_var 3 (max_ms) - - 65 18 load_var2 1 2 - 19 load_var 3 (max_ms) - 20 init_instance 0 (ai.clients.Backoff .initial_ms, .multiplier, .max_ms) - 21 return -} - -function ai.clients.Fallback._try(self: ai.clients.Fallback, input: ai.ModelTurnInput, index: int) -> ai.ModelTurn { - 195 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_var 3 (index) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 4 (_7) - 6 load_var 4 (_7) - 7 narrow_bind 0 4 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 212 10 load_const 1 ("Fallback needs at least one member") - 11 init_instance 0 (baml.errors.InvalidArgument .message) - 12 throw - - 195 13 load_var 4 (_7) - 14 store_var 5 (c) - - 197 15 load_var2 5 2 - 16 load_type 0 - 17 load_const 2 ("invoke") - 18 virtual_call nargs=2 ntypeargs=0 - 19 jump +43 (to 62) - 20 load_var 6 (e) - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 narrow_bind 3 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +5 (to 30) - 26 load_var 6 (e) - 27 throw_if_panic - - 208 28 load_var 6 (e) - 29 rethrow - - 197 30 load_var 7 (_10) - 31 store_var 8 (f) - - 200 32 load_var 3 (index) - 33 load_const 4 (1) - 34 add_int - 35 store_var 9 (_14) - 36 load_var 1 (self) - 37 load_field 0 (members) - 38 container_len - 39 store_var 10 (_15) - 40 load_var2 9 10 - 41 cmp_int_op < - 42 jump_if_false +11 (to 53) - 43 pop 1 - - 201 44 load_var 8 (f) - 45 load_type 3 - 46 load_const 5 ("retry_safety") - 47 virtual_call nargs=1 ntypeargs=0 - 48 store_var 11 (_17) - 49 load_var 11 (_17) - 50 load_const 6 (ai.errors.RetrySafety.Safe) - 51 alloc_variant 776 (ai.errors.RetrySafety) - 52 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 199 53 pop_jump_if_false +2 (to 55) - 54 jump +3 (to 57) - - 205 55 load_var 6 (e) - 56 rethrow - - 203 57 load_var2 1 2 - 58 load_var 3 (index) - 59 load_const 4 (1) - 60 add_int - 61 call 947 ntypeargs=0 (ai.clients.Fallback._try) - 62 return -} - -function ai.clients.Fallback.root.Client.id(self: ai.clients.Fallback) -> string { - 221 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_const 1 (0) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 3 (_5) - 6 load_var 3 (_5) - 7 narrow_bind 0 3 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 224 10 load_const 2 ("fallback") - 11 store_var 2 (_0) - - 221 12 jump +8 (to 20) - 13 load_var 3 (_5) - 14 store_var 4 (c) - - 222 15 load_var 4 (c) - 16 load_type 0 - 17 load_const 3 ("id") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 2 (_0) - 20 load_var 2 (_0) - 21 return -} - -function ai.clients.Fallback.root.Client.invoke(self: ai.clients.Fallback, input: ai.ModelTurnInput) -> ai.ModelTurn { - 229 0 load_var2 1 2 - 1 load_const 0 (0) - 2 call 947 ntypeargs=0 (ai.clients.Fallback._try) - 3 jump +6 (to 9) - 4 load_var 3 (e) - 5 throw_if_panic - - 230 6 load_var 3 (e) - 7 call 968 ntypeargs=0 (ai.errors.normalize) - 8 throw - 9 return -} - -function ai.clients.Retry._attempt(self: ai.clients.Retry, input: ai.ModelTurnInput, remaining: int) -> ai.ModelTurn { - 114 0 load_var 1 (self) - 1 load_field 0 (inner) - 2 load_var 2 (input) - 3 load_type 0 - 4 load_const 1 ("invoke") - 5 virtual_call nargs=2 ntypeargs=0 - 6 jump +58 (to 64) - 7 load_var 4 (e) - 8 store_var 5 (_6) - 9 load_var 5 (_6) - 10 narrow_bind 2 5 - 11 pop_jump_if_false +2 (to 13) - 12 jump +5 (to 17) - 13 load_var 4 (e) - 14 throw_if_panic - - 133 15 load_var 4 (e) - 16 rethrow - - 114 17 load_var 5 (_6) - 18 store_var 6 (f) - - 118 19 load_var 3 (remaining) - 20 load_const 3 (1) - 21 cmp_int_op > - 22 jump_if_false +11 (to 33) - 23 pop 1 - - 119 24 load_var 6 (f) - 25 load_type 2 - 26 load_const 4 ("retry_safety") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 7 (_11) - 29 load_var 7 (_11) - 30 load_const 5 (ai.errors.RetrySafety.Safe) - 31 alloc_variant 776 (ai.errors.RetrySafety) - 32 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 118 33 jump_if_false +5 (to 38) - 34 pop 1 - - 120 35 load_var2 6 1 - 36 load_field 2 (retry_if) - 37 call_indirect - - 117 38 pop_jump_if_false +2 (to 40) - 39 jump +3 (to 42) - - 130 40 load_var 4 (e) - 41 rethrow - - 122 42 load_var 1 (self) - 43 load_field 1 (max_attempts) - 44 load_var 3 (remaining) - 45 sub_int - 46 load_const 3 (1) - 47 add_int - 48 store_var 8 (attempt) - - 124 49 load_var 1 (self) - 50 load_field 3 (backoff) - 51 load_var2 8 6 - 52 call 939 ntypeargs=0 (ai.clients.Backoff.delay_ms) - 53 call 521 ntypeargs=0 (baml.time.Duration.from_milliseconds) - - 123 54 sys_op 275 (baml.sys.sleep) - 55 pop 1 - 56 jump +3 (to 59) - 57 load_var 9 (se) - 58 throw_if_panic - - 128 59 load_var2 1 2 - 60 load_var 3 (remaining) - 61 load_const 3 (1) - 62 sub_int - 63 call 941 ntypeargs=0 (ai.clients.Retry._attempt) - 64 return -} - -function ai.clients.Retry.new(inner: ai.Client, max_attempts: int, retry_if: ((ai.errors.Failure) -> bool throws never) | null, backoff: ai.clients.Backoff | null) -> ai.clients.Retry { - 0 load_var 2 (max_attempts) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 101 4 load_const 1 (3) - 5 store_var 2 (max_attempts) - 6 load_var 3 (retry_if) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 102 10 load_const 2 (null) - 11 store_var 3 (retry_if) - 12 load_var 4 (backoff) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 103 16 load_const 2 (null) - 17 store_var 4 (backoff) - - 108 18 load_var 3 (retry_if) - 19 store_var_load_var 6 (_9) - 20 load_const 2 (null) - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - 23 load_const 3 (ai.clients.default_retry_judgment) - 24 store_var 6 (_9) - 25 load_var 6 (_9) - 26 store_var 5 (_8) - - 109 27 load_var 4 (backoff) - 28 store_var_load_var 7 (_12) - 29 load_const 2 (null) - 30 cmp_op == - 31 pop_jump_if_false +6 (to 37) - 32 load_const 0 () - 33 load_const 0 () - 34 load_const 0 () - 35 call 938 ntypeargs=0 (ai.clients.Backoff.new) - 36 store_var 7 (_12) - - 105 37 load_var2 1 2 - 38 load_var2 5 7 - - 109 39 init_instance 0 (ai.clients.Retry .inner, .max_attempts, .retry_if, .backoff) - 40 return -} - -function ai.clients.Retry.root.Client.id(self: ai.clients.Retry) -> string { - 139 0 load_var 1 (self) - 1 load_field 0 (inner) - 2 load_type 0 - 3 load_const 1 ("id") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function ai.clients.Retry.root.Client.invoke(self: ai.clients.Retry, input: ai.ModelTurnInput) -> ai.ModelTurn { - 143 0 load_var2 1 2 - 1 load_var 1 (self) - 2 load_field 1 (max_attempts) - 3 call 941 ntypeargs=0 (ai.clients.Retry._attempt) - 4 jump +6 (to 10) - 5 load_var 3 (e) - 6 throw_if_panic - - 144 7 load_var 3 (e) - 8 call 968 ntypeargs=0 (ai.errors.normalize) - 9 throw - 10 return -} - -function ai.clients.RoundRobin.new(members: ai.Client[]) -> ai.clients.RoundRobin { - 159 0 load_var 1 (members) - 1 container_len - 2 store_var 3 (_3) - 3 load_var 3 (_3) - 4 load_const 0 (0) - 5 cmp_int_op == - 6 pop_jump_if_false +2 (to 8) - 7 jump +7 (to 14) - - 162 8 load_var 1 (members) - 9 load_const 0 (0) - 10 init_instance 0 (ai.clients.RoundRobin .members, .counter) - 11 store_var 2 (_0) - 12 load_var 2 (_0) - 13 return - - 160 14 load_const 1 ("RoundRobin needs at least one member") - 15 init_instance 1 (baml.errors.InvalidArgument .message) - 16 throw -} - -function ai.clients.RoundRobin.root.Client.id(self: ai.clients.RoundRobin) -> string { - 167 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (members) - 3 load_const 1 (0) - 4 call 3 ntypeargs=1 (baml.Array.at) - 5 store_var 3 (_5) - 6 load_var 3 (_5) - 7 narrow_bind 0 3 - 8 pop_jump_if_false +2 (to 10) - 9 jump +4 (to 13) - - 170 10 load_const 2 ("round-robin") - 11 store_var 2 (_0) - - 167 12 jump +8 (to 20) - 13 load_var 3 (_5) - 14 store_var 4 (c) - - 168 15 load_var 4 (c) - 16 load_type 0 - 17 load_const 3 ("id") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 2 (_0) - 20 load_var 2 (_0) - 21 return -} - -function ai.clients.RoundRobin.root.Client.invoke(self: ai.clients.RoundRobin, input: ai.ModelTurnInput) -> ai.ModelTurn { - 176 0 load_var 1 (self) - 1 load_field 1 (counter) - 2 store_var 6 (_5) - 3 load_var 1 (self) - 4 load_field 0 (members) - 5 container_len - 6 store_var 7 (_6) - 7 load_var2 6 7 - 8 mod_int - 9 store_var 5 (index) - - 177 10 load_var2 1 1 - 11 load_field 1 (counter) - 12 load_const 0 (1) - 13 bin_op + - 14 store_field 1 (counter) - - 178 15 load_type 1 - 16 load_var 1 (self) - 17 load_field 0 (members) - 18 load_var 5 (index) - 19 call 3 ntypeargs=1 (baml.Array.at) - 20 store_var 8 (_13) - 21 load_var 8 (_13) - 22 narrow_bind 1 8 - 23 pop_jump_if_false +2 (to 25) - 24 jump +4 (to 28) - - 181 25 load_const 2 ("RoundRobin needs at least one member") - 26 init_instance 0 (baml.errors.InvalidArgument .message) - 27 throw - - 178 28 load_var 8 (_13) - 29 store_var 9 (c) - - 179 30 load_var2 9 2 - 31 load_type 1 - 32 load_const 3 ("invoke") - 33 virtual_call nargs=2 ntypeargs=0 - 34 store_var 3 (_0) - 35 jump +6 (to 41) - - 175 36 load_var 4 (e) - 37 throw_if_panic - - 185 38 load_var 4 (e) - 39 call 968 ntypeargs=0 (ai.errors.normalize) - 40 throw - 41 load_var 3 (_0) - 42 return -} - -function ai.clients.default_retry_judgment(f: ai.errors.Failure) -> bool { - 51 0 load_var 1 (f) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +19 (to 24) - 6 load_var 1 (f) - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 narrow_bind 1 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +11 (to 22) - 12 load_var 1 (f) - 13 store_var 4 (_4) - 14 load_var 4 (_4) - 15 narrow_bind 2 4 - 16 pop_jump_if_false +2 (to 18) - 17 jump +3 (to 20) - - 55 18 load_const 3 (true) - - 51 19 jump +6 (to 25) - - 54 20 load_const 4 (false) - - 51 21 jump +4 (to 25) - - 53 22 load_const 4 (false) - - 51 23 jump +2 (to 25) - - 52 24 load_const 4 (false) - 25 return -} - -function ai.clients.resolve(selector: ai.Client | string | baml.env.Ref) -> ai.Client { - 30 0 load_var 1 (selector) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +58 (to 63) - 6 load_var 1 (selector) - 7 store_var 4 (_5) - 8 load_var 4 (_5) - 9 narrow_bind 1 4 - 10 pop_jump_if_false +2 (to 12) - 11 jump +5 (to 16) - 12 load_var 1 (selector) - 13 store_var 12 (existing) - - 44 14 load_var 12 (existing) - - 30 15 jump +51 (to 66) - 16 load_var 4 (_5) - 17 store_var 5 (named) - - 33 18 load_var 5 (named) - 19 call 228 ntypeargs=0 (baml.env.Ref.get) - 20 store_var 6 (_8) - 21 load_var 6 (_8) - 22 narrow_bind 0 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +35 (to 59) - - 39 25 load_type 2 - 26 load_var 5 (named) - 27 load_field 0 (name) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 8 (_18) - 30 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 31 store_var 10 (_22) - 32 load_type 2 - 33 load_var 10 (_22) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 9 (_21) - 36 load_type 2 - 37 load_var 5 (named) - 38 load_field 0 (name) - 39 call 138 ntypeargs=1 (baml.String.from) - 40 store_var 11 (_24) - - 36 41 load_const 3 ("ai.clients") - 42 load_const 4 (null) - - 39 43 load_const 5 ("client selector env.") - 44 load_var 8 (_18) - 45 bin_op + - 46 load_const 6 (" is not set: point it at a \"provider/model\" string (valid prefixes are ") - 47 bin_op + - 48 load_var 9 (_21) - 49 bin_op + - 50 load_const 7 ("), or give the client: position a value with a fallback — env.") - 51 bin_op + - 52 load_var 11 (_24) - 53 bin_op + - 54 load_const 8 (".get() ?? \"openai/gpt-4o-mini\"") - 55 bin_op + - 56 load_const 4 (null) - 57 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 58 throw - - 33 59 load_var 6 (_8) - 60 store_var_load_var 7 (value) - - 34 61 call 1002 ntypeargs=0 (ai.internal._from_shorthand) - 62 jump +4 (to 66) - - 30 63 load_var 2 (_2) - 64 store_var_load_var 3 (shorthand) - - 31 65 call 1002 ntypeargs=0 (ai.internal._from_shorthand) - 66 return -} - -function ai.content.Media.kind(self: ai.content.Media) -> string { - 37 0 load_var 1 (self) - 1 load_field 0 (media) - 2 store_var 2 (_2) - 3 load_var 2 (_2) - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +19 (to 27) - 9 load_var 2 (_2) - 10 store_var 4 (_4) - 11 load_var 4 (_4) - 12 narrow_bind 1 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +11 (to 25) - 15 load_var 2 (_2) - 16 store_var 5 (_5) - 17 load_var 5 (_5) - 18 narrow_bind 2 5 - 19 pop_jump_if_false +2 (to 21) - 20 jump +3 (to 23) - - 41 21 load_const 3 ("pdf") - - 37 22 jump +6 (to 28) - - 40 23 load_const 4 ("video") - - 37 24 jump +4 (to 28) - - 39 25 load_const 5 ("audio") - - 37 26 jump +2 (to 28) - - 38 27 load_const 6 ("image") - 28 return -} - -function ai.content.Media.new(value: image | audio | video | pdf, provider_id: string | null, revised_prompt: string | null) -> ai.content.Media { - 0 load_var 2 (provider_id) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 54 4 load_const 1 (null) - 5 store_var 2 (provider_id) - 6 load_var 3 (revised_prompt) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 55 10 load_const 1 (null) - 11 store_var 3 (revised_prompt) - - 57 12 load_type 2 - 13 load_var 1 (value) - 14 call 355 ntypeargs=1 (baml.json.to_json) - 15 store_var 4 (envelope) - 16 jump +16 (to 32) - 17 load_var 5 (e) - 18 throw_if_panic - - 59 19 load_type 3 - 20 load_var 5 (e) - 21 call 138 ntypeargs=1 (baml.String.from) - 22 store_var 7 (_12) - 23 load_type 4 - 24 load_var 7 (_12) - 25 call 138 ntypeargs=1 (baml.String.from) - 26 store_var 6 (_11) - 27 load_const 5 ("media output could not be encoded: ") - 28 load_var 6 (_11) - 29 bin_op + - 30 init_instance 0 (baml.errors.InvalidArgument .message) - 31 throw - - 62 32 load_type 6 - 33 load_var 4 (envelope) - 34 call 358 ntypeargs=1 (baml.json.from_json) - 35 store_var 8 (part) - 36 jump +16 (to 52) - 37 load_var 9 (e) - 38 throw_if_panic - - 64 39 load_type 7 - 40 load_var 9 (e) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 11 (_22) - 43 load_type 4 - 44 load_var 11 (_22) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 10 (_21) - 47 load_const 8 ("media output could not be decoded: ") - 48 load_var 10 (_21) - 49 bin_op + - 50 init_instance 1 (baml.errors.InvalidArgument .message) - 51 throw - - 67 52 load_var2 8 2 - 53 load_var 3 (revised_prompt) - 54 init_instance 2 (ai.content.Media .media, .provider_id, .revised_prompt) - 55 return -} - -function ai.errors.InvalidRequest.Failure.retry_safety(self: ai.errors.InvalidRequest) -> ai.errors.RetrySafety { - 54 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.NetworkFailure.Failure.retry_safety(self: ai.errors.NetworkFailure) -> ai.errors.RetrySafety { - 42 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.ParseFailed.Failure.retry_safety(self: ai.errors.ParseFailed) -> ai.errors.RetrySafety { - 75 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.RateLimited.Failure.retry_safety(self: ai.errors.RateLimited) -> ai.errors.RetrySafety { - 31 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.Refused.Failure.retry_safety(self: ai.errors.Refused) -> ai.errors.RetrySafety { - 65 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.StepBudgetExceeded.Failure.retry_safety(self: ai.errors.StepBudgetExceeded) -> ai.errors.RetrySafety { - 88 0 load_const 0 (ai.errors.RetrySafety.Unsafe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.StreamingUnsupported.Failure.retry_safety(self: ai.errors.StreamingUnsupported) -> ai.errors.RetrySafety { - 117 0 load_const 0 (ai.errors.RetrySafety.Safe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.ToolFailedError.Failure.retry_safety(self: ai.errors.ToolFailedError) -> ai.errors.RetrySafety { - 104 0 load_const 0 (ai.errors.RetrySafety.Unsafe) - 1 alloc_variant 776 (ai.errors.RetrySafety) - 2 store_var 2 (_0) - 3 load_var 2 (_0) - 4 return -} - -function ai.errors.classify_http(provider: string, status_code: int, body: string, headers: map | null) -> ai.errors.Failure { - 0 load_var 4 (headers) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 133 4 load_const 1 (null) - 5 store_var 4 (headers) - - 135 6 load_var 2 (status_code) - 7 load_const 2 (429) - 8 cmp_int_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +34 (to 44) - - 141 11 load_var 2 (status_code) - 12 load_const 3 (408) - 13 cmp_int_op == - 14 jump_if_false +2 (to 16) - 15 jump +5 (to 20) - 16 pop 1 - 17 load_var 2 (status_code) - 18 load_const 4 (500) - 19 cmp_int_op >= - 20 pop_jump_if_false +2 (to 22) - 21 jump +12 (to 33) - - 147 22 load_type 5 - 23 load_var 2 (status_code) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 store_var 7 (_14) - - 144 26 load_var2 1 2 - - 147 27 load_const 6 ("http ") - 28 load_var 7 (_14) - 29 bin_op + - 30 load_var 3 (body) - 31 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 141 32 jump +18 (to 50) - - 142 33 load_type 5 - 34 load_var 2 (status_code) - 35 call 138 ntypeargs=1 (baml.String.from) - 36 store_var 6 (_11) - 37 load_var 1 (provider) - 38 load_const 7 ("http ") - 39 load_var 6 (_11) - 40 bin_op + - 41 load_var 3 (body) - 42 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 141 43 jump +7 (to 50) - - 138 44 load_var 4 (headers) - 45 call 1005 ntypeargs=0 (ai.internal._retry_after_ms) - 46 store_var 5 (_7) - - 136 47 load_var2 1 5 - 48 load_var 3 (body) - 49 init_instance 2 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 50 return -} - -function ai.errors.normalize(error: unknown) -> ai.errors.Failure | baml.errors.UnknownError { - 18 0 load_var 1 (error) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +20 (to 25) - 6 load_var 1 (error) - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 narrow_bind 1 4 - 10 pop_jump_if_false +2 (to 12) - 11 jump +10 (to 21) - - 21 12 load_type 2 - 13 load_var 1 (error) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 6 (_7) - 16 load_var2 1 6 - 17 load_type 3 - 18 alloc_array 1 - 19 init_instance 0 (baml.errors.UnknownError .data, .message) - - 18 20 jump +8 (to 28) - 21 load_var 4 (_4) - 22 store_var 5 (unknown_error) - - 20 23 load_var 5 (unknown_error) - - 18 24 jump +4 (to 28) - 25 load_var 2 (_2) - 26 store_var 3 (failure) - - 19 27 load_var 3 (failure) - 28 return -} - -function ai.internal._aws_resolve_region(region: string | null, profile: string | null) -> string | null { -} - -function ai.internal._aws_sign_request(request: baml.http.Request, service: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null) -> baml.http.Request { -} - -function ai.internal._configured(value: string) -> string | null { - 7 0 load_var 1 (value) - 1 call 144 ntypeargs=0 (baml.String.trim) - 2 load_const 0 ("") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 10 6 load_var 1 (value) - - 7 7 jump +2 (to 9) - - 8 8 load_const 1 (null) - 9 return -} - -function ai.internal._flush_orphaned_calls(out: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[], pending: string[]) -> void { - 127 0 load_var 2 (pending) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 4 (_3) - 5 load_var 4 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 5 (_4) - 10 load_var 5 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +10 (to 23) - 14 load_var 5 (_4) - 15 store_var 6 (id) - - 128 16 load_type 5 - 17 load_var2 1 6 - 18 load_const 6 ("No result provided") - 19 init_instance 0 (ai.events.ToolFailed .id, .message) - 20 call 4 ntypeargs=1 (baml.Array.push) - 21 pop 1 - 22 jump -17 (to 5) - - 130 23 load_type 7 - 24 load_var 2 (pending) - 25 call 28 ntypeargs=1 (baml.Array.clear) - 26 pop 1 - - 126 27 load_const 8 (null) - 28 store_var 3 (_0) - 29 load_var 3 (_0) - 30 return -} - -function ai.internal._from_shorthand(shorthand: string) -> ai.Client { - 34 0 load_var 1 (shorthand) - 1 load_const 0 ("/") - 2 call 155 ntypeargs=0 (baml.String.index_of) - - 35 3 store_var 2 (_3) - 4 load_var 2 (_3) - 5 narrow_bind 1 2 - 6 pop_jump_if_false +2 (to 8) - 7 jump +23 (to 30) - - 67 8 load_type 2 - 9 load_var 1 (shorthand) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 15 (_62) - 12 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 13 store_var 17 (_65) - 14 load_type 2 - 15 load_var 17 (_65) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 16 (_64) - - 64 18 load_const 3 ("ai.clients") - 19 load_const 4 (null) - - 67 20 load_const 5 ("client \"") - 21 load_var 15 (_62) - 22 bin_op + - 23 load_const 6 ("\" is not a \"provider/model\" string (no \"/\"); valid prefixes are ") - 24 bin_op + - 25 load_var 16 (_64) - 26 bin_op + - 27 load_const 4 (null) - 28 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 29 throw - - 35 30 load_var 2 (_3) - 31 store_var 3 (index) - - 36 32 load_var 1 (shorthand) - 33 load_const 1 (0) - 34 load_var 3 (index) - 35 call 153 ntypeargs=0 (baml.String.slice) - 36 store_var 4 (prefix) - - 37 37 load_var 3 (index) - 38 load_const 7 (1) - 39 add_int - 40 store_var 6 (_8) - 41 load_var 1 (shorthand) - 42 call 139 ntypeargs=0 (baml.String.length) - 43 store_var 7 (_10) - 44 load_var2 1 6 - 45 load_var 7 (_10) - 46 call 153 ntypeargs=0 (baml.String.slice) - 47 store_var 5 (model) - - 38 48 load_var 4 (prefix) - 49 load_const 8 ("openai") - 50 cmp_op == - 51 pop_jump_if_false +2 (to 53) - 52 jump +223 (to 275) - 53 load_var 4 (prefix) - 54 load_const 9 ("openai-chat") - 55 cmp_op == - 56 pop_jump_if_false +2 (to 58) - 57 jump +204 (to 261) - 58 load_var 4 (prefix) - 59 load_const 10 ("openai-images") - 60 cmp_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +181 (to 243) - 63 load_var 4 (prefix) - 64 load_const 11 ("azure") - 65 cmp_op == - 66 pop_jump_if_false +2 (to 68) - 67 jump +159 (to 226) - 68 load_var 4 (prefix) - 69 load_const 12 ("ollama") - 70 cmp_op == - 71 pop_jump_if_false +2 (to 73) - 72 jump +141 (to 213) - 73 load_var 4 (prefix) - 74 load_const 13 ("openrouter") - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +123 (to 200) - 78 load_var 4 (prefix) - 79 load_const 14 ("anthropic") - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +103 (to 185) - 83 load_var 4 (prefix) - 84 load_const 15 ("google") - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +83 (to 170) - 88 load_var 4 (prefix) - 89 load_const 16 ("vertex") - 90 cmp_op == - 91 pop_jump_if_false +2 (to 93) - 92 jump +59 (to 151) - 93 load_var 4 (prefix) - 94 load_const 17 ("bedrock") - 95 cmp_op == - 96 pop_jump_if_false +2 (to 98) - 97 jump +34 (to 131) - 98 load_var 4 (prefix) - 99 load_const 18 ("ai-gateway-images") - 100 cmp_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +17 (to 119) - 103 load_var 4 (prefix) - 104 load_const 19 ("claude-code") - 105 cmp_op == - 106 pop_jump_if_false +2 (to 108) - 107 jump +3 (to 110) - - 51 108 load_const 4 (null) - - 38 109 jump +181 (to 290) - - 50 110 load_var 5 (model) - 111 load_const 20 () - 112 load_const 20 () - 113 load_const 20 () - 114 load_const 20 () - 115 load_const 20 () - 116 load_const 20 () - 117 call 1351 ntypeargs=0 (claude_code.ClaudeCodeClient.new) - 118 jump +172 (to 290) - - 49 119 load_var 5 (model) - 120 load_const 20 () - 121 load_const 20 () - 122 load_const 20 () - 123 load_const 20 () - 124 load_const 20 () - 125 load_const 20 () - 126 load_const 20 () - 127 load_const 20 () - 128 load_const 20 () - 129 call 1330 ntypeargs=0 (vercel.AiGatewayImageClient.new) - 130 jump +160 (to 290) - - 48 131 load_var 5 (model) - 132 load_const 20 () - 133 load_const 20 () - 134 load_const 20 () - 135 load_const 20 () - 136 load_const 20 () - 137 load_const 20 () - 138 load_const 20 () - 139 load_const 20 () - 140 load_const 20 () - 141 load_const 20 () - 142 load_const 20 () - 143 load_const 20 () - 144 load_const 20 () - 145 load_const 20 () - 146 load_const 20 () - 147 load_const 20 () - 148 load_const 20 () - 149 call 1271 ntypeargs=0 (aws.BedrockClient.new) - 150 jump +140 (to 290) - - 47 151 load_var 5 (model) - 152 load_const 20 () - 153 load_const 20 () - 154 load_const 20 () - 155 load_const 20 () - 156 load_const 20 () - 157 load_const 20 () - 158 load_const 20 () - 159 load_const 20 () - 160 load_const 20 () - 161 load_const 20 () - 162 load_const 20 () - 163 load_const 20 () - 164 load_const 20 () - 165 load_const 20 () - 166 load_const 20 () - 167 load_const 20 () - 168 call 1207 ntypeargs=0 (google.VertexClient.new) - 169 jump +121 (to 290) - - 46 170 load_var 5 (model) - 171 load_const 20 () - 172 load_const 20 () - 173 load_const 20 () - 174 load_const 20 () - 175 load_const 20 () - 176 load_const 20 () - 177 load_const 20 () - 178 load_const 20 () - 179 load_const 20 () - 180 load_const 20 () - 181 load_const 20 () - 182 load_const 20 () - 183 call 1201 ntypeargs=0 (google.GoogleClient.new) - 184 jump +106 (to 290) - - 45 185 load_var 5 (model) - 186 load_const 20 () - 187 load_const 20 () - 188 load_const 20 () - 189 load_const 20 () - 190 load_const 20 () - 191 load_const 20 () - 192 load_const 20 () - 193 load_const 20 () - 194 load_const 20 () - 195 load_const 20 () - 196 load_const 20 () - 197 load_const 20 () - 198 call 1162 ntypeargs=0 (anthropic.AnthropicClient.new) - 199 jump +91 (to 290) - - 44 200 load_var 5 (model) - 201 load_const 20 () - 202 load_const 20 () - 203 load_const 20 () - 204 load_const 20 () - 205 load_const 20 () - 206 load_const 20 () - 207 load_const 20 () - 208 load_const 20 () - 209 load_const 20 () - 210 load_const 20 () - 211 call 1084 ntypeargs=0 (openai.OpenRouterClient.new) - 212 jump +78 (to 290) - - 43 213 load_var 5 (model) - 214 load_const 20 () - 215 load_const 20 () - 216 load_const 20 () - 217 load_const 20 () - 218 load_const 20 () - 219 load_const 20 () - 220 load_const 20 () - 221 load_const 20 () - 222 load_const 20 () - 223 load_const 20 () - 224 call 1076 ntypeargs=0 (openai.OllamaClient.new) - 225 jump +65 (to 290) - - 42 226 load_var 5 (model) - 227 load_const 20 () - 228 load_const 20 () - 229 load_const 20 () - 230 load_const 20 () - 231 load_const 20 () - 232 load_const 20 () - 233 load_const 20 () - 234 load_const 20 () - 235 load_const 20 () - 236 load_const 20 () - 237 load_const 20 () - 238 load_const 20 () - 239 load_const 20 () - 240 load_const 20 () - 241 call 1067 ntypeargs=0 (openai.AzureClient.new) - 242 jump +48 (to 290) - - 41 243 load_var 5 (model) - 244 load_const 20 () - 245 load_const 20 () - 246 load_const 20 () - 247 load_const 20 () - 248 load_const 20 () - 249 load_const 20 () - 250 load_const 20 () - 251 load_const 20 () - 252 load_const 20 () - 253 load_const 20 () - 254 load_const 20 () - 255 load_const 20 () - 256 load_const 20 () - 257 load_const 20 () - 258 load_const 20 () - 259 call 1092 ntypeargs=0 (openai.ImageClient.new) - 260 jump +30 (to 290) - - 40 261 load_var 5 (model) - 262 load_const 20 () - 263 load_const 20 () - 264 load_const 20 () - 265 load_const 20 () - 266 load_const 20 () - 267 load_const 20 () - 268 load_const 20 () - 269 load_const 20 () - 270 load_const 20 () - 271 load_const 20 () - 272 load_const 20 () - 273 call 1051 ntypeargs=0 (openai.ChatClient.new) - 274 jump +16 (to 290) - - 39 275 load_var 5 (model) - 276 load_const 20 () - 277 load_const 20 () - 278 load_const 20 () - 279 load_const 20 () - 280 load_const 20 () - 281 load_const 20 () - 282 load_const 20 () - 283 load_const 20 () - 284 load_const 20 () - 285 load_const 20 () - 286 load_const 20 () - 287 load_const 20 () - 288 load_const 20 () - 289 call 1011 ntypeargs=0 (openai.ResponsesClient.new) - - 53 290 store_var 8 (_36) - 291 load_var 8 (_36) - 292 narrow_bind 21 8 - 293 pop_jump_if_false +2 (to 295) - 294 jump +41 (to 335) - - 59 295 load_type 2 - 296 load_var 4 (prefix) - 297 call 138 ntypeargs=1 (baml.String.from) - 298 store_var 10 (_47) - 299 load_type 2 - 300 load_var 1 (shorthand) - 301 call 138 ntypeargs=1 (baml.String.from) - 302 store_var 11 (_50) - 303 call 1001 ntypeargs=0 (ai.internal._shorthand_prefixes) - 304 store_var 13 (_53) - 305 load_type 2 - 306 load_var 13 (_53) - 307 call 138 ntypeargs=1 (baml.String.from) - 308 store_var 12 (_52) - 309 load_type 2 - 310 load_var 5 (model) - 311 call 138 ntypeargs=1 (baml.String.from) - 312 store_var 14 (_55) - - 56 313 load_const 22 ("ai.clients") - 314 load_const 4 (null) - - 59 315 load_const 23 ("no builtin provider for prefix \"") - 316 load_var 10 (_47) - 317 bin_op + - 318 load_const 24 ("\" in client \"") - 319 bin_op + - 320 load_var 11 (_50) - 321 bin_op + - 322 load_const 25 ("\"; valid prefixes are ") - 323 bin_op + - 324 load_var 12 (_52) - 325 bin_op + - 326 load_const 26 (" (for any other OpenAI-compatible endpoint, build openai.GenericClient.new(base_url = ..., model = \"") - 327 bin_op + - 328 load_var 14 (_55) - 329 bin_op + - 330 load_const 27 ("\"))") - 331 bin_op + - 332 load_const 4 (null) - 333 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 334 throw - - 53 335 load_var 8 (_36) - 336 store_var 9 (built) - - 54 337 load_var 9 (built) - 338 return -} - -function ai.internal._gcp_access_token(credentials_json: string | null, scope: string) -> string { -} - -function ai.internal._gcp_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._gcp_quota_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._header(headers: map, lower: string, canonical: string) -> string | null { - 8 0 load_type 0 - 1 load_type 0 - 2 load_var2 1 2 - 3 call 38 ntypeargs=2 (baml.Map.get) - 4 store_var_load_var 4 (_4) - 5 load_const 1 (null) - 6 cmp_op == - 7 pop_jump_if_false +6 (to 13) - 8 load_type 0 - 9 load_type 0 - 10 load_var2 1 3 - 11 call 38 ntypeargs=2 (baml.Map.get) - 12 store_var 4 (_4) - 13 load_var 4 (_4) - 14 return -} - -function ai.internal._int_header(headers: map, lower: string, canonical: string) -> int | null { - 14 0 load_var2 1 2 - 1 load_var 3 (canonical) - 2 call 1003 ntypeargs=0 (ai.internal._header) - 3 store_var 4 (_5) - 4 load_var 4 (_5) - 5 narrow_bind 0 4 - 6 pop_jump_if_false +27 (to 33) - 7 load_var 4 (_5) - 8 store_var 5 (raw) - - 15 9 load_var 5 (raw) - 10 call 144 ntypeargs=0 (baml.String.trim) - 11 call 81 ntypeargs=0 (baml.Int.parse) - 12 store_var 6 (parsed) - 13 jump +9 (to 22) - 14 load_var 7 (e) - 15 is_type 1 - 16 pop_jump_if_false +2 (to 18) - 17 jump +3 (to 20) - 18 load_var 7 (e) - 19 rethrow - - 16 20 load_const 2 (null) - 21 store_var 6 (parsed) - - 18 22 load_var 6 (parsed) - 23 store_var 8 (_11) - 24 load_var 8 (_11) - 25 narrow_bind 3 8 - 26 pop_jump_if_false +7 (to 33) - 27 load_var 8 (_11) - 28 store_var_load_var 9 (value) - - 19 29 load_const 3 (0) - 30 cmp_int_op >= - 31 pop_jump_if_false +2 (to 33) - 32 jump +3 (to 35) - - 24 33 load_const 2 (null) - 34 jump +2 (to 36) - - 20 35 load_var 9 (value) - 36 return -} - -function ai.internal._media_all_text(items: baml.json.json[]) -> bool { - 103 0 load_var 1 (items) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 2 (_2) - 5 load_var 2 (_2) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 3 (_3) - 10 load_var 3 (_3) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +13 (to 26) - 14 load_var 3 (_3) - 15 store_var_load_var 4 (i) - - 104 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +3 (to 21) - 19 load_const 6 (false) - 20 jump +2 (to 22) - 21 load_const 7 (true) - 22 unary_op ! - 23 pop_jump_if_false -18 (to 5) - - 105 24 load_const 6 (false) - 25 jump +2 (to 27) - - 108 26 load_const 7 (true) - 27 return -} - -function ai.internal._media_envelope(m: ai.content.Media) -> baml.json.json { - 57 0 load_type 0 - 1 load_var 1 (m) - 2 load_field 0 (media) - 3 call 355 ntypeargs=1 (baml.json.to_json) - 4 jump +12 (to 16) - 5 load_var 2 (e) - 6 throw_if_panic - - 59 7 load_type 1 - 8 load_var 2 (e) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 store_var 3 (_8) - 11 load_var2 2 3 - 12 load_type 2 - 13 alloc_array 1 - 14 init_instance 0 (baml.errors.UnknownError .data, .message) - 15 throw - 16 return -} - -function ai.internal._media_join_text(items: baml.json.json[]) -> baml.json.json { - 112 0 load_const 0 ("") - 1 store_var 2 (out) - - 113 2 load_var 1 (items) - 3 load_type 1 - 4 load_const 2 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_3) - 7 load_var 3 (_3) - 8 load_type 3 - 9 load_const 4 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_4) - 12 load_var 4 (_4) - 13 is_type 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +14 (to 29) - 16 load_var 4 (_4) - 17 store_var 5 (i) - - 114 18 load_var 5 (i) - 19 store_var 6 (_8) - 20 load_var 6 (_8) - 21 narrow_bind 6 6 - 22 pop_jump_if_false -15 (to 7) - 23 load_var 6 (_8) - 24 store_var 7 (s) - - 115 25 load_var2 2 7 - 26 bin_op + - 27 store_var 2 (out) - - 114 28 jump -21 (to 7) - - 118 29 load_var 2 (out) - 30 return -} - -function ai.internal._media_mime_type(explicit: string | null, source_value: string, kind: string) -> string { - 6 0 load_var 1 (explicit) - 1 store_var 4 (_4) - 2 load_var 4 (_4) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +159 (to 164) - - 9 6 load_var 2 (source_value) - 7 call 142 ntypeargs=0 (baml.String.to_lower_case) - 8 store_var 6 (source) - - 10 9 load_var 6 (source) - 10 load_const 1 (".jpg") - 11 call 147 ntypeargs=0 (baml.String.includes) - 12 jump_if_false +2 (to 14) - 13 jump +5 (to 18) - 14 pop 1 - 15 load_var 6 (source) - 16 load_const 2 (".jpeg") - 17 call 147 ntypeargs=0 (baml.String.includes) - 18 pop_jump_if_false +2 (to 20) - 19 jump +143 (to 162) - - 12 20 load_var 6 (source) - 21 load_const 3 (".png") - 22 call 147 ntypeargs=0 (baml.String.includes) - 23 pop_jump_if_false +2 (to 25) - 24 jump +136 (to 160) - - 14 25 load_var 6 (source) - 26 load_const 4 (".webp") - 27 call 147 ntypeargs=0 (baml.String.includes) - 28 pop_jump_if_false +2 (to 30) - 29 jump +129 (to 158) - - 16 30 load_var 6 (source) - 31 load_const 5 (".gif") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 pop_jump_if_false +2 (to 35) - 34 jump +122 (to 156) - - 18 35 load_var 6 (source) - 36 load_const 6 (".svg") - 37 call 147 ntypeargs=0 (baml.String.includes) - 38 pop_jump_if_false +2 (to 40) - 39 jump +115 (to 154) - - 20 40 load_var 6 (source) - 41 load_const 7 (".wav") - 42 call 147 ntypeargs=0 (baml.String.includes) - 43 pop_jump_if_false +2 (to 45) - 44 jump +108 (to 152) - - 22 45 load_var 6 (source) - 46 load_const 8 (".mp3") - 47 call 147 ntypeargs=0 (baml.String.includes) - 48 pop_jump_if_false +2 (to 50) - 49 jump +101 (to 150) - - 24 50 load_var 6 (source) - 51 load_const 9 (".flac") - 52 call 147 ntypeargs=0 (baml.String.includes) - 53 pop_jump_if_false +2 (to 55) - 54 jump +94 (to 148) - - 26 55 load_var 6 (source) - 56 load_const 10 (".ogg") - 57 call 147 ntypeargs=0 (baml.String.includes) - 58 pop_jump_if_false +2 (to 60) - 59 jump +87 (to 146) - - 28 60 load_var 6 (source) - 61 load_const 11 (".webm") - 62 call 147 ntypeargs=0 (baml.String.includes) - 63 pop_jump_if_false +2 (to 65) - 64 jump +73 (to 137) - - 34 65 load_var 6 (source) - 66 load_const 12 (".mov") - 67 call 147 ntypeargs=0 (baml.String.includes) - 68 pop_jump_if_false +2 (to 70) - 69 jump +66 (to 135) - - 36 70 load_var 6 (source) - 71 load_const 13 (".mp4") - 72 call 147 ntypeargs=0 (baml.String.includes) - 73 pop_jump_if_false +2 (to 75) - 74 jump +52 (to 126) - - 44 75 load_var 6 (source) - 76 load_const 14 (".avi") - 77 call 147 ntypeargs=0 (baml.String.includes) - 78 pop_jump_if_false +2 (to 80) - 79 jump +45 (to 124) - - 46 80 load_var 6 (source) - 81 load_const 15 (".mkv") - 82 call 147 ntypeargs=0 (baml.String.includes) - 83 pop_jump_if_false +2 (to 85) - 84 jump +31 (to 115) - - 52 85 load_var 6 (source) - 86 load_const 16 (".pdf") - 87 call 147 ntypeargs=0 (baml.String.includes) - 88 pop_jump_if_false +2 (to 90) - 89 jump +24 (to 113) - - 54 90 load_var 3 (kind) - 91 load_const 17 ("audio") - 92 cmp_op == - 93 pop_jump_if_false +2 (to 95) - 94 jump +17 (to 111) - - 56 95 load_var 3 (kind) - 96 load_const 18 ("video") - 97 cmp_op == - 98 pop_jump_if_false +2 (to 100) - 99 jump +10 (to 109) - - 58 100 load_var 3 (kind) - 101 load_const 19 ("pdf") - 102 cmp_op == - 103 pop_jump_if_false +2 (to 105) - 104 jump +3 (to 107) - - 61 105 load_const 20 ("image/png") - - 58 106 jump +61 (to 167) - - 59 107 load_const 21 ("application/pdf") - - 58 108 jump +59 (to 167) - - 57 109 load_const 22 ("video/mp4") - - 56 110 jump +57 (to 167) - - 55 111 load_const 23 ("audio/mpeg") - - 54 112 jump +55 (to 167) - - 53 113 load_const 24 ("application/pdf") - - 52 114 jump +53 (to 167) - - 47 115 load_var 3 (kind) - 116 load_const 25 ("audio") - 117 cmp_op == - 118 pop_jump_if_false +2 (to 120) - 119 jump +3 (to 122) - - 50 120 load_const 26 ("video/x-matroska") - - 47 121 jump +46 (to 167) - - 48 122 load_const 27 ("audio/x-matroska") - - 47 123 jump +44 (to 167) - - 45 124 load_const 28 ("video/x-msvideo") - - 44 125 jump +42 (to 167) - - 39 126 load_var 3 (kind) - 127 load_const 29 ("audio") - 128 cmp_op == - 129 pop_jump_if_false +2 (to 131) - 130 jump +3 (to 133) - - 42 131 load_const 30 ("video/mp4") - - 39 132 jump +35 (to 167) - - 40 133 load_const 31 ("audio/mp4") - - 39 134 jump +33 (to 167) - - 35 135 load_const 32 ("video/quicktime") - - 34 136 jump +31 (to 167) - - 29 137 load_var 3 (kind) - 138 load_const 33 ("audio") - 139 cmp_op == - 140 pop_jump_if_false +2 (to 142) - 141 jump +3 (to 144) - - 32 142 load_const 34 ("video/webm") - - 29 143 jump +24 (to 167) - - 30 144 load_const 35 ("audio/webm") - - 29 145 jump +22 (to 167) - - 27 146 load_const 36 ("audio/ogg") - - 26 147 jump +20 (to 167) - - 25 148 load_const 37 ("audio/flac") - - 24 149 jump +18 (to 167) - - 23 150 load_const 38 ("audio/mpeg") - - 22 151 jump +16 (to 167) - - 21 152 load_const 39 ("audio/wav") - - 20 153 jump +14 (to 167) - - 19 154 load_const 40 ("image/svg+xml") - - 18 155 jump +12 (to 167) - - 17 156 load_const 41 ("image/gif") - - 16 157 jump +10 (to 167) - - 15 158 load_const 42 ("image/webp") - - 14 159 jump +8 (to 167) - - 13 160 load_const 43 ("image/png") - - 12 161 jump +6 (to 167) - - 11 162 load_const 44 ("image/jpeg") - - 10 163 jump +4 (to 167) - - 6 164 load_var 4 (_4) - 165 store_var 5 (supplied) - - 7 166 load_var 5 (supplied) - 167 return -} - -function ai.internal._media_mixed_parts(turn: ai.ModelTurn) -> baml.json.json[] { - 81 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (items) - - 82 3 load_var 1 (turn) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +42 (to 59) - 18 load_var 5 (_5) - 19 store_var 6 (b) - - 83 20 load_var 6 (b) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +21 (to 46) - 26 load_var 6 (b) - 27 store_var 9 (_17) - 28 load_var 9 (_17) - 29 narrow_bind 7 9 - 30 pop_jump_if_false -21 (to 9) - 31 load_var 9 (_17) - 32 store_var 10 (m) - - 91 33 load_var 10 (m) - 34 call 903 ntypeargs=0 (ai.content.Media.kind) - 35 load_const 8 ("image") - 36 cmp_op == - 37 pop_jump_if_false -28 (to 9) - - 92 38 load_var 10 (m) - 39 call 986 ntypeargs=0 (ai.internal._media_envelope) - 40 store_var 11 (_22) - 41 load_type 0 - 42 load_var2 3 11 - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -36 (to 9) - - 83 46 load_var 7 (_9) - 47 store_var_load_var 8 (t) - - 85 48 load_field 0 (text) - 49 call 144 ntypeargs=0 (baml.String.trim) - 50 load_const 9 ("") - 51 cmp_op != - 52 pop_jump_if_false -43 (to 9) - - 86 53 load_type 0 - 54 load_var2 3 8 - 55 load_field 0 (text) - 56 call 4 ntypeargs=1 (baml.Array.push) - 57 pop 1 - 58 jump -49 (to 9) - - 99 59 load_var 3 (items) - 60 store_var 2 (_0) - 61 load_var 2 (_0) - 62 return -} - -function ai.internal._media_of_kind(turn: ai.ModelTurn, kind: string) -> baml.json.json[] { - 66 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 67 3 load_var 1 (turn) - 4 load_field 0 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +23 (to 40) - 18 load_var 6 (_6) - 19 store_var 7 (b) - - 68 20 load_var 7 (b) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 8 (_10) - 26 store_var 9 (m) - - 69 27 load_var 9 (m) - 28 call 903 ntypeargs=0 (ai.content.Media.kind) - 29 load_var 2 (kind) - 30 cmp_op == - 31 pop_jump_if_false -22 (to 9) - - 70 32 load_var 9 (m) - 33 call 986 ntypeargs=0 (ai.internal._media_envelope) - 34 store_var 10 (_15) - 35 load_type 0 - 36 load_var2 4 10 - 37 call 4 ntypeargs=1 (baml.Array.push) - 38 pop 1 - 39 jump -30 (to 9) - - 74 40 load_var 4 (out) - 41 store_var 3 (_0) - 42 load_var 3 (_0) - 43 return -} - -function ai.internal._media_reject_mixed(turn: ai.ModelTurn, kind: string, provider: string) -> void { - 124 0 load_const 0 (0) - 1 store_var 5 (unexpected) - - 125 2 load_var 1 (turn) - 3 load_field 0 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 6 (_6) - 8 load_var 6 (_6) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 7 (_7) - 13 load_var 7 (_7) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +38 (to 54) - 17 load_var 7 (_7) - 18 store_var 8 (b) - - 126 19 load_var 8 (b) - 20 store_var 9 (_11) - 21 load_var 9 (_11) - 22 narrow_bind 6 9 - 23 pop_jump_if_false +2 (to 25) - 24 jump +18 (to 42) - 25 load_var 8 (b) - 26 store_var 11 (_16) - 27 load_var 11 (_16) - 28 narrow_bind 7 11 - 29 pop_jump_if_false -21 (to 8) - 30 load_var 11 (_16) - 31 store_var_load_var 12 (t) - - 134 32 load_field 0 (text) - 33 call 144 ntypeargs=0 (baml.String.trim) - 34 load_const 8 ("") - 35 cmp_op != - 36 pop_jump_if_false -28 (to 8) - - 135 37 load_var 5 (unexpected) - 38 load_const 9 (1) - 39 add_int - 40 store_var 5 (unexpected) - - 134 41 jump -33 (to 8) - - 126 42 load_var 9 (_11) - 43 store_var 10 (m) - - 128 44 load_var 10 (m) - 45 call 903 ntypeargs=0 (ai.content.Media.kind) - 46 load_var 2 (kind) - 47 cmp_op != - 48 pop_jump_if_false -40 (to 8) - - 129 49 load_var 5 (unexpected) - 50 load_const 9 (1) - 51 add_int - 52 store_var 5 (unexpected) - - 128 53 jump -45 (to 8) - - 142 54 load_var 5 (unexpected) - 55 load_const 0 (0) - 56 cmp_int_op > - 57 pop_jump_if_false +2 (to 59) - 58 jump +5 (to 63) - 59 load_const 10 (null) - 60 store_var 4 (_0) - 61 load_var 4 (_0) - 62 return - - 145 63 load_type 11 - 64 load_var 2 (kind) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 13 (_31) - 67 load_type 12 - 68 load_var 5 (unexpected) - 69 call 138 ntypeargs=1 (baml.String.from) - 70 store_var 14 (_33) - 71 load_type 11 - 72 load_var 2 (kind) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 15 (_36) - - 143 75 load_var 3 (provider) - - 145 76 load_const 13 ("Expected only ") - 77 load_var 13 (_31) - 78 bin_op + - 79 load_const 14 (" output parts, got ") - 80 bin_op + - 81 load_var 14 (_33) - 82 bin_op + - 83 load_const 15 (" non-") - 84 bin_op + - 85 load_var 15 (_36) - 86 bin_op + - 87 load_const 16 (" part(s). Use a text/image union return type to preserve mixed outputs.") - 88 bin_op + - 89 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 90 throw -} - -function ai.internal._media_shape(t: type) -> string { - 18 0 load_var 1 (t) - 1 load_type 0 - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 pop_jump_if_false +2 (to 5) - 4 jump +91 (to 95) - - 21 5 load_var 1 (t) - 6 load_type 1 - 7 call 672 ntypeargs=0 (baml.ops.equals_equals) - 8 pop_jump_if_false +2 (to 10) - 9 jump +84 (to 93) - - 24 10 load_var 1 (t) - 11 load_type 2 - 12 call 672 ntypeargs=0 (baml.ops.equals_equals) - 13 pop_jump_if_false +2 (to 15) - 14 jump +77 (to 91) - - 27 15 load_var 1 (t) - 16 load_type 3 - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 pop_jump_if_false +2 (to 20) - 19 jump +70 (to 89) - - 30 20 load_var 1 (t) - 21 load_type 4 - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - 23 pop_jump_if_false +2 (to 25) - 24 jump +63 (to 87) - - 33 25 load_var 1 (t) - 26 load_type 5 - 27 call 672 ntypeargs=0 (baml.ops.equals_equals) - 28 pop_jump_if_false +2 (to 30) - 29 jump +56 (to 85) - - 36 30 load_var 1 (t) - 31 load_type 6 - 32 call 672 ntypeargs=0 (baml.ops.equals_equals) - 33 pop_jump_if_false +2 (to 35) - 34 jump +49 (to 83) - - 39 35 load_var 1 (t) - 36 load_type 7 - 37 call 672 ntypeargs=0 (baml.ops.equals_equals) - 38 pop_jump_if_false +2 (to 40) - 39 jump +42 (to 81) - - 42 40 load_var 1 (t) - 41 load_type 8 - 42 call 672 ntypeargs=0 (baml.ops.equals_equals) - 43 jump_if_false +2 (to 45) - 44 jump +5 (to 49) - 45 pop 1 - 46 load_var 1 (t) - 47 load_type 9 - 48 call 672 ntypeargs=0 (baml.ops.equals_equals) - 49 pop_jump_if_false +2 (to 51) - 50 jump +29 (to 79) - - 45 51 load_var 1 (t) - 52 load_type 10 - 53 call 672 ntypeargs=0 (baml.ops.equals_equals) - 54 jump_if_false +2 (to 56) - 55 jump +5 (to 60) - 56 pop 1 - 57 load_var 1 (t) - 58 load_type 11 - 59 call 672 ntypeargs=0 (baml.ops.equals_equals) - 60 pop_jump_if_false +2 (to 62) - 61 jump +16 (to 77) - - 48 62 load_var 1 (t) - 63 load_type 12 - 64 call 672 ntypeargs=0 (baml.ops.equals_equals) - 65 jump_if_false +2 (to 67) - 66 jump +5 (to 71) - 67 pop 1 - 68 load_var 1 (t) - 69 load_type 13 - 70 call 672 ntypeargs=0 (baml.ops.equals_equals) - 71 pop_jump_if_false +2 (to 73) - 72 jump +3 (to 75) - - 51 73 load_const 14 ("") - 74 jump +22 (to 96) - - 49 75 load_const 15 ("mixed:image") - 76 jump +20 (to 96) - - 46 77 load_const 16 ("mixedlist:image") - 78 jump +18 (to 96) - - 43 79 load_const 17 ("list:image") - 80 jump +16 (to 96) - - 40 81 load_const 18 ("opt:pdf") - 82 jump +14 (to 96) - - 37 83 load_const 19 ("opt:video") - 84 jump +12 (to 96) - - 34 85 load_const 20 ("opt:audio") - 86 jump +10 (to 96) - - 31 87 load_const 21 ("opt:image") - 88 jump +8 (to 96) - - 28 89 load_const 22 ("one:pdf") - 90 jump +6 (to 96) - - 25 91 load_const 23 ("one:video") - 92 jump +4 (to 96) - - 22 93 load_const 24 ("one:audio") - 94 jump +2 (to 96) - - 19 95 load_const 25 ("one:image") - 96 return -} - -function ai.internal._merge_json(base: baml.json.json, patch: baml.json.json) -> baml.json.json { - 49 0 load_var 2 (patch) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 82 6 load_var 2 (patch) - - 49 7 jump +95 (to 102) - 8 load_var 3 (_3) - 9 store_var 4 (patch_object) - - 51 10 load_type 1 - 11 load_type 2 - 12 alloc_map 0 - 13 store_var 5 (out) - - 52 14 load_var 1 (base) - 15 store_var 6 (_6) - 16 load_var 6 (_6) - 17 narrow_bind 0 6 - 18 pop_jump_if_false +34 (to 52) - 19 load_var 6 (_6) - 20 store_var 7 (base_object) - - 56 21 load_type 1 - 22 load_type 2 - 23 load_var 7 (base_object) - 24 call 35 ntypeargs=2 (baml.Map.keys) - 25 load_type 3 - 26 load_const 4 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 8 (_11) - 29 load_var 8 (_11) - 30 load_type 5 - 31 load_const 6 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 9 (_12) - 34 load_var 9 (_12) - 35 is_type 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +15 (to 52) - 38 load_var 9 (_12) - 39 store_var 10 (key) - - 57 40 load_type 1 - 41 load_type 2 - 42 load_var2 7 10 - 43 call 38 ntypeargs=2 (baml.Map.get) - 44 store_var 11 (_18) - 45 load_type 1 - 46 load_type 2 - 47 load_var2 5 10 - 48 load_var 11 (_18) - 49 call 37 ntypeargs=2 (baml.Map.set) - 50 pop 1 - 51 jump -22 (to 29) - - 65 52 load_type 1 - 53 load_type 2 - 54 load_var 4 (patch_object) - 55 call 35 ntypeargs=2 (baml.Map.keys) - 56 load_type 3 - 57 load_const 8 ("iter") - 58 virtual_call nargs=1 ntypeargs=0 - 59 store_var 12 (_27) - 60 load_var 12 (_27) - 61 load_type 5 - 62 load_const 9 ("next") - 63 virtual_call nargs=1 ntypeargs=0 - 64 store_var 13 (_28) - 65 load_var 13 (_28) - 66 is_type 7 - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - 69 load_var 13 (_28) - 70 store_var 14 (key) - - 66 71 load_type 1 - 72 load_type 2 - 73 load_var2 4 14 - 74 call 38 ntypeargs=2 (baml.Map.get) - 75 store_var 15 (value) - - 67 76 load_var 15 (value) - 77 load_const 10 (null) - 78 cmp_op == - 79 pop_jump_if_false +2 (to 81) - 80 jump +15 (to 95) - - 75 81 load_type 1 - 82 load_type 2 - 83 load_var2 5 14 - 84 call 38 ntypeargs=2 (baml.Map.get) - 85 load_var 15 (value) - 86 call 997 ntypeargs=0 (ai.internal._merge_json) - 87 store_var 16 (_43) - 88 load_type 1 - 89 load_type 2 - 90 load_var2 5 14 - 91 load_var 16 (_43) - 92 call 37 ntypeargs=2 (baml.Map.set) - 93 pop 1 - 94 jump -34 (to 60) - - 69 95 load_type 1 - 96 load_type 2 - 97 load_var2 5 14 - 98 call 39 ntypeargs=2 (baml.Map.delete) - 99 pop 1 - 100 jump -40 (to 60) - - 80 101 load_var 5 (out) - 102 return -} - -function ai.internal._proxy(conn: ai.mcp.McpConnection, name: string) -> (map) -> string throws unknown { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 12 6 load_var2 1 2 - 7 make_closure 4341 2 - 8 store_var 3 (_0) - 9 load_var 3 (_0) - 10 return -} - -function ai.internal._redact_after(text: string, marker: string) -> string { - 17 0 load_const 0 ("") - 1 store_var 3 (out) - - 18 2 load_var 1 (text) - 3 store_var 4 (rest) - - 19 4 load_const 1 (true) - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - - 31 7 load_var 3 (out) - 8 jump +10 (to 18) - - 20 9 load_var2 4 2 - 10 call 155 ntypeargs=0 (baml.String.index_of) - - 21 11 store_var 5 (_6) - 12 load_var 5 (_6) - 13 narrow_bind 2 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +4 (to 19) - - 28 16 load_var2 3 4 - 17 bin_op + - 18 return - - 21 19 load_var 5 (_6) - 20 store_var 6 (start) - - 22 21 load_var 6 (start) - 22 store_var 8 (_9) - 23 load_var 2 (marker) - 24 call 139 ntypeargs=0 (baml.String.length) - 25 load_var 8 (_9) - 26 add_int - 27 store_var 7 (head) - - 23 28 load_var 4 (rest) - 29 load_const 2 (0) - 30 load_var 7 (head) - 31 call 153 ntypeargs=0 (baml.String.slice) - 32 store_var 9 (_11) - 33 load_var2 3 9 - 34 bin_op + - 35 store_var 3 (out) - - 24 36 load_var 3 (out) - 37 load_const 3 ("REDACTED") - 38 bin_op + - 39 store_var 3 (out) - - 25 40 load_var 4 (rest) - 41 call 139 ntypeargs=0 (baml.String.length) - 42 store_var 11 (_15) - 43 load_var2 4 7 - 44 load_var 11 (_15) - 45 call 153 ntypeargs=0 (baml.String.slice) - 46 store_var 10 (tail) - - 26 47 load_var 10 (tail) - 48 call 996 ntypeargs=0 (ai.internal._redact_value_end) - 49 store_var 12 (_16) - 50 load_var 10 (tail) - 51 call 139 ntypeargs=0 (baml.String.length) - 52 store_var 13 (_18) - 53 load_var2 10 12 - 54 load_var 13 (_18) - 55 call 153 ntypeargs=0 (baml.String.slice) - 56 store_var 4 (rest) - 57 jump -53 (to 4) -} - -function ai.internal._redact_value_end(tail: string) -> int { - 35 0 load_var 1 (tail) - 1 call 139 ntypeargs=0 (baml.String.length) - 2 store_var 2 (cut) - - 36 3 load_const 0 ("&") - 4 load_const 1 (" ") - 5 load_const 2 ("\"") - 6 load_const 3 ("'") - 7 load_const 4 (")") - 8 load_const 5 (",") - 9 load_const 6 ("\n") - 10 load_const 7 ("\t") - 11 load_type 8 - 12 alloc_array 8 - 13 load_type 9 - 14 load_const 10 ("iter") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 3 (_4) - 17 load_var 3 (_4) - 18 load_type 11 - 19 load_const 12 ("next") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 4 (_5) - 22 load_var 4 (_5) - 23 is_type 13 - 24 pop_jump_if_false +2 (to 26) - 25 jump +17 (to 42) - 26 load_var 4 (_5) - 27 store_var 5 (delimiter) - - 37 28 load_var2 1 5 - 29 call 155 ntypeargs=0 (baml.String.index_of) - 30 store_var 6 (_11) - 31 load_var 6 (_11) - 32 narrow_bind 14 6 - 33 pop_jump_if_false -16 (to 17) - 34 load_var 6 (_11) - 35 store_var_load_var 7 (at) - - 38 36 load_var 2 (cut) - 37 cmp_int_op < - 38 pop_jump_if_false -21 (to 17) - - 39 39 load_var 7 (at) - 40 store_var 2 (cut) - - 38 41 jump -24 (to 17) - - 43 42 load_var 2 (cut) - 43 return -} - -function ai.internal._resolve_media_content(url: string | null, file: string | null, inline: string, mime: string, fetch_url: bool) -> ai.wire.ResolvedMedia { - 72 0 load_var 2 (file) - 1 store_var 6 (_6) - 2 load_var 6 (_6) - 3 narrow_bind 0 6 - 4 pop_jump_if_false +2 (to 6) - 5 jump +221 (to 226) - - 95 6 load_var 3 (inline) - 7 load_const 1 ("") - 8 cmp_op != - 9 pop_jump_if_false +2 (to 11) - 10 jump +212 (to 222) - - 98 11 load_var 1 (url) - 12 store_var 18 (_40) - 13 load_var 18 (_40) - 14 narrow_bind 0 18 - 15 pop_jump_if_false +2 (to 17) - 16 jump +4 (to 20) - - 161 17 load_const 2 ("media has no URL, file, or base64 content") - 18 init_instance 0 (baml.errors.InvalidArgument .message) - 19 throw - - 98 20 load_var 18 (_40) - 21 store_var 19 (media_url) - - 99 22 load_var 19 (media_url) - 23 load_const 3 ("data:") - 24 call 148 ntypeargs=0 (baml.String.starts_with) - 25 pop_jump_if_false +2 (to 27) - 26 jump +138 (to 164) - - 122 27 load_var 5 (fetch_url) - 28 unary_op ! - 29 jump_if_false +2 (to 31) - 30 jump +5 (to 35) - 31 pop 1 - 32 load_var 19 (media_url) - 33 load_const 4 ("gs://") - 34 call 148 ntypeargs=0 (baml.String.starts_with) - 35 pop_jump_if_false +2 (to 37) - 36 jump +123 (to 159) - - 127 37 load_const 5 (30) - 38 call 522 ntypeargs=0 (baml.time.Duration.from_seconds) - 39 store_var 31 (_69) - 40 load_var2 19 31 - 41 call 248 ntypeargs=0 (baml.http.fetch) - 42 store_var 29 (response) - 43 jump +26 (to 69) - 44 load_var 30 (e) - 45 throw_if_panic - - 131 46 load_type 6 - 47 load_var 19 (media_url) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 32 (_74) - 50 load_type 7 - 51 load_var 30 (e) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 34 (_78) - 54 load_type 6 - 55 load_var 34 (_78) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 33 (_77) - - 129 58 load_const 8 ("media") - - 131 59 load_const 9 ("media URL ") - 60 load_var 32 (_74) - 61 bin_op + - 62 load_const 10 (" could not be fetched: ") - 63 bin_op + - 64 load_var 33 (_77) - 65 bin_op + - 66 load_const 11 (null) - 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 68 throw - - 136 69 load_var 29 (response) - 70 call 240 ntypeargs=0 (baml.http.Response.ok) - 71 unary_op ! - 72 pop_jump_if_false +2 (to 74) - 73 jump +66 (to 139) - - 143 74 load_type 6 - 75 load_type 6 - 76 load_var 29 (response) - 77 load_field 1 (headers) - 78 load_const 12 ("content-type") - 79 call 38 ntypeargs=2 (baml.Map.get) - 80 store_var_load_var 38 (_94) - 81 load_const 11 (null) - 82 cmp_op == - 83 pop_jump_if_false +3 (to 86) - 84 load_var 4 (mime) - 85 store_var 38 (_94) - 86 load_var 38 (_94) - 87 store_var 37 (response_mime) - - 144 88 load_var 29 (response) - 89 sys_op 239 (baml.http.Response.bytes) - 90 jump +26 (to 116) - 91 load_var 39 (e) - 92 throw_if_panic - - 148 93 load_type 6 - 94 load_var 19 (media_url) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 40 (_106) - 97 load_type 13 - 98 load_var 39 (e) - 99 call 138 ntypeargs=1 (baml.String.from) - 100 store_var 42 (_110) - 101 load_type 6 - 102 load_var 42 (_110) - 103 call 138 ntypeargs=1 (baml.String.from) - 104 store_var 41 (_109) - - 146 105 load_const 14 ("media") - - 148 106 load_const 15 ("media URL ") - 107 load_var 40 (_106) - 108 bin_op + - 109 load_const 16 (" body could not be read: ") - 110 bin_op + - 111 load_var 41 (_109) - 112 bin_op + - 113 load_const 11 (null) - 114 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 115 throw - - 155 116 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 117 store_var 43 (_113) - - 158 118 load_var 37 (response_mime) - 119 load_const 17 (";") - 120 call 150 ntypeargs=0 (baml.String.split) - 121 store_var 46 (_118) - 122 load_type 6 - 123 load_var 46 (_118) - 124 load_const 18 (0) - 125 call 3 ntypeargs=1 (baml.Array.at) - 126 store_var_load_var 45 (_116) - 127 load_const 11 (null) - 128 cmp_op == - 129 pop_jump_if_false +3 (to 132) - 130 load_var 4 (mime) - 131 store_var 45 (_116) - 132 load_var 45 (_116) - 133 call 144 ntypeargs=0 (baml.String.trim) - 134 store_var 44 (_114) - - 153 135 load_const 11 (null) - 136 load_var2 43 44 - 137 init_instance 3 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 138 jump +154 (to 292) - - 139 139 load_type 6 - 140 load_var 19 (media_url) - 141 call 138 ntypeargs=1 (baml.String.from) - 142 store_var 35 (_87) - 143 load_type 19 - 144 load_var 29 (response) - 145 load_field 0 (status_code) - 146 call 138 ntypeargs=1 (baml.String.from) - 147 store_var 36 (_90) - - 137 148 load_const 20 ("media") - - 139 149 load_const 21 ("media URL ") - 150 load_var 35 (_87) - 151 bin_op + - 152 load_const 22 (" returned HTTP ") - 153 bin_op + - 154 load_var 36 (_90) - 155 bin_op + - 156 load_const 11 (null) - 157 init_instance 4 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 158 throw - - 123 159 load_var 19 (media_url) - 160 load_const 11 (null) - 161 load_var 4 (mime) - 162 init_instance 5 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 163 jump +129 (to 292) - - 100 164 load_var 19 (media_url) - 165 load_const 23 (";base64,") - 166 call 155 ntypeargs=0 (baml.String.index_of) - 167 store_var 20 (_44) - 168 load_var 20 (_44) - 169 narrow_bind 18 20 - 170 pop_jump_if_false +2 (to 172) - 171 jump +30 (to 201) - - 113 172 load_var 19 (media_url) - 173 call 139 ntypeargs=0 (baml.String.length) - 174 load_const 24 (48) - 175 cmp_int_op > - 176 pop_jump_if_false +2 (to 178) - 177 jump +4 (to 181) - - 116 178 load_var 19 (media_url) - 179 store_var 26 (preview) - - 113 180 jump +12 (to 192) - - 114 181 load_var 19 (media_url) - 182 load_const 18 (0) - 183 load_const 24 (48) - 184 call 153 ntypeargs=0 (baml.String.slice) - 185 store_var 27 (_56) - 186 load_type 6 - 187 load_var 27 (_56) - 188 call 138 ntypeargs=1 (baml.String.from) - 189 load_const 25 ("...") - 190 bin_op + - 191 store_var 26 (preview) - - 119 192 load_type 6 - 193 load_var 26 (preview) - 194 call 138 ntypeargs=1 (baml.String.from) - 195 store_var 28 (_60) - 196 load_const 26 ("media carries a data: URL with no ;base64, marker, which has no payload to send: ") - 197 load_var 28 (_60) - 198 bin_op + - 199 init_instance 6 (baml.errors.InvalidArgument .message) - 200 throw - - 100 201 load_var 20 (_44) - 202 store_var_load_var 21 (separator) - - 103 203 load_const 27 (8) - 204 add_int - 205 store_var 23 (_47) - 206 load_var 19 (media_url) - 207 call 139 ntypeargs=0 (baml.String.length) - 208 store_var 24 (_49) - 209 load_var2 19 23 - 210 load_var 24 (_49) - 211 call 153 ntypeargs=0 (baml.String.slice) - 212 store_var 22 (_46) - - 104 213 load_var 19 (media_url) - 214 load_const 28 (5) - 215 load_var 21 (separator) - 216 call 153 ntypeargs=0 (baml.String.slice) - 217 store_var 25 (_50) - - 101 218 load_const 11 (null) - 219 load_var2 22 25 - 220 init_instance 7 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 221 jump +71 (to 292) - - 96 222 load_const 11 (null) - 223 load_var2 3 4 - 224 init_instance 8 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 225 jump +67 (to 292) - - 72 226 load_var 6 (_6) - 227 store_var_load_var 7 (path) - - 77 228 load_const 29 ("r") - 229 sys_op 289 (baml.fs.open) - 230 store_var 8 (handle) - 231 jump +24 (to 255) - 232 load_var 9 (e) - 233 throw_if_panic - - 80 234 load_type 6 - 235 load_var 7 (path) - 236 call 138 ntypeargs=1 (baml.String.from) - 237 store_var 10 (_15) - 238 load_type 30 - 239 load_var 9 (e) - 240 call 138 ntypeargs=1 (baml.String.from) - 241 store_var 12 (_19) - 242 load_type 6 - 243 load_var 12 (_19) - 244 call 138 ntypeargs=1 (baml.String.from) - 245 store_var 11 (_18) - 246 load_const 31 ("media file ") - 247 load_var 10 (_15) - 248 bin_op + - 249 load_const 32 (" could not be opened: ") - 250 bin_op + - 251 load_var 11 (_18) - 252 bin_op + - 253 init_instance 9 (baml.errors.InvalidArgument .message) - 254 throw - - 84 255 load_var 8 (handle) - 256 sys_op 282 (baml.fs.File.bytes) - 257 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 258 store_var 13 (data) - 259 jump +27 (to 286) - 260 load_var 14 (e) - 261 throw_if_panic - - 86 262 load_var 8 (handle) - 263 sys_op 285 (baml.fs.File.close) - 264 pop 1 - - 88 265 load_type 6 - 266 load_var 7 (path) - 267 call 138 ntypeargs=1 (baml.String.from) - 268 store_var 15 (_30) - 269 load_type 30 - 270 load_var 14 (e) - 271 call 138 ntypeargs=1 (baml.String.from) - 272 store_var 17 (_34) - 273 load_type 6 - 274 load_var 17 (_34) - 275 call 138 ntypeargs=1 (baml.String.from) - 276 store_var 16 (_33) - 277 load_const 33 ("media file ") - 278 load_var 15 (_30) - 279 bin_op + - 280 load_const 34 (" could not be read: ") - 281 bin_op + - 282 load_var 16 (_33) - 283 bin_op + - 284 init_instance 10 (baml.errors.InvalidArgument .message) - 285 throw - - 92 286 load_var 8 (handle) - 287 sys_op 285 (baml.fs.File.close) - 288 pop 1 - - 93 289 load_const 11 (null) - 290 load_var2 13 4 - 291 init_instance 11 (ai.wire.ResolvedMedia .url, .base64, .mime_type) - 292 return -} - -function ai.internal._resolve_pending_call(pending: string[], id: string) -> void { - 135 0 load_type 0 - 1 load_var2 1 2 - 2 call 24 ntypeargs=1 (baml.Array.index_of) - 3 store_var 3 (_5) - 4 load_var 3 (_5) - 5 narrow_bind 1 3 - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - 8 load_const 2 (null) - 9 jump +8 (to 17) - 10 load_var 3 (_5) - 11 store_var 4 (index) - - 136 12 load_type 0 - 13 load_var2 1 4 - 14 call 6 ntypeargs=1 (baml.Array.remove_at) - 15 pop 1 - - 135 16 load_const 2 (null) - 17 return -} - -function ai.internal._retry_after_ms(headers: map | null) -> int | null { - 33 0 load_var 1 (headers) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +20 (to 24) - 5 load_var 2 (_2) - 6 store_var_load_var 3 (h) - - 34 7 load_const 1 ("retry-after-ms") - 8 load_const 2 ("Retry-After-Ms") - 9 call 1004 ntypeargs=0 (ai.internal._int_header) - 10 store_var 4 (_6) - 11 load_var 4 (_6) - 12 narrow_bind 3 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +17 (to 31) - - 37 15 load_var 3 (h) - 16 load_const 4 ("retry-after") - 17 load_const 5 ("Retry-After") - 18 call 1004 ntypeargs=0 (ai.internal._int_header) - 19 store_var 6 (_10) - 20 load_var 6 (_10) - 21 narrow_bind 3 6 - 22 pop_jump_if_false +2 (to 24) - 23 jump +3 (to 26) - - 41 24 load_const 6 (null) - 25 jump +9 (to 34) - - 37 26 load_var 6 (_10) - 27 store_var_load_var 7 (seconds) - - 38 28 load_const 7 (1000) - 29 mul_int - 30 jump +4 (to 34) - - 34 31 load_var 4 (_6) - 32 store_var 5 (ms) - - 35 33 load_var 5 (ms) - 34 return -} - -function ai.internal._schema_for_signature(handler: baml.AnyFunction) -> map { - 6 0 load_var 1 (handler) - 1 call 774 ntypeargs=0 (baml.reflect.signature) - 2 store_var 3 (sig) - - 7 3 load_type 0 - 4 load_type 1 - 5 alloc_map 0 - 6 store_var 4 (props) - - 8 7 load_type 0 - 8 alloc_array 0 - 9 store_var 5 (required) - - 9 10 load_var 3 (sig) - 11 load_field 1 (args) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 6 (_6) - 16 load_var 6 (_6) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 7 (_7) - 21 load_var 7 (_7) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +22 (to 46) - 25 load_var 7 (_7) - 26 store_var 8 (a) - - 10 27 load_var 8 (a) - 28 load_field 0 (name) - 29 store_var 9 (_12) - 30 load_var 8 (a) - 31 load_field 1 (type) - 32 sys_op 365 (baml.json.schema) - 33 store_var 10 (_13) - 34 load_type 0 - 35 load_type 1 - 36 load_var2 4 9 - 37 load_var 10 (_13) - 38 call 37 ntypeargs=2 (baml.Map.set) - 39 pop 1 - - 11 40 load_type 0 - 41 load_var2 5 8 - 42 load_field 0 (name) - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -29 (to 16) - - 13 46 load_const 7 ("object") - 47 load_var2 4 5 - 48 load_const 8 (false) - 49 load_const 9 ("type") - 50 load_const 10 ("properties") - 51 load_const 11 ("required") - 52 load_const 12 ("additionalProperties") - 53 load_type 0 - 54 load_type 1 - 55 alloc_map 4 - 56 store_var 2 (_0) - 57 load_var 2 (_0) - 58 return -} - -function ai.internal._shorthand_prefixes() -> string { - 8 0 load_type 0 - 1 load_const 1 ("openai") - 2 load_const 2 ("openai-chat") - 3 load_const 3 ("openai-images") - 4 load_const 4 ("azure") - 5 load_const 5 ("ollama") - 6 load_const 6 ("openrouter") - 7 load_const 7 ("anthropic") - 8 load_const 8 ("google") - 9 load_const 9 ("vertex") - 10 load_const 10 ("bedrock") - 11 load_const 11 ("ai-gateway-images") - 12 load_const 12 ("claude-code") - 13 load_type 0 - 14 alloc_array 12 - 15 load_const 13 (", ") - 16 call 15 ntypeargs=1 (baml.Array.join) - 17 return -} - -function ai.internal._wire_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], keep_reasoning: bool) -> (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[] { - 94 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 95 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 5 (_4) - 8 load_var 5 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 6 (_5) - 13 load_var 6 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +48 (to 64) - 17 load_var 6 (_5) - 18 store_var 7 (block) - - 96 19 load_var 7 (block) - 20 store_var 8 (_9) - 21 load_var 8 (_9) - 22 narrow_bind 6 8 - 23 pop_jump_if_false +2 (to 25) - 24 jump +28 (to 52) - 25 load_var 7 (block) - 26 store_var 10 (_17) - 27 load_var 10 (_17) - 28 narrow_bind 7 10 - 29 pop_jump_if_false +2 (to 31) - 30 jump +13 (to 43) - 31 load_var 7 (block) - 32 store_var 12 (_22) - 33 load_var 12 (_22) - 34 narrow_bind 8 12 - 35 pop_jump_if_false -27 (to 8) - 36 load_var 12 (_22) - 37 store_var 13 (use) - - 110 38 load_type 0 - 39 load_var2 4 13 - 40 call 4 ntypeargs=1 (baml.Array.push) - 41 pop 1 - 42 jump -34 (to 8) - - 96 43 load_var 10 (_17) - 44 store_var 11 (reasoning) - - 104 45 load_var 2 (keep_reasoning) - 46 pop_jump_if_false -38 (to 8) - - 105 47 load_type 0 - 48 load_var2 4 11 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -43 (to 8) - - 96 52 load_var 8 (_9) - 53 store_var_load_var 9 (text) - - 98 54 load_field 0 (text) - 55 call 144 ntypeargs=0 (baml.String.trim) - 56 load_const 9 ("") - 57 cmp_op != - 58 pop_jump_if_false -50 (to 8) - - 99 59 load_type 0 - 60 load_var2 4 9 - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -55 (to 8) - - 119 64 load_var 4 (out) - 65 store_var 3 (_0) - 66 load_var 3 (_0) - 67 return -} - -function ai.internal.assemble_prompt(parts: string[], values: unknown[]) -> ai.Prompt { -} - -function ai.internal.build_output_format(return_type: type) -> ai.OutputFormat { -} - -function ai.internal.get_return_type(function_name: string) -> type { -} - -function ai.internal.make_role(name: string) -> ai.Role { - 46 0 load_var 1 (name) - 1 load_type 0 - 2 load_type 1 - 3 alloc_map 0 - 4 init_instance 0 (ai.Role .name, .metadata) - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function ai.internal.render_output_format(return_type: type) -> string { -} - -function ai.internal.validate_output_type(return_type: type) -> void { - 10 0 load_var 1 (return_type) - 1 call 215 ntypeargs=0 (baml.TypeValue._validate_renderable) - 2 pop 1 - - 11 3 load_var 1 (return_type) - 4 call 207 ntypeargs=0 (baml.TypeValue.as_enum) - 5 store_var 2 (_4) - 6 load_var 2 (_4) - 7 narrow_bind 0 2 - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 25 10 load_const 1 (null) - - 11 11 jump +13 (to 24) - 12 load_var 2 (_4) - 13 store_var 3 (enum_type) - - 13 14 load_var 3 (enum_type) - 15 call 795 ntypeargs=0 (baml.reflect.enum.Type.values) - 16 container_len - 17 store_var 4 (_7) - 18 load_var 4 (_7) - 19 load_const 2 (0) - 20 cmp_int_op == - 21 pop_jump_if_false +2 (to 23) - 22 jump +3 (to 25) - 23 load_const 1 (null) - 24 return - - 14 25 load_var 1 (return_type) - 26 call 217 ntypeargs=0 (baml.TypeValue.baml.ToString.to_string) - 27 store_var 6 (_11) - 28 load_const 3 ("empty enum `") - 29 load_var 6 (_11) - 30 bin_op + - 31 load_const 4 ("` cannot be rendered as an LLM output schema") - 32 bin_op + - 33 store_var_load_var 5 (message) - - 17 34 load_const 5 ("E0159") - 35 load_const 1 (null) - - 20 36 load_var 5 (message) - 37 init_instance 0 (baml.reflect.Diagnostic .code, .span, .message) - 38 load_type 6 - 39 alloc_array 1 - 40 init_instance 1 (baml.reflect.errors.CompilationError .message, .diagnostics) - 41 throw -} - -function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, params: map) -> baml.json.json { - 86 0 load_var 1 (self) - 1 load_field 2 (next_id) - 2 store_var 4 (id) - - 87 3 load_var 1 (self) - 4 copy 0 - 5 load_field 2 (next_id) - 6 load_const 0 (1) - 7 bin_op + - 8 store_field 2 (next_id) - - 88 9 load_var2 4 2 - 10 load_var 3 (params) - 11 call 1364 ntypeargs=0 (ai.mcp.rpc_line) - 12 store_var 5 (_6) - 13 load_var2 1 5 - 14 call 1366 ntypeargs=0 (ai.mcp.McpConnection._send) - 15 pop 1 - - 89 16 load_const 1 (true) - 17 pop_jump_if_false +2 (to 19) - 18 jump +19 (to 37) - - 132 19 load_type 2 - 20 load_var 1 (self) - 21 load_field 0 (server_name) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 23 (_66) - - 133 24 load_type 2 - 25 load_var 2 (method) - 26 call 138 ntypeargs=1 (baml.String.from) - 27 store_var 24 (_70) - - 132 28 load_const 3 ("mcp/") - 29 load_var 23 (_66) - 30 bin_op + - - 133 31 load_const 4 ("no response for ") - 32 load_var 24 (_70) - 33 bin_op + - 34 load_const 5 (null) - 35 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 36 throw - - 90 37 load_var 1 (self) - 38 load_field 1 (p) - 39 load_field 0 (stdout) - 40 load_type 6 - 41 load_const 7 ("next") - 42 virtual_call nargs=1 ntypeargs=0 - 43 store_var 6 (next) - 44 jump +25 (to 69) - 45 load_var 7 (e) - 46 throw_if_panic - - 93 47 load_type 2 - 48 load_var 1 (self) - 49 load_field 0 (server_name) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 8 (_13) - - 94 52 load_type 8 - 53 load_var 7 (e) - 54 call 138 ntypeargs=1 (baml.String.from) - 55 store_var 10 (_18) - 56 load_type 2 - 57 load_var 10 (_18) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 9 (_17) - - 93 60 load_const 9 ("mcp/") - 61 load_var 8 (_13) - 62 bin_op + - - 94 63 load_const 10 ("reading from the MCP server failed: ") - 64 load_var 9 (_17) - 65 bin_op + - 66 load_const 5 (null) - 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 68 throw - - 99 69 load_var 6 (next) - 70 store_var 11 (_21) - 71 load_var 11 (_21) - 72 narrow_bind 0 11 - 73 pop_jump_if_false +2 (to 75) - 74 jump +19 (to 93) - - 123 75 load_type 2 - 76 load_var 1 (self) - 77 load_field 0 (server_name) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 21 (_58) - - 124 80 load_type 2 - 81 load_var 2 (method) - 82 call 138 ntypeargs=1 (baml.String.from) - 83 store_var 22 (_62) - - 123 84 load_const 11 ("mcp/") - 85 load_var 21 (_58) - 86 bin_op + - - 124 87 load_const 12 ("the MCP server stream ended before answering ") - 88 load_var 22 (_62) - 89 bin_op + - 90 load_const 5 (null) - 91 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 92 throw - - 99 93 load_var 11 (_21) - 94 store_var 12 (line) - - 101 95 load_var 12 (line) - 96 call 144 ntypeargs=0 (baml.String.trim) - 97 store_var 13 (trimmed) - - 102 98 load_var 13 (trimmed) - 99 call 139 ntypeargs=0 (baml.String.length) - 100 load_const 13 (0) - 101 cmp_int_op > - 102 pop_jump_if_false -86 (to 16) - - 104 103 load_var 13 (trimmed) - 104 call 350 ntypeargs=0 (baml.json.parse) - 105 store_var 14 (msg) - 106 jump +5 (to 111) - 107 load_var 15 (e) - 108 throw_if_panic - - 105 109 load_const 5 (null) - 110 store_var 14 (msg) - - 107 111 load_type 14 - 112 load_var 14 (msg) - 113 load_const 15 (".id") - 114 load_const 0 (1) - 115 unary_op - - 116 call 364 ntypeargs=1 (baml.json.path_or) - 117 load_var 4 (id) - 118 cmp_int_op == - 119 pop_jump_if_false -103 (to 16) - - 108 120 load_type 16 - 121 load_var 14 (msg) - 122 load_const 17 (".error") - 123 load_const 5 (null) - 124 call 364 ntypeargs=1 (baml.json.path_or) - 125 store_var 16 (err) - - 109 126 load_var 16 (err) - 127 load_const 5 (null) - 128 call 672 ntypeargs=0 (baml.ops.equals_equals) - 129 unary_op ! - 130 pop_jump_if_false +2 (to 132) - 131 jump +7 (to 138) - - 117 132 load_type 16 - 133 load_var 14 (msg) - 134 load_const 18 (".result") - 135 load_const 5 (null) - 136 call 364 ntypeargs=1 (baml.json.path_or) - 137 return - - 111 138 load_type 2 - 139 load_var 1 (self) - 140 load_field 0 (server_name) - 141 call 138 ntypeargs=1 (baml.String.from) - 142 store_var 17 (_43) - - 112 143 load_type 19 - 144 load_var 16 (err) - 145 load_const 20 (".code") - 146 load_const 5 (null) - 147 call 364 ntypeargs=1 (baml.json.path_or) - 148 store_var 18 (_46) - - 113 149 load_type 2 - 150 load_var 16 (err) - 151 load_const 21 (".message") - 152 load_const 22 ("MCP error") - 153 call 364 ntypeargs=1 (baml.json.path_or) - 154 store_var 19 (_49) - - 114 155 load_var 16 (err) - 156 call 351 ntypeargs=0 (baml.json.stringify) - 157 store_var 20 (_52) - - 111 158 load_const 23 ("mcp/") - 159 load_var 17 (_43) - 160 bin_op + - 161 load_var2 18 19 - 162 load_var 20 (_52) - 163 init_instance 3 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 164 throw -} - -function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> void { - 71 0 load_type 0 - 1 load_var 2 (line) - 2 load_const 1 ("\n") - 3 load_type 0 - 4 alloc_array 2 - 5 load_const 2 ("") - 6 call 15 ntypeargs=1 (baml.Array.join) - 7 store_var 4 (framed) - - 72 8 load_var 1 (self) - 9 load_field 1 (p) - 10 load_var 4 (framed) - 11 sys_op 267 (baml.sys.Process.write_stdin) - 12 pop 1 - 13 jump +25 (to 38) - 14 load_var 5 (e) - 15 throw_if_panic - - 75 16 load_type 0 - 17 load_var 1 (self) - 18 load_field 0 (server_name) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 6 (_12) - - 76 21 load_type 3 - 22 load_var 5 (e) - 23 call 138 ntypeargs=1 (baml.String.from) - 24 store_var 8 (_17) - 25 load_type 0 - 26 load_var 8 (_17) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 7 (_16) - - 75 29 load_const 4 ("mcp/") - 30 load_var 6 (_12) - 31 bin_op + - - 76 32 load_const 5 ("writing to the MCP server failed: ") - 33 load_var 7 (_16) - 34 bin_op + - 35 load_const 6 (null) - 36 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 37 throw - - 67 38 load_const 6 (null) - 39 store_var 3 (_0) - 40 load_var 3 (_0) - 41 return -} - -function ai.mcp.McpConnection.call_tool(self: ai.mcp.McpConnection, name: string, args: map) -> string { - 169 0 load_var2 2 3 - 1 load_const 0 ("name") - 2 load_const 1 ("arguments") - 3 load_type 2 - 4 load_type 3 - 5 alloc_map 2 - 6 store_var 5 (params) - - 170 7 load_var 1 (self) - 8 load_const 4 ("tools/call") - 9 load_var 5 (params) - 10 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 11 store_var 6 (result) - - 171 12 load_type 2 - 13 alloc_array 0 - 14 store_var 7 (texts) - - 172 15 load_type 5 - 16 load_var 6 (result) - 17 load_const 6 (".content") - 18 load_type 7 - 19 alloc_array 0 - 20 call 364 ntypeargs=1 (baml.json.path_or) - 21 load_type 8 - 22 load_const 9 ("iter") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 8 (_12) - 25 load_var 8 (_12) - 26 load_type 10 - 27 load_const 11 ("next") - 28 virtual_call nargs=1 ntypeargs=0 - 29 store_var 9 (_13) - 30 load_var 9 (_13) - 31 is_type 12 - 32 pop_jump_if_false +2 (to 34) - 33 jump +22 (to 55) - 34 load_var 9 (_13) - 35 store_var 10 (item) - - 173 36 load_type 2 - 37 load_var 10 (item) - 38 load_const 13 (".type") - 39 load_const 14 ("") - 40 call 364 ntypeargs=1 (baml.json.path_or) - 41 load_const 15 ("text") - 42 cmp_op == - 43 pop_jump_if_false -18 (to 25) - - 174 44 load_type 2 - 45 load_var 10 (item) - 46 load_const 16 (".text") - 47 load_const 17 ("") - 48 call 364 ntypeargs=1 (baml.json.path_or) - 49 store_var 11 (_22) - 50 load_type 2 - 51 load_var2 7 11 - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - 54 jump -29 (to 25) - - 177 55 load_type 2 - 56 load_var 7 (texts) - 57 load_const 18 ("\n") - 58 call 15 ntypeargs=1 (baml.Array.join) - 59 store_var 12 (joined) - - 178 60 load_type 19 - 61 load_var 6 (result) - 62 load_const 20 (".isError") - 63 load_const 21 (false) - 64 call 364 ntypeargs=1 (baml.json.path_or) - 65 pop_jump_if_false +2 (to 67) - 66 jump +5 (to 71) - - 181 67 load_var 12 (joined) - 68 store_var 4 (_0) - 69 load_var 4 (_0) - 70 return - - 179 71 load_type 2 - 72 load_var 2 (name) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 13 (_35) - 75 load_type 2 - 76 load_var 12 (joined) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 14 (_37) - 79 load_const 22 ("mcp tool ") - 80 load_var 13 (_35) - 81 bin_op + - 82 load_const 23 (" failed: ") - 83 bin_op + - 84 load_var 14 (_37) - 85 bin_op + - 86 init_instance 0 (baml.errors.InvalidArgument .message) - 87 throw -} - -function ai.mcp.McpConnection.close(self: ai.mcp.McpConnection) -> void { - 185 0 load_var 1 (self) - 1 load_field 1 (p) - 2 sys_op 271 (baml.sys.Process.close) - 3 pop 1 - - 184 4 load_const 0 (null) - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function ai.mcp.McpConnection.connect(name: string, command: string, args: string[], timeout_ms: int) -> ai.mcp.McpConnection { - 0 load_var 4 (timeout_ms) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 35 4 load_const 1 (30000) - 5 store_var 4 (timeout_ms) - - 37 6 load_var2 2 3 - - 40 7 load_const 2 (null) - 8 load_const 2 (null) - 9 load_var 4 (timeout_ms) - 10 load_const 2 (null) - 11 load_const 3 (true) - 12 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) - 13 sys_op 273 (baml.sys.start_process) - 14 store_var 6 (p) - 15 jump +24 (to 39) - - 37 16 load_var 7 (e) - 17 throw_if_panic - - 50 18 load_type 4 - 19 load_var 1 (name) - 20 call 138 ntypeargs=1 (baml.String.from) - 21 store_var 8 (_11) - - 51 22 load_type 5 - 23 load_var 7 (e) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 store_var 10 (_15) - 26 load_type 4 - 27 load_var 10 (_15) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 9 (_14) - - 50 30 load_const 6 ("mcp/") - 31 load_var 8 (_11) - 32 bin_op + - - 51 33 load_const 7 ("the MCP server could not start: ") - 34 load_var 9 (_14) - 35 bin_op + - 36 load_const 2 (null) - 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 38 throw - - 56 39 load_var2 1 6 - 40 load_const 8 (1) - 41 init_instance 2 (ai.mcp.McpConnection .server_name, .p, .next_id) - 42 store_var 11 (conn) - - 57 43 load_const 9 ("2025-06-18") - - 59 44 load_type 4 - 45 load_type 10 - 46 alloc_map 0 - - 60 47 load_const 11 ("baml-mcp") - 48 load_const 12 ("0.1") - 49 load_const 13 ("name") - 50 load_const 14 ("version") - 51 load_type 4 - 52 load_type 4 - 53 alloc_map 2 - 54 load_const 15 ("protocolVersion") - 55 load_const 16 ("capabilities") - 56 load_const 17 ("clientInfo") - 57 load_type 4 - 58 load_type 10 - 59 alloc_map 3 - 60 store_var 12 (init) - - 62 61 load_var 11 (conn) - 62 load_const 18 ("initialize") - 63 load_var 12 (init) - 64 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 65 pop 1 - - 63 66 load_const 2 (null) - 67 load_const 19 ("notifications/initialized") - 68 load_const 2 (null) - 69 call 1364 ntypeargs=0 (ai.mcp.rpc_line) - 70 store_var 13 (_26) - 71 load_var2 11 13 - 72 call 1366 ntypeargs=0 (ai.mcp.McpConnection._send) - 73 pop 1 - - 64 74 load_var 11 (conn) - 75 store_var 5 (_0) - 76 load_var 5 (_0) - 77 return -} - -function ai.mcp.McpConnection.tools(self: ai.mcp.McpConnection) -> ai.tools.Tool[] { - 142 0 load_var 1 (self) - 1 load_const 0 ("tools/list") - 2 load_type 1 - 3 load_type 2 - 4 alloc_map 0 - 5 call 1367 ntypeargs=0 (ai.mcp.McpConnection._request) - 6 store_var 3 (result) - - 143 7 load_type 3 - 8 alloc_array 0 - 9 store_var 4 (out) - - 144 10 load_type 4 - 11 load_var 3 (result) - 12 load_const 5 (".tools") - 13 load_type 6 - 14 alloc_array 0 - 15 call 364 ntypeargs=1 (baml.json.path_or) - 16 load_type 7 - 17 load_const 8 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 5 (_9) - 20 load_var 5 (_9) - 21 load_type 9 - 22 load_const 10 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 6 (_10) - 25 load_var 6 (_10) - 26 is_type 11 - 27 pop_jump_if_false +2 (to 29) - 28 jump +51 (to 79) - 29 load_var 6 (_10) - 30 store_var 7 (t) - - 145 31 load_type 1 - 32 load_var 7 (t) - 33 load_const 12 (".name") - 34 load_const 13 ("") - 35 call 364 ntypeargs=1 (baml.json.path_or) - 36 store_var 8 (tool_name) - - 147 37 load_type 6 - 38 load_var 7 (t) - 39 load_const 14 (".inputSchema") - 40 load_type 1 - 41 load_type 6 - 42 alloc_map 0 - 43 call 364 ntypeargs=1 (baml.json.path_or) - 44 store_var 11 (_19) - - 146 45 load_type 15 - 46 load_var 11 (_19) - 47 call 358 ntypeargs=1 (baml.json.from_json) - 48 store_var 9 (schema) - 49 jump +9 (to 58) - 50 load_var 10 (e) - 51 throw_if_panic - - 150 52 load_type 1 - 53 load_type 2 - 54 alloc_map 0 - 55 store_var 12 (empty) - - 151 56 load_var 12 (empty) - 57 store_var 9 (schema) - - 157 58 load_type 1 - 59 load_var 7 (t) - 60 load_const 16 (".description") - 61 load_const 17 ("") - 62 call 364 ntypeargs=1 (baml.json.path_or) - 63 store_var 14 (_28) - - 158 64 load_var 9 (schema) - 65 store_var 15 (_31) - - 159 66 load_var2 1 8 - 67 call 1371 ntypeargs=0 (ai.internal._proxy) - 68 store_var 16 (_32) - - 156 69 load_var2 8 14 - 70 load_var2 15 16 - 71 load_const 18 () - - 155 72 call 920 ntypeargs=0 (ai.tools.raw_tool) - 73 store_var 13 (_26) - - 154 74 load_type 3 - 75 load_var2 4 13 - 76 call 4 ntypeargs=1 (baml.Array.push) - 77 pop 1 - 78 jump -58 (to 20) - - 163 79 load_var 4 (out) - 80 store_var 2 (_0) - 81 load_var 2 (_0) - 82 return -} - -function ai.mcp.rpc_line(id: int | null, method: string, params: map | null) -> string { - 14 0 load_const 0 ("2.0") - 1 load_var 2 (method) - 2 load_const 1 ("jsonrpc") - 3 load_const 2 ("method") - 4 load_type 3 - 5 load_type 4 - 6 alloc_map 2 - 7 store_var 4 (m) - - 15 8 load_var 1 (id) - 9 store_var 5 (_5) - 10 load_var 5 (_5) - 11 narrow_bind 5 5 - 12 pop_jump_if_false +10 (to 22) - 13 load_var 5 (_5) - 14 store_var 6 (i) - - 16 15 load_type 3 - 16 load_type 4 - 17 load_var 4 (m) - 18 load_const 6 ("id") - 19 load_var 6 (i) - 20 call 37 ntypeargs=2 (baml.Map.set) - 21 pop 1 - - 18 22 load_var 3 (params) - 23 store_var 7 (_11) - 24 load_var 7 (_11) - 25 narrow_bind 7 7 - 26 pop_jump_if_false +10 (to 36) - 27 load_var 7 (_11) - 28 store_var 8 (p) - - 19 29 load_type 3 - 30 load_type 4 - 31 load_var 4 (m) - 32 load_const 8 ("params") - 33 load_var 8 (p) - 34 call 37 ntypeargs=2 (baml.Map.set) - 35 pop 1 - - 21 36 load_type 7 - 37 load_var 4 (m) - 38 call 355 ntypeargs=1 (baml.json.to_json) - 39 call 351 ntypeargs=0 (baml.json.stringify) - 40 return -} - -function ai.prompt(body: ((string) -> ai.Role throws never, ai.Context) -> baml.TaggedString throws never) -> (ai.Context) -> ai.Prompt throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 84 3 load_var 1 (body) - 4 make_closure 2109 1 - 5 store_var 3 (render) - - 88 6 load_var 3 (render) - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function ai.stream.Stream.final(self: ai.stream.Stream<#0, #1>) -> #1 { - 374 0 load_var 1 (self) - 1 load_field 3 (_finished) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +9 (to 13) - - 384 5 load_var 1 (self) - 6 load_field 2 (_text) - 7 load_var 1 (self) - 8 load_field 1 (_cache) - 9 load_type 0 - 10 load_type 1 - 11 sys_op 443 (baml.sap.__parse_final) - 12 return - - 375 13 load_var 1 (self) - 14 load_field 0 (_next_text) - 15 call_indirect - 16 store_var 2 (_4) - 17 load_var 2 (_4) - 18 load_const 2 (null) - 19 cmp_op == - 20 pop_jump_if_false +2 (to 22) - 21 jump +9 (to 30) - 22 load_var 2 (_4) - 23 store_var 3 (s) - - 380 24 load_var2 1 1 - 25 load_field 2 (_text) - 26 load_var 3 (s) - 27 bin_op + - 28 store_field 2 (_text) - - 375 29 jump -29 (to 0) - - 377 30 load_var 1 (self) - 31 load_const 3 (true) - 32 store_field 3 (_finished) - - 375 33 jump -33 (to 0) -} - -function ai.stream.Stream.next(self: ai.stream.Stream<#0, #1>) -> #0 | ai.stream.Done { - 348 0 load_const 0 (true) - 1 pop_jump_if_false +2 (to 3) - 2 jump +4 (to 6) - - 369 3 load_const 1 ("unreachable") - 4 call 277 ntypeargs=0 (baml.sys.panic) - 5 jump +43 (to 48) - - 349 6 load_var 1 (self) - 7 load_field 3 (_finished) - 8 pop_jump_if_false +2 (to 10) - 9 jump +38 (to 47) - - 352 10 load_var 1 (self) - 11 load_field 0 (_next_text) - 12 call_indirect - 13 store_var 2 (_3) - 14 load_var 2 (_3) - 15 load_const 2 (null) - 16 cmp_op == - 17 pop_jump_if_false +2 (to 19) - 18 jump +24 (to 42) - 19 load_var 2 (_3) - 20 store_var 3 (s) - - 358 21 load_var2 1 1 - 22 load_field 2 (_text) - 23 load_var 3 (s) - 24 bin_op + - 25 store_field 2 (_text) - - 359 26 load_var 1 (self) - 27 load_field 2 (_text) - 28 load_var 1 (self) - 29 load_field 1 (_cache) - 30 load_type 3 - 31 load_type 4 - 32 sys_op 444 (baml.sap.__parse_partial) - 33 store_var 4 (parsed) - - 360 34 load_var 4 (parsed) - 35 is_type 5 - 36 pop_jump_if_false +2 (to 38) - 37 jump -37 (to 0) - 38 load_var 4 (parsed) - 39 store_var 5 (p) - - 363 40 load_var 5 (p) - 41 jump +7 (to 48) - - 354 42 load_var 1 (self) - 43 load_const 0 (true) - 44 store_field 3 (_finished) - - 355 45 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 46 jump +2 (to 48) - - 350 47 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 48 return -} - -function ai.stream.TurnStream._check_terminal(self: ai.stream.TurnStream) -> void { - 202 0 load_var 1 (self) - 1 load_field 11 (_require_terminal) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - 7 load_const 1 (null) - 8 jump +9 (to 17) - 9 load_var 2 (_3) - 10 store_var 3 (provider) - - 203 11 load_var 1 (self) - 12 load_field 12 (_saw_terminal) - 13 unary_op ! - 14 pop_jump_if_false +2 (to 16) - 15 jump +3 (to 18) - 16 load_const 1 (null) - 17 return - - 204 18 load_var 1 (self) - 19 load_field 6 (_text) - 20 load_const 2 ("") - 21 cmp_op == - 22 pop_jump_if_false +2 (to 24) - 23 jump +5 (to 28) - - 207 24 load_var 1 (self) - 25 load_field 6 (_text) - 26 store_var 4 (partial) - - 204 27 jump +3 (to 30) - - 205 28 load_const 1 (null) - 29 store_var 4 (partial) - - 211 30 load_var 1 (self) - 31 load_field 6 (_text) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 store_var 6 (_15) - 34 load_type 3 - 35 load_var 6 (_15) - 36 call 138 ntypeargs=1 (baml.String.from) - 37 store_var 5 (_14) - - 210 38 load_var 3 (provider) - - 211 39 load_const 4 ("stream ended before the provider's terminal event: the connection closed after ") - 40 load_var 5 (_14) - 41 bin_op + - 42 load_const 5 (" characters of assistant text with no end-of-turn event, so the turn is truncated") - 43 bin_op + - - 212 44 load_var 4 (partial) - 45 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 46 throw -} - -function ai.stream.TurnStream._finish(self: ai.stream.TurnStream) -> void { - 191 0 load_var 1 (self) - 1 load_const 0 (true) - 2 store_field 10 (_done) - - 192 3 load_var 1 (self) - 4 load_field 0 (_sse) - 5 store_var 2 (_3) - 6 load_var 2 (_3) - 7 narrow_bind 1 2 - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - 10 load_const 2 (null) - 11 jump +7 (to 18) - 12 load_var 2 (_3) - 13 store_var 3 (sse) - - 193 14 load_var 3 (sse) - 15 sys_op 246 (baml.http.SseStream.close) - 16 pop 1 - - 192 17 load_const 2 (null) - 18 return -} - -function ai.stream.TurnStream.final_turn(self: ai.stream.TurnStream) -> ai.ModelTurn { - 307 0 load_const 0 (true) - 1 pop_jump_if_false +7 (to 8) - - 308 2 load_var 1 (self) - 3 call 963 ntypeargs=0 (ai.stream.TurnStream.next) - 4 store_var 2 (_3) - 5 load_var 2 (_3) - 6 narrow_bind 1 2 - 7 pop_jump_if_false -7 (to 0) - - 318 8 load_var 1 (self) - 9 call 962 ntypeargs=0 (ai.stream.TurnStream._check_terminal) - 10 pop 1 - - 319 11 load_var 1 (self) - 12 load_field 8 (_input_tokens) - 13 load_const 2 (null) - 14 call 672 ntypeargs=0 (baml.ops.equals_equals) - 15 unary_op ! - 16 jump_if_false +2 (to 18) - 17 jump +7 (to 24) - 18 pop 1 - 19 load_var 1 (self) - 20 load_field 9 (_output_tokens) - 21 load_const 2 (null) - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - 23 unary_op ! - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - - 327 26 load_const 2 (null) - 27 store_var 3 (usage) - - 319 28 jump +24 (to 52) - - 321 29 load_var 1 (self) - 30 load_field 8 (_input_tokens) - 31 store_var_load_var 5 (_13) - 32 load_const 2 (null) - 33 cmp_op == - 34 pop_jump_if_false +3 (to 37) - 35 load_const 3 (0) - 36 store_var 5 (_13) - 37 load_var 5 (_13) - 38 store_var 4 (_12) - - 322 39 load_var 1 (self) - 40 load_field 9 (_output_tokens) - 41 store_var_load_var 6 (_17) - 42 load_const 2 (null) - 43 cmp_op == - 44 pop_jump_if_false +3 (to 47) - 45 load_const 3 (0) - 46 store_var 6 (_17) - - 320 47 load_var2 4 6 - - 322 48 load_const 2 (null) - 49 load_const 2 (null) - 50 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 51 store_var 3 (usage) - - 331 52 load_var 1 (self) - 53 load_field 7 (_stop_reason) - 54 store_var_load_var 7 (_24) - 55 load_const 2 (null) - 56 cmp_op == - 57 pop_jump_if_false +4 (to 61) - 58 load_const 3 (ai.content.StopReason.Complete) - 59 alloc_variant 774 (ai.content.StopReason) - 60 store_var 7 (_24) - - 330 61 load_var 1 (self) - 62 load_field 6 (_text) - 63 init_instance 1 (ai.content.Text .text) - 64 load_type 4 - 65 alloc_array 1 - - 331 66 load_var2 7 3 - - 332 67 init_instance 2 (ai.ModelTurn .content, .stop_reason, .usage) - 68 return -} - -function ai.stream.TurnStream.from_chunks(chunks: string[]) -> ai.stream.TurnStream { - 173 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_var 1 (chunks) - 3 load_const 1 (0) - - 178 4 load_type 2 - 5 alloc_array 0 - 6 load_const 1 (0) - 7 load_const 3 ("") - 8 load_const 0 (null) - 9 load_const 0 (null) - 10 load_const 0 (null) - 11 load_const 4 (false) - 12 load_const 0 (null) - 13 load_const 4 (false) - 14 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal) - 15 store_var 2 (_0) - 16 load_var 2 (_0) - 17 return -} - -function ai.stream.TurnStream.from_sse(sse: baml.http.SseStream, decode: (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown, require_terminal: string | null) -> ai.stream.TurnStream { - 0 load_var 3 (require_terminal) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 149 4 load_const 1 (null) - 5 store_var 3 (require_terminal) - - 151 6 load_var2 1 2 - - 154 7 load_type 2 - 8 alloc_array 0 - 9 load_const 3 (0) - - 156 10 load_type 4 - 11 alloc_array 0 - 12 load_const 3 (0) - 13 load_const 5 ("") - 14 load_const 1 (null) - 15 load_const 1 (null) - 16 load_const 1 (null) - 17 load_const 6 (false) - 18 load_var 3 (require_terminal) - 19 load_const 6 (false) - 20 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal) - 21 return -} - -function ai.stream.TurnStream.next(self: ai.stream.TurnStream) -> string | ai.stream.Done { - 221 0 load_const 0 (true) - 1 pop_jump_if_false +2 (to 3) - 2 jump +4 (to 6) - - 296 3 load_const 1 ("unreachable") - 4 call 277 ntypeargs=0 (baml.sys.panic) - 5 jump +204 (to 209) - - 222 6 load_var 1 (self) - 7 load_field 10 (_done) - 8 pop_jump_if_false +2 (to 10) - 9 jump +199 (to 208) - - 226 10 load_var 1 (self) - 11 load_field 5 (_pcursor) - 12 store_var 2 (_4) - 13 load_var 1 (self) - 14 load_field 4 (_pending) - 15 container_len - 16 store_var 3 (_5) - 17 load_var2 2 3 - 18 cmp_int_op < - 19 pop_jump_if_false +2 (to 21) - 20 jump +99 (to 119) - - 255 21 load_var 1 (self) - 22 load_field 0 (_sse) - 23 store_var 18 (_33) - 24 load_var 18 (_33) - 25 narrow_bind 2 18 - 26 pop_jump_if_false +2 (to 28) - 27 jump +40 (to 67) - - 282 28 load_type 3 - 29 load_var 1 (self) - 30 load_field 2 (_chunks) - 31 load_var 1 (self) - 32 load_field 3 (_cursor) - 33 call 3 ntypeargs=1 (baml.Array.at) - 34 store_var 27 (_59) - 35 load_var 27 (_59) - 36 narrow_bind 4 27 - 37 pop_jump_if_false +2 (to 39) - 38 jump +6 (to 44) - - 289 39 load_var 1 (self) - 40 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 41 pop 1 - - 290 42 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 43 jump +166 (to 209) - - 282 44 load_var 27 (_59) - 45 store_var 28 (c) - - 284 46 load_var 1 (self) - 47 copy 0 - 48 load_field 3 (_cursor) - 49 load_const 4 (1) - 50 bin_op + - 51 store_field 3 (_cursor) - - 285 52 load_type 3 - 53 load_var 1 (self) - 54 load_field 6 (_text) - 55 call 138 ntypeargs=1 (baml.String.from) - 56 store_var 29 (_61) - 57 load_type 3 - 58 load_var 28 (c) - 59 call 138 ntypeargs=1 (baml.String.from) - 60 store_var 30 (_64) - 61 load_var2 1 29 - 62 load_var 30 (_64) - 63 bin_op + - 64 store_field 6 (_text) - - 286 65 load_var 28 (c) - 66 jump +143 (to 209) - - 255 67 load_var 18 (_33) - 68 store_var 19 (sse) - - 257 69 load_var 19 (sse) - 70 sys_op 245 (baml.http.SseStream.next) - 71 store_var 20 (_35) - 72 load_var 20 (_35) - 73 load_const 5 (null) - 74 cmp_op == - 75 pop_jump_if_false +2 (to 77) - 76 jump +35 (to 111) - 77 load_var 20 (_35) - 78 store_var 21 (batch) - - 267 79 load_var 1 (self) - 80 load_field 1 (_decode) - 81 store_var 22 (_41) - 82 load_var 22 (_41) - 83 narrow_bind 6 22 - 84 pop_jump_if_false -84 (to 0) - 85 load_var 22 (_41) - 86 store_var 23 (decode) - - 268 87 load_var2 21 23 - 88 call_indirect - 89 load_type 7 - 90 load_const 8 ("iter") - 91 virtual_call nargs=1 ntypeargs=0 - 92 store_var 24 (_46) - 93 load_var 24 (_46) - 94 load_type 9 - 95 load_const 10 ("next") - 96 virtual_call nargs=1 ntypeargs=0 - 97 store_var 25 (_47) - 98 load_var 25 (_47) - 99 is_type 11 - 100 pop_jump_if_false +2 (to 102) - 101 jump -101 (to 0) - 102 load_var 25 (_47) - 103 store_var 26 (e) - - 269 104 load_type 12 - 105 load_var 1 (self) - 106 load_field 4 (_pending) - 107 load_var 26 (e) - 108 call 4 ntypeargs=1 (baml.Array.push) - 109 pop 1 - 110 jump -17 (to 93) - - 262 111 load_var 1 (self) - 112 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 113 pop 1 - - 263 114 load_var 1 (self) - 115 call 962 ntypeargs=0 (ai.stream.TurnStream._check_terminal) - 116 pop 1 - - 264 117 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 118 jump +91 (to 209) - - 227 119 load_type 12 - 120 load_var 1 (self) - 121 load_field 4 (_pending) - 122 load_var 1 (self) - 123 load_field 5 (_pcursor) - 124 call 3 ntypeargs=1 (baml.Array.at) - 125 store_var 4 (e) - - 228 126 load_var 1 (self) - 127 copy 0 - 128 load_field 5 (_pcursor) - 129 load_const 4 (1) - 130 bin_op + - 131 store_field 5 (_pcursor) - - 229 132 load_var 4 (e) - 133 store_var 5 (_11) - 134 load_var 5 (_11) - 135 narrow_bind 13 5 - 136 pop_jump_if_false +2 (to 138) - 137 jump +52 (to 189) - 138 load_var 4 (e) - 139 store_var 9 (_19) - 140 load_var 9 (_19) - 141 narrow_bind 14 9 - 142 pop_jump_if_false +2 (to 144) - 143 jump +14 (to 157) - 144 load_var 4 (e) - 145 store_var 17 (_30) - 146 load_var 17 (_30) - 147 narrow_bind 15 17 - 148 pop_jump_if_false -148 (to 0) - - 247 149 load_var 1 (self) - 150 load_const 0 (true) - 151 store_field 12 (_saw_terminal) - - 248 152 load_var 1 (self) - 153 call 961 ntypeargs=0 (ai.stream.TurnStream._finish) - 154 pop 1 - - 249 155 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 156 jump +53 (to 209) - - 229 157 load_var 9 (_19) - 158 store_var_load_var 10 (m) - - 235 159 load_field 0 (stop_reason) - 160 store_var 11 (_22) - 161 load_var 11 (_22) - 162 narrow_bind 16 11 - 163 pop_jump_if_false +5 (to 168) - 164 load_var 11 (_22) - 165 store_var 12 (s) - - 236 166 load_var2 1 12 - 167 store_field 7 (_stop_reason) - - 238 168 load_var 10 (m) - 169 load_field 1 (input_tokens) - 170 store_var 13 (_25) - 171 load_var 13 (_25) - 172 narrow_bind 17 13 - 173 pop_jump_if_false +5 (to 178) - 174 load_var 13 (_25) - 175 store_var 14 (i) - - 239 176 load_var2 1 14 - 177 store_field 8 (_input_tokens) - - 241 178 load_var 10 (m) - 179 load_field 2 (output_tokens) - 180 store_var 15 (_28) - 181 load_var 15 (_28) - 182 narrow_bind 17 15 - 183 pop_jump_if_false -183 (to 0) - 184 load_var 15 (_28) - 185 store_var 16 (o) - - 242 186 load_var2 1 16 - 187 store_field 9 (_output_tokens) - - 241 188 jump -188 (to 0) - - 229 189 load_var 5 (_11) - 190 store_var 6 (d) - - 231 191 load_type 3 - 192 load_var 1 (self) - 193 load_field 6 (_text) - 194 call 138 ntypeargs=1 (baml.String.from) - 195 store_var 7 (_13) - 196 load_type 3 - 197 load_var 6 (d) - 198 load_field 0 (text) - 199 call 138 ntypeargs=1 (baml.String.from) - 200 store_var 8 (_16) - 201 load_var2 1 7 - 202 load_var 8 (_16) - 203 bin_op + - 204 store_field 6 (_text) - - 232 205 load_var 6 (d) - 206 load_field 0 (text) - 207 jump +2 (to 209) - - 223 208 alloc_instance 411 ntypeargs=0 (ai.stream.Done) - 209 return -} - -function ai.stream.decode_sse_batch(batch: string) -> ai.stream.SseEvent[] { - 63 0 load_type 0 - 1 load_var 1 (batch) - 2 call 357 ntypeargs=1 (baml.json.from_string) - 3 return -} - -function ai.stream.from_spec(spec: ai.FunctionSpec<#1>, client: ai.stream.StreamingClient | null) -> ai.stream.Stream<#0, #1> { - 0 load_var 14 - 1 make_cell - 2 store_var 14 - 3 load_var 2 (client) - 4 load_const 0 () - 5 cmp_op == - 6 pop_jump_if_false +3 (to 9) - - 400 7 load_const 1 (null) - 8 store_var 2 (client) - - 402 9 load_type 2 - 10 load_var 1 (spec) - 11 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 12 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 13 unary_op ! - 14 pop_jump_if_false +2 (to 16) - 15 jump +79 (to 94) - - 407 16 load_var 2 (client) - 17 store_var 7 (_16) - 18 load_var 7 (_16) - 19 narrow_bind 3 7 - 20 pop_jump_if_false +2 (to 22) - 21 jump +22 (to 43) - - 410 22 load_var 1 (spec) - 23 load_field 4 (default_client) - 24 store_var 9 (_19) - 25 load_var 9 (_19) - 26 narrow_bind 3 9 - 27 pop_jump_if_false +2 (to 29) - 28 jump +10 (to 38) - - 414 29 load_var 1 (spec) - 30 load_field 4 (default_client) - 31 load_type 4 - 32 load_const 5 ("id") - 33 virtual_call nargs=1 ntypeargs=0 - 34 store_var 11 (_22) - - 413 35 load_var 11 (_22) - 36 init_instance 0 (ai.errors.StreamingUnsupported .client_id) - 37 throw - - 410 38 load_var 9 (_19) - 39 store_var 10 (s) - - 411 40 load_var 10 (s) - 41 store_var 6 (selected) - - 410 42 jump +5 (to 47) - - 407 43 load_var 7 (_16) - 44 store_var 8 (s) - - 408 45 load_var 8 (s) - 46 store_var 6 (selected) - - 421 47 load_var 6 (selected) - 48 store_var 13 (c) - - 422 49 load_var 13 (c) - 50 load_type 4 - 51 load_const 6 ("id") - 52 virtual_call nargs=1 ntypeargs=0 - 53 store_var 12 (provider) - - 426 54 load_var 1 (spec) - 55 load_field 2 (prompt_template) - 56 store_var 15 (_28) - - 427 57 load_type 2 - 58 load_var 1 (spec) - 59 call 906 ntypeargs=1 (ai.Journal.new) - 60 store_var 16 (_29) - - 428 61 load_type 2 - 62 load_var 1 (spec) - 63 call 917 ntypeargs=1 (ai.FunctionSpec.tools) - 64 store_var 17 (_31) - - 429 65 load_type 2 - 66 load_var 1 (spec) - 67 call 915 ntypeargs=1 (ai.FunctionSpec.output_type) - 68 store_var 18 (_33) - - 424 69 load_var2 6 15 - - 425 70 load_var2 16 17 - 71 load_var 18 (_33) - 72 init_instance 1 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) - 73 load_type 3 - 74 load_const 7 ("invoke_stream") - 75 virtual_call nargs=2 ntypeargs=0 - 76 store_deref 14 - - 442 77 load_type 8 - 78 load_type 2 - 79 call 442 ntypeargs=2 (baml.sap.__new_parse_cache) - 80 store_var 19 (_36) - - 436 81 load_type 8 - 82 load_type 2 - 83 load_var 14 (turns) - 84 make_closure 2290 captures=1 ntypeargs=2 - 85 load_var 19 (_36) - 86 load_const 9 ("") - 87 load_const 10 (false) - 88 load_type 8 - 89 load_type 2 - 90 init_instance 2 (ai.stream.Stream ._next_text, ._cache, ._text, ._finished) - 91 store_var 3 (_0) - 92 load_var 3 (_0) - 93 return - - 404 94 load_type 2 - 95 load_var 1 (spec) - 96 call 913 ntypeargs=1 (ai.FunctionSpec.name) - 97 store_var 5 (_12) - 98 load_type 11 - 99 load_var 5 (_12) - 100 call 138 ntypeargs=1 (baml.String.from) - 101 store_var 4 (_11) - 102 load_const 12 ("streaming does not run the tool loop yet: ") - 103 load_var 4 (_11) - 104 bin_op + - 105 load_const 13 (" has a non-empty toolbox") - 106 bin_op + - 107 init_instance 3 (baml.errors.InvalidArgument .message) - 108 throw -} - -function ai.tools.Tool.call(self: ai.tools.Tool, args: map) -> string { - 26 0 load_var 1 (self) - 1 load_field 4 (raw_handler) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +65 (to 71) - - 29 7 load_var 1 (self) - 8 load_field 3 (handler) - 9 store_var 5 (_8) - 10 load_var 5 (_8) - 11 narrow_bind 1 5 - 12 pop_jump_if_false +2 (to 14) - 13 jump +13 (to 26) - - 37 14 load_type 2 - 15 load_var 1 (self) - 16 load_field 0 (name) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 14 (_34) - 19 load_const 3 ("tool ") - 20 load_var 14 (_34) - 21 bin_op + - 22 load_const 4 (" has no handler") - 23 bin_op + - 24 init_instance 0 (baml.errors.InvalidArgument .message) - 25 throw - - 29 26 load_var 5 (_8) - 27 store_var 6 (h) - - 30 28 load_type 5 - 29 load_type 5 - 30 load_var2 6 2 - 31 call 775 ntypeargs=2 (baml.reflect.call_any) - 32 store_var 7 (value) - 33 jump +33 (to 66) - 34 load_var 8 (e) - 35 store_var 9 (_15) - 36 load_var 9 (_15) - 37 narrow_bind 6 9 - 38 pop_jump_if_false +2 (to 40) - 39 jump +3 (to 42) - 40 load_var 8 (e) - 41 rethrow - 42 load_var 9 (_15) - 43 store_var 10 (bad) - - 32 44 load_type 2 - 45 load_var 1 (self) - 46 load_field 0 (name) - 47 call 138 ntypeargs=1 (baml.String.from) - 48 store_var 11 (_21) - 49 load_type 7 - 50 load_var 10 (bad) - 51 call 138 ntypeargs=1 (baml.String.from) - 52 store_var 13 (_25) - 53 load_type 2 - 54 load_var 13 (_25) - 55 call 138 ntypeargs=1 (baml.String.from) - 56 store_var 12 (_24) - 57 load_const 8 ("invalid arguments for ") - 58 load_var 11 (_21) - 59 bin_op + - 60 load_const 9 (": ") - 61 bin_op + - 62 load_var 12 (_24) - 63 bin_op + - 64 init_instance 1 (baml.errors.InvalidArgument .message) - 65 throw - - 35 66 load_type 5 - 67 load_var 7 (value) - 68 call 355 ntypeargs=1 (baml.json.to_json) - 69 call 351 ntypeargs=0 (baml.json.stringify) - 70 jump +5 (to 75) - - 26 71 load_var 3 (_4) - 72 store_var 4 (rh) - - 27 73 load_var2 2 4 - 74 call_indirect - 75 return -} - -function ai.tools.Toolbox.get(self: ai.tools.Toolbox, name: string) -> ai.tools.Tool | null { - 0 load_var 2 - 1 make_cell - 2 store_var 2 - - 112 3 load_type 0 - 4 load_type 1 - 5 load_var 1 (self) - 6 load_field 0 (entries) - 7 load_var 2 (name) - 8 make_closure 2135 1 - 9 call 19 ntypeargs=2 (baml.Array.find) - 10 return -} - -function ai.tools.Toolbox.is_empty(self: ai.tools.Toolbox) -> bool { - 118 0 load_var 1 (self) - 1 load_field 0 (entries) - 2 container_len - 3 store_var 3 (_2) - 4 load_var 3 (_2) - 5 load_const 0 (0) - 6 cmp_int_op == - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function ai.tools.Toolbox.list(self: ai.tools.Toolbox) -> ai.tools.Tool[] { - 108 0 load_var 1 (self) - 1 load_field 0 (entries) - 2 return -} - -function ai.tools.Toolbox.new(tools: ai.tools.Tool[]) -> ai.tools.Toolbox { - 97 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (names) - - 98 3 load_var 1 (tools) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +25 (to 41) - 17 load_var 5 (_4) - 18 store_var 6 (t) - - 99 19 load_type 0 - 20 load_var2 3 6 - 21 load_field 0 (name) - 22 call 23 ntypeargs=1 (baml.Array.includes) - 23 pop_jump_if_false +2 (to 25) - 24 jump +7 (to 31) - - 102 25 load_type 0 - 26 load_var2 3 6 - 27 load_field 0 (name) - 28 call 4 ntypeargs=1 (baml.Array.push) - 29 pop 1 - 30 jump -22 (to 8) - - 100 31 load_type 0 - 32 load_var 6 (t) - 33 load_field 0 (name) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 7 (_13) - 36 load_const 6 ("duplicate tool name: ") - 37 load_var 7 (_13) - 38 bin_op + - 39 init_instance 0 (baml.errors.InvalidArgument .message) - 40 throw - - 104 41 load_var 1 (tools) - 42 init_instance 1 (ai.tools.Toolbox .entries) - 43 store_var 2 (_0) - 44 load_var 2 (_0) - 45 return -} - -function ai.tools.raw_tool(name: string, description: string, input_schema: map, handler: (map) -> string throws unknown, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - 0 load_var 5 (on_error) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 77 4 load_const 1 (null) - 5 store_var 5 (on_error) - - 79 6 load_var 1 (name) - 7 load_const 2 ("__baml_return_output") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +7 (to 17) - - 82 11 load_var2 1 2 - 12 load_var 3 (input_schema) - 13 load_const 1 (null) - 14 load_var2 4 5 - 15 init_instance 0 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) - 16 return - - 80 17 load_const 3 ("the tool name __baml_return_output is reserved") - 18 init_instance 1 (baml.errors.InvalidArgument .message) - 19 throw -} - -function ai.tools.tool(handler: baml.AnyFunction, name: string | null, description: string | null, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - 0 load_var 2 (name) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 45 4 load_const 1 (null) - 5 store_var 2 (name) - 6 load_var 3 (description) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 46 10 load_const 1 (null) - 11 store_var 3 (description) - 12 load_var 4 (on_error) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 47 16 load_const 1 (null) - 17 store_var 4 (on_error) - - 49 18 load_var 1 (handler) - 19 call 774 ntypeargs=0 (baml.reflect.signature) - 20 store_var 5 (sig) - - 50 21 load_var 2 (name) - 22 store_var_load_var 7 (_10) - 23 load_const 1 (null) - 24 cmp_op == - 25 pop_jump_if_false +4 (to 29) - 26 load_var 5 (sig) - 27 load_field 0 (name) - 28 store_var 7 (_10) - 29 load_var 7 (_10) - 30 store_var 6 (resolved_name) - - 51 31 load_var 6 (resolved_name) - 32 store_var 8 (_12) - 33 load_var 8 (_12) - 34 narrow_bind 2 8 - 35 pop_jump_if_false +2 (to 37) - 36 jump +4 (to 40) - - 64 37 load_const 3 ("anonymous tool needs a name") - 38 init_instance 0 (baml.errors.InvalidArgument .message) - 39 throw - - 51 40 load_var 8 (_12) - 41 store_var_load_var 9 (n) - - 52 42 load_const 4 ("__baml_return_output") - 43 cmp_op == - 44 pop_jump_if_false +2 (to 46) - 45 jump +27 (to 72) - - 57 46 load_var 3 (description) - 47 store_var_load_var 12 (_21) - 48 load_const 1 (null) - 49 cmp_op == - 50 pop_jump_if_false +4 (to 54) - 51 load_var 5 (sig) - 52 load_field 5 (docstring) - 53 store_var 12 (_21) - 54 load_var 12 (_21) - 55 store_var_load_var 11 (_19) - 56 load_const 1 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 5 ("") - 60 store_var 11 (_19) - 61 load_var 11 (_19) - 62 store_var 10 (_18) - - 58 63 load_var 1 (handler) - 64 call 978 ntypeargs=0 (ai.internal._schema_for_signature) - 65 store_var 13 (_24) - - 56 66 load_var2 9 10 - 67 load_var2 13 1 - 68 load_const 1 (null) - 69 load_var 4 (on_error) - 70 init_instance 1 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) - 71 return - - 53 72 load_const 6 ("the tool name __baml_return_output is reserved") - 73 init_instance 2 (baml.errors.InvalidArgument .message) - 74 throw -} - -function ai.wire.credential_sources(cred: string | baml.env.Ref | null, canonical_env: string | null) -> string { - 66 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (names) - - 67 3 load_var 1 (cred) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +8 (to 15) - 8 load_var 4 (_4) - 9 store_var 5 (named) - - 68 10 load_type 0 - 11 load_var2 3 5 - 12 load_field 0 (name) - 13 call 4 ntypeargs=1 (baml.Array.push) - 14 pop 1 - - 70 15 load_var 2 (canonical_env) - 16 store_var 6 (_9) - 17 load_var 6 (_9) - 18 narrow_bind 2 6 - 19 pop_jump_if_false +7 (to 26) - 20 load_var 6 (_9) - 21 store_var 7 (canonical) - - 71 22 load_type 0 - 23 load_var2 3 7 - 24 call 4 ntypeargs=1 (baml.Array.push) - 25 pop 1 - - 73 26 load_var 3 (names) - 27 container_len - 28 store_var 8 (_15) - 29 load_var 8 (_15) - 30 load_const 3 (0) - 31 cmp_int_op == - 32 pop_jump_if_false +2 (to 34) - 33 jump +6 (to 39) - - 76 34 load_type 0 - 35 load_var 3 (names) - 36 load_const 4 (", ") - 37 call 15 ntypeargs=1 (baml.Array.join) - 38 jump +2 (to 40) - - 74 39 load_const 5 ("(no environment variable was named)") - 40 return -} - -function ai.wire.merge_request_body(base: baml.json.json, overrides: baml.json.json | null) -> baml.json.json { - 208 0 load_var 2 (overrides) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 210 5 load_var2 1 2 - 6 call 997 ntypeargs=0 (ai.internal._merge_json) - 7 jump +2 (to 9) - - 209 8 load_var 1 (base) - 9 return -} - -function ai.wire.redact_url_secrets(text: string) -> string { - 51 0 load_var 1 (text) - 1 load_const 0 ("key=") - 2 call 995 ntypeargs=0 (ai.internal._redact_after) - - 52 3 load_const 1 ("token=") - 4 call 995 ntypeargs=0 (ai.internal._redact_after) - - 53 5 load_const 2 ("secret=") - 6 call 995 ntypeargs=0 (ai.internal._redact_after) - 7 return -} - -function ai.wire.render_output_format(t: type) -> string { - 115 0 load_var 1 (t) - 1 call 1006 ntypeargs=0 (ai.internal.validate_output_type) - 2 pop 1 - - 116 3 load_var 1 (t) - 4 sys_op 1007 (ai.internal.render_output_format) - 5 return -} - -function ai.wire.resolve_credential(cred: string | baml.env.Ref | null, env_fallback: string | null) -> string | null { - 27 0 load_var 1 (cred) - 1 store_var 3 (_4) - 2 load_var 3 (_4) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +22 (to 27) - 6 load_var 1 (cred) - 7 store_var 5 (_7) - 8 load_var 5 (_7) - 9 narrow_bind 1 5 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 30 12 load_const 2 (null) - - 27 13 jump +17 (to 30) - 14 load_var 5 (_7) - 15 store_var 6 (named) - - 29 16 load_var 6 (named) - 17 call 228 ntypeargs=0 (baml.env.Ref.get) - 18 store_var_load_var 7 (_10) - 19 load_const 2 (null) - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - 22 load_const 3 ("") - 23 store_var 7 (_10) - 24 load_var 7 (_10) - 25 call 994 ntypeargs=0 (ai.internal._configured) - 26 jump +4 (to 30) - - 27 27 load_var 3 (_4) - 28 store_var_load_var 4 (literal) - - 28 29 call 994 ntypeargs=0 (ai.internal._configured) - - 32 30 store_var 8 (_13) - 31 load_var 8 (_13) - 32 narrow_bind 0 8 - 33 pop_jump_if_false +2 (to 35) - 34 jump +21 (to 55) - - 35 35 load_var 2 (env_fallback) - 36 store_var 10 (_15) - 37 load_var 10 (_15) - 38 narrow_bind 0 10 - 39 pop_jump_if_false +2 (to 41) - 40 jump +3 (to 43) - - 38 41 load_const 2 (null) - 42 jump +16 (to 58) - - 35 43 load_var 10 (_15) - 44 store_var_load_var 11 (fallback) - - 36 45 sys_op 226 (baml.env.get) - 46 store_var_load_var 12 (_18) - 47 load_const 2 (null) - 48 cmp_op == - 49 pop_jump_if_false +3 (to 52) - 50 load_const 4 ("") - 51 store_var 12 (_18) - 52 load_var 12 (_18) - 53 call 994 ntypeargs=0 (ai.internal._configured) - 54 jump +4 (to 58) - - 32 55 load_var 8 (_13) - 56 store_var 9 (value) - - 33 57 load_var 9 (value) - 58 return -} - -function ai.wire.resolve_media(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> ai.wire.ResolvedMedia { - 131 0 load_var 1 (media) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +133 (to 138) - 6 load_var 1 (media) - 7 store_var 12 (_18) - 8 load_var 12 (_18) - 9 narrow_bind 1 12 - 10 pop_jump_if_false +2 (to 12) - 11 jump +87 (to 98) - 12 load_var 1 (media) - 13 store_var 21 (_33) - 14 load_var 21 (_33) - 15 narrow_bind 2 21 - 16 pop_jump_if_false +2 (to 18) - 17 jump +41 (to 58) - 18 load_var 1 (media) - 19 store_var 30 (pdf) - - 163 20 load_var 30 (pdf) - 21 call 323 ntypeargs=0 (baml.media.Pdf.file) - 22 store_var_load_var 33 (_52) - 23 load_const 3 (null) - 24 cmp_op == - 25 pop_jump_if_false +4 (to 29) - 26 load_var 30 (pdf) - 27 call 322 ntypeargs=0 (baml.media.Pdf.url) - 28 store_var 33 (_52) - 29 load_var 33 (_52) - 30 store_var_load_var 32 (_50) - 31 load_const 3 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 4 ("") - 35 store_var 32 (_50) - 36 load_var 32 (_50) - 37 store_var 31 (source) - - 165 38 load_var 30 (pdf) - 39 call 322 ntypeargs=0 (baml.media.Pdf.url) - 40 store_var 34 (_56) - - 166 41 load_var 30 (pdf) - 42 call 323 ntypeargs=0 (baml.media.Pdf.file) - 43 store_var 35 (_57) - - 167 44 load_var 30 (pdf) - 45 call 324 ntypeargs=0 (baml.media.Pdf.base64) - 46 store_var 36 (_58) - - 168 47 load_var 30 (pdf) - 48 call 325 ntypeargs=0 (baml.media.Pdf.mime_type) - 49 load_var 31 (source) - 50 load_const 5 ("pdf") - 51 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 52 store_var 37 (_59) - - 164 53 load_var2 34 35 - 54 load_var2 36 37 - 55 load_var 2 (fetch_url) - 56 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 57 jump +120 (to 177) - - 131 58 load_var 21 (_33) - 59 store_var 22 (video) - - 153 60 load_var 22 (video) - 61 call 337 ntypeargs=0 (baml.media.Video.file) - 62 store_var_load_var 25 (_38) - 63 load_const 3 (null) - 64 cmp_op == - 65 pop_jump_if_false +4 (to 69) - 66 load_var 22 (video) - 67 call 336 ntypeargs=0 (baml.media.Video.url) - 68 store_var 25 (_38) - 69 load_var 25 (_38) - 70 store_var_load_var 24 (_36) - 71 load_const 3 (null) - 72 cmp_op == - 73 pop_jump_if_false +3 (to 76) - 74 load_const 6 ("") - 75 store_var 24 (_36) - 76 load_var 24 (_36) - 77 store_var 23 (source) - - 155 78 load_var 22 (video) - 79 call 336 ntypeargs=0 (baml.media.Video.url) - 80 store_var 26 (_42) - - 156 81 load_var 22 (video) - 82 call 337 ntypeargs=0 (baml.media.Video.file) - 83 store_var 27 (_43) - - 157 84 load_var 22 (video) - 85 call 338 ntypeargs=0 (baml.media.Video.base64) - 86 store_var 28 (_44) - - 158 87 load_var 22 (video) - 88 call 339 ntypeargs=0 (baml.media.Video.mime_type) - 89 load_var 23 (source) - 90 load_const 7 ("video") - 91 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 92 store_var 29 (_45) - - 154 93 load_var2 26 27 - 94 load_var2 28 29 - 95 load_var 2 (fetch_url) - 96 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 97 jump +80 (to 177) - - 131 98 load_var 12 (_18) - 99 store_var 13 (audio) - - 143 100 load_var 13 (audio) - 101 call 330 ntypeargs=0 (baml.media.Audio.file) - 102 store_var_load_var 16 (_23) - 103 load_const 3 (null) - 104 cmp_op == - 105 pop_jump_if_false +4 (to 109) - 106 load_var 13 (audio) - 107 call 329 ntypeargs=0 (baml.media.Audio.url) - 108 store_var 16 (_23) - 109 load_var 16 (_23) - 110 store_var_load_var 15 (_21) - 111 load_const 3 (null) - 112 cmp_op == - 113 pop_jump_if_false +3 (to 116) - 114 load_const 8 ("") - 115 store_var 15 (_21) - 116 load_var 15 (_21) - 117 store_var 14 (source) - - 145 118 load_var 13 (audio) - 119 call 329 ntypeargs=0 (baml.media.Audio.url) - 120 store_var 17 (_27) - - 146 121 load_var 13 (audio) - 122 call 330 ntypeargs=0 (baml.media.Audio.file) - 123 store_var 18 (_28) - - 147 124 load_var 13 (audio) - 125 call 331 ntypeargs=0 (baml.media.Audio.base64) - 126 store_var 19 (_29) - - 148 127 load_var 13 (audio) - 128 call 332 ntypeargs=0 (baml.media.Audio.mime_type) - 129 load_var 14 (source) - 130 load_const 9 ("audio") - 131 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 132 store_var 20 (_30) - - 144 133 load_var2 17 18 - 134 load_var2 19 20 - 135 load_var 2 (fetch_url) - 136 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 137 jump +40 (to 177) - - 131 138 load_var 3 (_3) - 139 store_var 4 (image) - - 133 140 load_var 4 (image) - 141 call 344 ntypeargs=0 (baml.media.Image.file) - 142 store_var_load_var 7 (_8) - 143 load_const 3 (null) - 144 cmp_op == - 145 pop_jump_if_false +4 (to 149) - 146 load_var 4 (image) - 147 call 343 ntypeargs=0 (baml.media.Image.url) - 148 store_var 7 (_8) - 149 load_var 7 (_8) - 150 store_var_load_var 6 (_6) - 151 load_const 3 (null) - 152 cmp_op == - 153 pop_jump_if_false +3 (to 156) - 154 load_const 10 ("") - 155 store_var 6 (_6) - 156 load_var 6 (_6) - 157 store_var 5 (source) - - 135 158 load_var 4 (image) - 159 call 343 ntypeargs=0 (baml.media.Image.url) - 160 store_var 8 (_12) - - 136 161 load_var 4 (image) - 162 call 344 ntypeargs=0 (baml.media.Image.file) - 163 store_var 9 (_13) - - 137 164 load_var 4 (image) - 165 call 345 ntypeargs=0 (baml.media.Image.base64) - 166 store_var 10 (_14) - - 138 167 load_var 4 (image) - 168 call 346 ntypeargs=0 (baml.media.Image.mime_type) - 169 load_var 5 (source) - 170 load_const 11 ("image") - 171 call 992 ntypeargs=0 (ai.internal._media_mime_type) - 172 store_var 11 (_15) - - 134 173 load_var2 8 9 - 174 load_var2 10 11 - 175 load_var 2 (fetch_url) - 176 call 993 ntypeargs=0 (ai.internal._resolve_media_content) - 177 return -} - -function ai.wire.sanitize_for_client(j: ai.Journal, client_id: string) -> ai.Journal { - 268 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 270 3 load_type 1 - 4 alloc_array 0 - 5 store_var 5 (pending) - - 271 6 load_var 1 (j) - 7 call 905 ntypeargs=0 (ai.Journal.entries) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 6 (_6) - 12 load_var 6 (_6) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 7 (_7) - 17 load_var 7 (_7) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +120 (to 140) - 21 load_var 7 (_7) - 22 store_var 8 (event) - - 272 23 load_var 8 (event) - 24 store_var 9 (_11) - 25 load_var 9 (_11) - 26 narrow_bind 7 9 - 27 pop_jump_if_false +2 (to 29) - 28 jump +56 (to 84) - 29 load_var 8 (event) - 30 store_var 18 (_38) - 31 load_var 18 (_38) - 32 narrow_bind 8 18 - 33 pop_jump_if_false +2 (to 35) - 34 jump +40 (to 74) - 35 load_var 8 (event) - 36 store_var 20 (_46) - 37 load_var 20 (_46) - 38 narrow_bind 9 20 - 39 pop_jump_if_false +2 (to 41) - 40 jump +23 (to 63) - 41 load_var 8 (event) - 42 store_var 22 (_54) - 43 load_var 22 (_54) - 44 narrow_bind 10 22 - 45 pop_jump_if_false +2 (to 47) - 46 jump +6 (to 52) - - 310 47 load_type 0 - 48 load_var2 4 8 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -39 (to 12) - - 272 52 load_var 22 (_54) - 53 store_var 23 (failed) - - 305 54 load_var2 5 23 - 55 load_field 0 (id) - 56 call 1000 ntypeargs=0 (ai.internal._resolve_pending_call) - 57 pop 1 - - 306 58 load_type 0 - 59 load_var2 4 23 - 60 call 4 ntypeargs=1 (baml.Array.push) - 61 pop 1 - 62 jump -50 (to 12) - - 272 63 load_var 20 (_46) - 64 store_var 21 (completed) - - 300 65 load_var2 5 21 - 66 load_field 0 (id) - 67 call 1000 ntypeargs=0 (ai.internal._resolve_pending_call) - 68 pop 1 - - 301 69 load_type 0 - 70 load_var2 4 21 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -61 (to 12) - - 272 74 load_var 18 (_38) - 75 store_var 19 (user) - - 295 76 load_var2 4 5 - 77 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 78 pop 1 - - 296 79 load_type 0 - 80 load_var2 4 19 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -71 (to 12) - - 272 84 load_var 9 (_11) - 85 store_var 10 (assistant) - - 274 86 load_var2 4 5 - 87 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 88 pop 1 - - 275 89 load_var 10 (assistant) - 90 load_field 0 (content) - 91 load_var 10 (assistant) - 92 load_field 1 (client_id) - 93 load_var 2 (client_id) - 94 cmp_op == - 95 call 998 ntypeargs=0 (ai.internal._wire_blocks) - 96 store_var 11 (blocks) - - 276 97 load_var 11 (blocks) - 98 container_len - 99 store_var 12 (_21) - 100 load_var 12 (_21) - 101 load_const 11 (0) - 102 cmp_int_op > - 103 pop_jump_if_false -91 (to 12) - - 277 104 load_type 0 - 105 load_var2 4 11 - - 280 106 load_var 10 (assistant) - 107 load_field 1 (client_id) - 108 init_instance 0 (ai.events.AssistantMessage .content, .client_id) - - 277 109 call 4 ntypeargs=1 (baml.Array.push) - 110 pop 1 - - 283 111 load_var 11 (blocks) - 112 load_type 12 - 113 load_const 13 ("iter") - 114 virtual_call nargs=1 ntypeargs=0 - 115 store_var 13 (_28) - 116 load_var 13 (_28) - 117 load_type 14 - 118 load_const 15 ("next") - 119 virtual_call nargs=1 ntypeargs=0 - 120 store_var 14 (_29) - 121 load_var 14 (_29) - 122 is_type 6 - 123 pop_jump_if_false +2 (to 125) - 124 jump -112 (to 12) - 125 load_var 14 (_29) - 126 store_var 15 (block) - - 284 127 load_var 15 (block) - 128 store_var 16 (_33) - 129 load_var 16 (_33) - 130 narrow_bind 16 16 - 131 pop_jump_if_false -15 (to 116) - 132 load_var 16 (_33) - 133 store_var 17 (use) - - 285 134 load_type 1 - 135 load_var2 5 17 - 136 load_field 0 (id) - 137 call 4 ntypeargs=1 (baml.Array.push) - 138 pop 1 - 139 jump -23 (to 116) - - 315 140 load_var2 4 5 - 141 call 999 ntypeargs=0 (ai.internal._flush_orphaned_calls) - 142 pop 1 - - 316 143 load_var 4 (out) - 144 init_instance 1 (ai.Journal .log) - 145 store_var 3 (_0) - 146 load_var 3 (_0) - 147 return -} - -function ai.wire.send_as(req: baml.http.Request, provider: string) -> #0 { - 83 0 load_var 1 (req) - 1 load_const 0 () - 2 call 250 ntypeargs=0 (baml.http.send) - 3 store_var 3 (resp) - 4 jump +19 (to 23) - 5 load_var 4 (e) - 6 throw_if_panic - - 89 7 load_type 1 - 8 load_var 4 (e) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 call 929 ntypeargs=0 (ai.wire.redact_url_secrets) - 11 store_var 6 (_8) - 12 load_type 2 - 13 load_var 6 (_8) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 5 (_7) - - 85 16 load_var 2 (provider) - - 89 17 load_const 3 ("transport failed before a response arrived: ") - 18 load_var 5 (_7) - 19 bin_op + - 20 load_const 4 (null) - 21 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 22 throw - - 94 23 load_var 3 (resp) - 24 sys_op 238 (baml.http.Response.text) - 25 store_var 7 (text) - 26 jump +8 (to 34) - 27 load_var 8 (e) - 28 throw_if_panic - - 96 29 load_var 2 (provider) - 30 load_const 5 ("the response body could not be read completely") - 31 load_const 4 (null) - 32 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 33 throw - - 103 34 load_var 3 (resp) - 35 call 240 ntypeargs=0 (baml.http.Response.ok) - 36 unary_op ! - 37 pop_jump_if_false +2 (to 39) - 38 jump +11 (to 49) - - 107 39 load_type 6 - 40 load_var 7 (text) - 41 call 357 ntypeargs=1 (baml.json.from_string) - 42 jump +6 (to 48) - 43 load_var 9 (e) - 44 throw_if_panic - - 108 45 load_var2 2 7 - 46 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 47 throw - 48 return - - 105 49 load_var2 2 3 - 50 load_field 0 (status_code) - 51 load_var2 7 3 - 52 load_field 1 (headers) - 53 call 977 ntypeargs=0 (ai.errors.classify_http) - 54 throw -} - -function anthropic.AnthropicClient.ai.Client.id(self: anthropic.AnthropicClient) -> string { - 158 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("anthropic/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function anthropic.AnthropicClient.ai.Client.invoke(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 162 0 load_var2 1 2 - 1 call 1192 ntypeargs=0 (anthropic.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 163 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function anthropic.AnthropicClient.ai.stream.StreamingClient.invoke_stream(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 170 0 load_var2 1 2 - 1 call 1199 ntypeargs=0 (anthropic.internal.invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 171 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function anthropic.AnthropicClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, max_tokens: int, temperature: float | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, thinking: anthropic.ThinkingConfig | null, tool_choice: anthropic.ToolChoice | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> anthropic.AnthropicClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 103 4 load_const 1 ("claude-haiku-4-5") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 104 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 105 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (max_tokens) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 106 22 load_const 3 (8192) - 23 store_var 4 (max_tokens) - 24 load_var 5 (temperature) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 107 28 load_const 2 (null) - 29 store_var 5 (temperature) - 30 load_var 6 (top_p) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 108 34 load_const 2 (null) - 35 store_var 6 (top_p) - 36 load_var 7 (top_k) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 109 40 load_const 2 (null) - 41 store_var 7 (top_k) - 42 load_var 8 (stop_sequences) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 110 46 load_const 2 (null) - 47 store_var 8 (stop_sequences) - 48 load_var 9 (thinking) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 111 52 load_const 2 (null) - 53 store_var 9 (thinking) - 54 load_var 10 (tool_choice) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 112 58 load_const 2 (null) - 59 store_var 10 (tool_choice) - 60 load_var 11 (request_body) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 113 64 load_const 2 (null) - 65 store_var 11 (request_body) - 66 load_var 12 (headers) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 114 70 load_const 2 (null) - 71 store_var 12 (headers) - 72 load_var 13 (query_params) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 115 76 load_const 2 (null) - 77 store_var 13 (query_params) - - 117 78 load_var2 1 2 - 79 load_var2 3 4 - 80 load_var2 5 6 - 81 load_var2 7 8 - 82 load_var2 9 10 - 83 load_var2 11 12 - 84 load_var 13 (query_params) - 85 init_instance 0 (anthropic.AnthropicClient .model, .api_key, .base_url, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .headers, .query_params) - 86 return -} - -function anthropic.AnthropicClient.resolved_api_key(self: anthropic.AnthropicClient) -> string { - 143 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("ANTHROPIC_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +15 (to 23) - - 147 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("ANTHROPIC_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 3 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - 18 load_const 4 ("anthropic needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 19 load_var 4 (_8) - 20 bin_op + - - 146 21 call 1168 ntypeargs=0 (anthropic.internal._reject) - 22 throw - - 143 23 load_var 2 (_4) - 24 store_var 3 (k) - - 144 25 load_var 3 (k) - 26 return -} - -function anthropic.AnthropicClient.resolved_base_url(self: anthropic.AnthropicClient) -> string | null { - 153 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function anthropic.ThinkingConfig.disabled() -> anthropic.ThinkingConfig { - 23 0 load_const 0 ("disabled") - 1 store_var_load_var 2 (kind) - - 24 2 load_const 1 (null) - 3 init_instance 0 (anthropic.ThinkingConfig .type, .budget_tokens) - 4 store_var 1 (_0) - 5 load_var 1 (_0) - 6 return -} - -function anthropic.ThinkingConfig.enabled(budget_tokens: int) -> anthropic.ThinkingConfig { - 18 0 load_var 1 (budget_tokens) - 1 store_var 3 (budget) - - 19 2 load_const 0 ("enabled") - 3 load_var 3 (budget) - 4 init_instance 0 (anthropic.ThinkingConfig .type, .budget_tokens) - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function anthropic.ToolChoice.any(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 1 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 44 4 load_const 1 (null) - 5 store_var 1 (disable_parallel_tool_use) - - 45 6 load_var 1 (disable_parallel_tool_use) - 7 store_var 2 (parallel) - - 46 8 load_const 2 ("any") - 9 load_const 1 (null) - 10 load_var 2 (parallel) - 11 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 12 return -} - -function anthropic.ToolChoice.auto(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 1 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 38 4 load_const 1 (null) - 5 store_var 1 (disable_parallel_tool_use) - - 39 6 load_var 1 (disable_parallel_tool_use) - 7 store_var 2 (parallel) - - 40 8 load_const 2 ("auto") - 9 load_const 1 (null) - 10 load_var 2 (parallel) - 11 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 12 return -} - -function anthropic.ToolChoice.none() -> anthropic.ToolChoice { - 57 0 load_const 0 ("none") - 1 store_var_load_var 2 (kind) - - 58 2 load_const 1 (null) - 3 load_const 1 (null) - 4 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 5 store_var 1 (_0) - 6 load_var 1 (_0) - 7 return -} - -function anthropic.ToolChoice.tool(name: string, disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - 0 load_var 2 (disable_parallel_tool_use) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 50 4 load_const 1 (null) - 5 store_var 2 (disable_parallel_tool_use) - - 51 6 load_var 1 (name) - 7 store_var 3 (chosen) - - 52 8 load_const 2 ("tool") - 9 load_var2 3 2 - 10 init_instance 0 (anthropic.ToolChoice .type, .name, .disable_parallel_tool_use) - 11 return -} - -function anthropic.internal.AnthStreamState.new() -> anthropic.internal.AnthStreamState { - 958 0 load_const 0 ("") - 1 load_const 1 ("") - - 961 2 load_type 2 - 3 alloc_array 0 - 4 load_const 3 (null) - 5 load_const 3 (null) - 6 load_const 3 (null) - 7 load_const 3 (null) - 8 load_const 3 (null) - 9 init_instance 0 (anthropic.internal.AnthStreamState .thinking, .signature, .tool_calls, .cache_read_input_tokens, .cache_creation_input_tokens, .reasoning_tokens, .stop_reason_raw, .model) - 10 store_var 1 (_0) - 11 load_var 1 (_0) - 12 return -} - -function anthropic.internal.AnthStreamState.tool_uses(self: anthropic.internal.AnthStreamState) -> ai.content.ToolUse[] { - 974 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 975 3 load_var 1 (self) - 4 load_field 2 (tool_calls) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +37 (to 54) - 18 load_var 5 (_5) - 19 store_var 6 (call) - - 976 20 load_type 6 - 21 load_type 7 - 22 alloc_map 0 - 23 store_var 7 (empty) - - 977 24 load_var 6 (call) - 25 load_field 3 (args_json) - 26 call 144 ntypeargs=0 (baml.String.trim) - 27 load_const 8 ("") - 28 cmp_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +12 (to 42) - - 980 31 load_type 9 - 32 load_var 6 (call) - 33 load_field 3 (args_json) - 34 call 357 ntypeargs=1 (baml.json.from_string) - 35 store_var 8 (args) - 36 jump +8 (to 44) - 37 load_var 9 (e) - 38 throw_if_panic - - 981 39 load_var 7 (empty) - 40 store_var 8 (args) - - 980 41 jump +3 (to 44) - - 978 42 load_var 7 (empty) - 43 store_var 8 (args) - - 984 44 load_type 0 - 45 load_var2 3 6 - 46 load_field 1 (id) - 47 load_var 6 (call) - 48 load_field 2 (name) - 49 load_var 8 (args) - 50 init_instance 0 (ai.content.ToolUse .id, .name, .args) - 51 call 4 ntypeargs=1 (baml.Array.push) - 52 pop 1 - 53 jump -44 (to 9) - - 986 54 load_var 3 (out) - 55 store_var 2 (_0) - 56 load_var 2 (_0) - 57 return -} - -function anthropic.internal._anth_apply_cache_control(blocks: (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[], cache_control: baml.json.json | null) -> void { - 269 0 load_var 2 (cache_control) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +64 (to 68) - - 272 5 load_var 1 (blocks) - 6 container_len - 7 store_var 4 (_6) - 8 load_type 1 - 9 load_var2 1 4 - 10 load_const 2 (1) - 11 sub_int - 12 call 3 ntypeargs=1 (baml.Array.at) - 13 store_var 5 (_8) - 14 load_var 5 (_8) - 15 narrow_bind 3 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +12 (to 29) - 18 load_var 5 (_8) - 19 narrow_bind 4 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +8 (to 29) - 22 load_var 5 (_8) - 23 narrow_bind 5 5 - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - 26 load_var 5 (_8) - 27 narrow_bind 6 5 - 28 pop_jump_if_false +40 (to 68) - 29 load_var 5 (_8) - 30 store_var 6 (last) - - 273 31 load_var 6 (last) - 32 store_var 7 (_10) - 33 load_var 7 (_10) - 34 narrow_bind 3 7 - 35 pop_jump_if_false +2 (to 37) - 36 jump +28 (to 64) - 37 load_var 6 (last) - 38 store_var 9 (_12) - 39 load_var 9 (_12) - 40 narrow_bind 4 9 - 41 pop_jump_if_false +2 (to 43) - 42 jump +17 (to 59) - 43 load_var 6 (last) - 44 store_var 11 (_14) - 45 load_var 11 (_14) - 46 narrow_bind 5 11 - 47 pop_jump_if_false +2 (to 49) - 48 jump +6 (to 54) - 49 load_var 6 (last) - 50 store_var 13 (result) - - 284 51 load_var2 13 2 - 52 store_field 4 (cache_control) - - 273 53 jump +15 (to 68) - 54 load_var 11 (_14) - 55 store_var 12 (use) - - 281 56 load_var2 12 2 - 57 store_field 4 (cache_control) - - 273 58 jump +10 (to 68) - 59 load_var 9 (_12) - 60 store_var 10 (media) - - 278 61 load_var2 10 2 - 62 store_field 2 (cache_control) - - 273 63 jump +5 (to 68) - 64 load_var 7 (_10) - 65 store_var 8 (text) - - 275 66 load_var2 8 2 - 67 store_field 2 (cache_control) - - 268 68 load_const 0 (null) - 69 store_var 3 (_0) - 70 load_var 3 (_0) - 71 return -} - -function anthropic.internal._anth_drop_nulls(j: baml.json.json) -> baml.json.json { - 214 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +39 (to 44) - 6 load_var 1 (j) - 7 store_var 10 (_27) - 8 load_var 10 (_27) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 241 12 load_var 1 (j) - - 214 13 jump +84 (to 97) - 14 load_var 10 (_27) - 15 store_var 11 (arr) - - 235 16 load_type 2 - 17 alloc_array 0 - 18 store_var 12 (out) - - 236 19 load_var 11 (arr) - 20 load_type 3 - 21 load_const 4 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 13 (_31) - 24 load_var 13 (_31) - 25 load_type 5 - 26 load_const 6 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 14 (_32) - 29 load_var 14 (_32) - 30 is_type 7 - 31 pop_jump_if_false +2 (to 33) - 32 jump +10 (to 42) - 33 load_var 14 (_32) - 34 store_var_load_var 15 (element) - - 237 35 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - 36 store_var 16 (_37) - 37 load_type 2 - 38 load_var2 12 16 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -17 (to 24) - - 239 42 load_var 12 (out) - - 214 43 jump +54 (to 97) - 44 load_var 2 (_2) - 45 store_var 3 (obj) - - 216 46 load_type 8 - 47 load_type 2 - 48 alloc_map 0 - 49 store_var 4 (out) - - 217 50 load_type 8 - 51 load_type 2 - 52 load_var 3 (obj) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 9 - 55 load_const 10 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 5 (_8) - 58 load_var 5 (_8) - 59 load_type 11 - 60 load_const 12 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 6 (_9) - 63 load_var 6 (_9) - 64 is_type 7 - 65 pop_jump_if_false +2 (to 67) - 66 jump +30 (to 96) - 67 load_var 6 (_9) - 68 store_var 7 (key) - - 218 69 load_type 8 - 70 load_type 2 - 71 load_var2 3 7 - 72 call 38 ntypeargs=2 (baml.Map.get) - 73 store_var 8 (value) - - 219 74 load_var 8 (value) - 75 load_const 13 (null) - 76 cmp_op == - 77 pop_jump_if_false +2 (to 79) - 78 jump -20 (to 58) - - 222 79 load_var 7 (key) - 80 call 1169 ntypeargs=0 (anthropic.internal._anth_verbatim_subtree) - 81 pop_jump_if_false +2 (to 83) - 82 jump +5 (to 87) - - 225 83 load_var 8 (value) - 84 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - 85 store_var 9 (kept) - 86 jump +3 (to 89) - - 223 87 load_var 8 (value) - 88 store_var 9 (kept) - - 227 89 load_type 8 - 90 load_type 2 - 91 load_var2 4 7 - 92 load_var 9 (kept) - 93 call 37 ntypeargs=2 (baml.Map.set) - 94 pop 1 - 95 jump -37 (to 58) - - 232 96 load_var 4 (out) - 97 return -} - -function anthropic.internal._anth_stream_call_at(state: anthropic.internal.AnthStreamState, index: int | null) -> anthropic.internal.AnthStreamToolCall | null { - 991 0 load_var 2 (index) - 1 store_var_load_var 4 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +4 (to 8) - 5 load_const 1 (1) - 6 unary_op - - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 store_var 3 (wanted) - - 992 10 load_var 1 (state) - 11 load_field 2 (tool_calls) - 12 load_type 2 - 13 load_const 3 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 5 (_7) - 16 load_var 5 (_7) - 17 load_type 4 - 18 load_const 5 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 6 (_8) - 21 load_var 6 (_8) - 22 is_type 6 - 23 pop_jump_if_false +2 (to 25) - 24 jump +9 (to 33) - 25 load_var 6 (_8) - 26 store_var_load_var 7 (call) - - 993 27 load_field 0 (index) - 28 load_var 3 (wanted) - 29 cmp_int_op == - 30 pop_jump_if_false -14 (to 16) - - 994 31 load_var 7 (call) - 32 jump +2 (to 34) - - 997 33 load_const 0 (null) - 34 return -} - -function anthropic.internal._anth_stream_failure(error: anthropic.internal.AnthStreamError | null, raw: string) -> ai.errors.Failure { - 1005 0 load_var 1 (error) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - 5 load_var 1 (error) - 6 load_field 0 (0) - 7 jump +2 (to 9) - 8 load_const 0 (null) - 9 store_var_load_var 4 (_4) - 10 load_const 0 (null) - 11 cmp_op == - 12 pop_jump_if_false +3 (to 15) - 13 load_const 1 ("") - 14 store_var 4 (_4) - 15 load_var 4 (_4) - 16 store_var 3 (kind) - - 1006 17 load_var 1 (error) - 18 load_const 0 (null) - 19 cmp_op == - 20 pop_jump_if_false +2 (to 22) - 21 jump +4 (to 25) - 22 load_var 1 (error) - 23 load_field 1 (1) - 24 jump +2 (to 26) - 25 load_const 0 (null) - 26 store_var_load_var 6 (_10) - 27 load_const 0 (null) - 28 cmp_op == - 29 pop_jump_if_false +3 (to 32) - 30 load_var 3 (kind) - 31 store_var 6 (_10) - 32 load_var 6 (_10) - 33 store_var 5 (detail) - - 1007 34 load_var 3 (kind) - 35 load_const 2 ("rate_limit_error") - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +85 (to 123) - 39 load_var 3 (kind) - 40 load_const 3 ("overloaded_error") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +63 (to 106) - 44 load_var 3 (kind) - 45 load_const 4 ("api_error") - 46 cmp_op == - 47 pop_jump_if_false +2 (to 49) - 48 jump +41 (to 89) - 49 load_var 3 (kind) - 50 load_const 5 ("timeout_error") - 51 cmp_op == - 52 pop_jump_if_false +2 (to 54) - 53 jump +19 (to 72) - - 1023 54 load_type 6 - 55 load_var 3 (kind) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 13 (_45) - 58 load_type 6 - 59 load_var 5 (detail) - 60 call 138 ntypeargs=1 (baml.String.from) - 61 store_var 14 (_48) - - 1020 62 load_const 7 ("anthropic") - 63 load_const 0 (null) - - 1023 64 load_var 13 (_45) - 65 load_const 8 (": ") - 66 bin_op + - 67 load_var 14 (_48) - 68 bin_op + - 69 load_var 2 (raw) - 70 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 1007 71 jump +56 (to 127) - - 1015 72 load_type 9 - 73 load_var 3 (kind) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 11 (_37) - 76 load_type 6 - 77 load_var 5 (detail) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 12 (_40) - - 1013 80 load_const 10 ("anthropic") - - 1015 81 load_var 11 (_37) - 82 load_const 11 (": ") - 83 bin_op + - 84 load_var 12 (_40) - 85 bin_op + - 86 load_var 2 (raw) - 87 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 88 jump +39 (to 127) - - 1015 89 load_type 9 - 90 load_var 3 (kind) - 91 call 138 ntypeargs=1 (baml.String.from) - 92 store_var 9 (_28) - 93 load_type 6 - 94 load_var 5 (detail) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 10 (_31) - - 1013 97 load_const 12 ("anthropic") - - 1015 98 load_var 9 (_28) - 99 load_const 13 (": ") - 100 bin_op + - 101 load_var 10 (_31) - 102 bin_op + - 103 load_var 2 (raw) - 104 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 105 jump +22 (to 127) - - 1015 106 load_type 9 - 107 load_var 3 (kind) - 108 call 138 ntypeargs=1 (baml.String.from) - 109 store_var 7 (_19) - 110 load_type 6 - 111 load_var 5 (detail) - 112 call 138 ntypeargs=1 (baml.String.from) - 113 store_var 8 (_22) - - 1013 114 load_const 14 ("anthropic") - - 1015 115 load_var 7 (_19) - 116 load_const 15 (": ") - 117 bin_op + - 118 load_var 8 (_22) - 119 bin_op + - 120 load_var 2 (raw) - 121 init_instance 3 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 1007 122 jump +5 (to 127) - - 1008 123 load_const 16 ("anthropic") - 124 load_const 0 (null) - 125 load_var 2 (raw) - 126 init_instance 4 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 127 return -} - -function anthropic.internal._anth_supported_image_mime(mime: string) -> bool { - 303 0 load_var 1 (mime) - 1 call 142 ntypeargs=0 (baml.String.to_lower_case) - 2 store_var 2 (m) - - 304 3 load_var 2 (m) - 4 load_const 0 ("image/jpeg") - 5 cmp_op == - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_var 2 (m) - 10 load_const 1 ("image/png") - 11 cmp_op == - 12 jump_if_false +2 (to 14) - 13 jump +5 (to 18) - 14 pop 1 - 15 load_var 2 (m) - 16 load_const 2 ("image/gif") - 17 cmp_op == - 18 jump_if_false +2 (to 20) - 19 jump +5 (to 24) - 20 pop 1 - 21 load_var 2 (m) - 22 load_const 3 ("image/webp") - 23 cmp_op == - 24 return -} - -function anthropic.internal._anth_verbatim_subtree(key: string) -> bool { - 210 0 load_var 1 (key) - 1 load_const 0 ("input") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("input_schema") - 8 cmp_op == - 9 return -} - -function anthropic.internal._anthropic_assistant_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - 417 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 418 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +61 (to 77) - 17 load_var 5 (_4) - 18 store_var 6 (b) - - 419 19 load_var 6 (b) - 20 store_var 7 (_8) - 21 load_var 7 (_8) - 22 narrow_bind 6 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +36 (to 60) - 25 load_var 6 (b) - 26 store_var 9 (_17) - 27 load_var 9 (_17) - 28 narrow_bind 7 9 - 29 pop_jump_if_false +2 (to 31) - 30 jump -22 (to 8) - 31 load_var 6 (b) - 32 store_var 10 (_18) - 33 load_var 10 (_18) - 34 narrow_bind 8 10 - 35 pop_jump_if_false +2 (to 37) - 36 jump -28 (to 8) - 37 load_var 6 (b) - 38 store_var 11 (u) - - 437 39 load_var 11 (u) - 40 load_field 0 (id) - 41 store_var 12 (_22) - - 438 42 load_var 11 (u) - 43 load_field 1 (name) - 44 store_var 13 (_23) - - 439 45 load_type 9 - 46 load_var 11 (u) - 47 load_field 2 (args) - 48 call 355 ntypeargs=1 (baml.json.to_json) - 49 store_var 14 (_24) - - 434 50 load_type 0 - 51 load_var 3 (out) - - 435 52 load_const 10 ("tool_use") - 53 load_var2 12 13 - 54 load_var 14 (_24) - 55 load_const 11 (null) - 56 init_instance 0 (anthropic.internal.AnthToolUseBlock .type, .id, .name, .input, .cache_control) - - 434 57 call 4 ntypeargs=1 (baml.Array.push) - 58 pop 1 - 59 jump -51 (to 8) - - 419 60 load_var 7 (_8) - 61 store_var_load_var 8 (t) - - 421 62 load_field 0 (text) - 63 call 144 ntypeargs=0 (baml.String.trim) - 64 load_const 12 ("") - 65 cmp_op != - 66 pop_jump_if_false -58 (to 8) - - 422 67 load_type 0 - 68 load_var 3 (out) - 69 load_const 13 ("text") - 70 load_var 8 (t) - 71 load_field 0 (text) - 72 load_const 11 (null) - 73 init_instance 1 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 74 call 4 ntypeargs=1 (baml.Array.push) - 75 pop 1 - 76 jump -68 (to 8) - - 447 77 load_var 3 (out) - 78 store_var 2 (_0) - 79 load_var 2 (_0) - 80 return -} - -function anthropic.internal._anthropic_body_params(c: anthropic.AnthropicClient) -> anthropic.internal.AnthropicBodyParams { - 572 0 load_var 1 (c) - 1 load_field 0 (model) - 2 store_var 3 (_2) - - 573 3 load_var 1 (c) - 4 load_field 3 (max_tokens) - 5 store_var 4 (_3) - - 574 6 load_var 1 (c) - 7 load_field 4 (temperature) - 8 store_var 5 (_4) - - 575 9 load_var 1 (c) - 10 load_field 5 (top_p) - 11 store_var 6 (_5) - - 576 12 load_var 1 (c) - 13 load_field 6 (top_k) - 14 store_var 7 (_6) - - 577 15 load_var 1 (c) - 16 load_field 7 (stop_sequences) - 17 store_var 8 (_7) - - 578 18 load_var 1 (c) - 19 load_field 8 (thinking) - 20 store_var 9 (_8) - - 579 21 load_var 1 (c) - 22 load_field 9 (tool_choice) - 23 store_var 10 (_9) - - 580 24 load_var 1 (c) - 25 load_field 10 (request_body) - 26 store_var 11 (_10) - - 581 27 load_var 1 (c) - 28 load_type 0 - 29 load_const 1 ("id") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 12 (_11) - - 571 32 load_var2 3 4 - 33 load_var2 5 6 - 34 load_var2 7 8 - 35 load_var2 9 10 - 36 load_var2 11 12 - 37 init_instance 0 (anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id) - 38 store_var 2 (_0) - 39 load_var 2 (_0) - 40 return -} - -function anthropic.internal._anthropic_headers(c: anthropic.AnthropicClient) -> map { - 755 0 load_const 0 ("2023-06-01") - 1 load_const 1 ("application/json") - 2 load_const 2 ("anthropic-version") - 3 load_const 3 ("content-type") - 4 load_type 4 - 5 load_type 4 - 6 alloc_map 2 - 7 store_var 3 (headers) - - 759 8 load_var 1 (c) - 9 load_field 11 (headers) - 10 store_var 4 (_4) - 11 load_var 4 (_4) - 12 narrow_bind 5 4 - 13 pop_jump_if_false +42 (to 55) - 14 load_var 4 (_4) - 15 store_var 5 (extra) - - 760 16 load_type 4 - 17 load_type 4 - 18 load_var 5 (extra) - 19 call 35 ntypeargs=2 (baml.Map.keys) - 20 load_type 6 - 21 load_const 7 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 6 (_9) - 24 load_var 6 (_9) - 25 load_type 8 - 26 load_const 9 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 7 (_10) - 29 load_var 7 (_10) - 30 is_type 10 - 31 pop_jump_if_false +2 (to 33) - 32 jump +23 (to 55) - 33 load_var 7 (_10) - 34 store_var 8 (key) - - 761 35 load_var 8 (key) - 36 call 142 ntypeargs=0 (baml.String.to_lower_case) - 37 store_var 9 (_15) - 38 load_type 4 - 39 load_type 4 - 40 load_var2 5 8 - 41 call 38 ntypeargs=2 (baml.Map.get) - 42 store_var_load_var 10 (_17) - 43 load_const 11 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 12 ("") - 47 store_var 10 (_17) - 48 load_type 4 - 49 load_type 4 - 50 load_var2 3 9 - 51 load_var 10 (_17) - 52 call 37 ntypeargs=2 (baml.Map.set) - 53 pop 1 - 54 jump -30 (to 24) - - 764 55 load_var 1 (c) - 56 call 1163 ntypeargs=0 (anthropic.AnthropicClient.resolved_api_key) - 57 store_var 11 (_26) - 58 load_type 4 - 59 load_type 4 - 60 load_var 3 (headers) - 61 load_const 13 ("x-api-key") - 62 load_var 11 (_26) - 63 call 37 ntypeargs=2 (baml.Map.set) - 64 pop 1 - - 765 65 load_var 3 (headers) - 66 store_var 2 (_0) - 67 load_var 2 (_0) - 68 return -} - -function anthropic.internal._anthropic_lower_journal(j: ai.Journal) -> anthropic.internal.AnthropicMessage[] { - 479 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (msgs) - - 480 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +84 (to 101) - 18 load_var 5 (_5) - 19 store_var 6 (e) - - 481 20 load_var 6 (e) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +59 (to 84) - 26 load_var 6 (e) - 27 store_var 9 (_17) - 28 load_var 9 (_17) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +32 (to 63) - 32 load_var 6 (e) - 33 store_var 13 (_27) - 34 load_var 13 (_27) - 35 narrow_bind 8 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +16 (to 53) - 38 load_var 6 (e) - 39 store_var 15 (_33) - 40 load_var 15 (_33) - 41 narrow_bind 9 15 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 15 (_33) - 44 store_var 16 (f) - - 515 45 load_var2 3 16 - 46 load_field 0 (id) - 47 load_var 16 (f) - 48 load_field 1 (message) - 49 load_const 10 (true) - 50 call 1177 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) - 51 pop 1 - 52 jump -43 (to 9) - - 481 53 load_var 13 (_27) - 54 store_var 14 (c) - - 512 55 load_var2 3 14 - 56 load_field 0 (id) - 57 load_var 14 (c) - 58 load_field 1 (output) - 59 load_const 11 (false) - 60 call 1177 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) - 61 pop 1 - 62 jump -53 (to 9) - - 481 63 load_var 9 (_17) - 64 store_var_load_var 10 (m) - - 495 65 load_field 0 (content) - 66 call 1176 ntypeargs=0 (anthropic.internal._anthropic_assistant_blocks) - 67 store_var 11 (blocks) - - 500 68 load_var 11 (blocks) - 69 container_len - 70 store_var 12 (_22) - 71 load_var 12 (_22) - 72 load_const 12 (0) - 73 cmp_int_op > - 74 pop_jump_if_false -65 (to 9) - - 501 75 load_type 0 - 76 load_var 3 (msgs) - - 502 77 load_const 13 ("assistant") - 78 load_const 11 (false) - - 505 79 load_var 11 (blocks) - 80 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 501 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -74 (to 9) - - 481 84 load_var 7 (_9) - 85 store_var 8 (m) - - 483 86 load_type 0 - 87 load_var 3 (msgs) - - 484 88 load_const 14 ("user") - 89 load_const 11 (false) - - 488 90 load_const 15 ("text") - 91 load_var 8 (m) - 92 load_field 0 (content) - 93 load_const 16 (null) - 94 init_instance 1 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 95 load_type 17 - 96 alloc_array 1 - 97 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 483 98 call 4 ntypeargs=1 (baml.Array.push) - 99 pop 1 - 100 jump -91 (to 9) - - 520 101 load_var 3 (msgs) - 102 store_var 2 (_0) - 103 load_var 2 (_0) - 104 return -} - -function anthropic.internal._anthropic_lower_prompt(prompt: ai.Prompt) -> anthropic.internal.AnthropicPrompt { - 379 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (system) - - 380 3 load_type 1 - 4 alloc_array 0 - 5 store_var 4 (messages) - - 381 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_5) - 12 load_var 5 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_6) - 17 load_var 6 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +76 (to 96) - 21 load_var 6 (_6) - 22 store_var 7 (message) - - 382 23 load_type 7 - 24 load_type 8 - 25 load_var 7 (message) - 26 load_field 3 (metadata) - 27 load_const 9 ("cache_control") - 28 call 38 ntypeargs=2 (baml.Map.get) - 29 store_var 8 (cache_control) - - 383 30 load_var 7 (message) - 31 load_field 0 (role) - 32 load_const 10 ("system") - 33 cmp_op == - 34 pop_jump_if_false +2 (to 36) - 35 jump +33 (to 68) - - 391 36 load_var 7 (message) - 37 load_field 0 (role) - 38 load_const 11 ("assistant") - 39 cmp_op == - 40 pop_jump_if_false +2 (to 42) - 41 jump +4 (to 45) - - 394 42 load_const 12 ("user") - 43 store_var 13 (role) - - 391 44 jump +3 (to 47) - - 392 45 load_const 13 ("assistant") - 46 store_var 13 (role) - - 396 47 load_var2 7 13 - 48 call 1174 ntypeargs=0 (anthropic.internal._anthropic_prompt_blocks) - 49 store_var 14 (blocks) - - 397 50 load_var2 14 8 - 51 call 1171 ntypeargs=0 (anthropic.internal._anth_apply_cache_control) - 52 pop 1 - - 400 53 load_var 14 (blocks) - 54 container_len - 55 store_var 15 (_40) - 56 load_var 15 (_40) - 57 load_const 14 (0) - 58 cmp_int_op > - 59 pop_jump_if_false -47 (to 12) - - 401 60 load_type 1 - 61 load_var2 4 13 - - 402 62 load_const 15 (false) - 63 load_var 14 (blocks) - 64 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - - 401 65 call 4 ntypeargs=1 (baml.Array.push) - 66 pop 1 - 67 jump -55 (to 12) - - 384 68 load_var 7 (message) - 69 load_const 16 ("system") - 70 call 1174 ntypeargs=0 (anthropic.internal._anthropic_prompt_blocks) - 71 store_var 9 (blocks) - - 385 72 load_var2 9 8 - 73 call 1171 ntypeargs=0 (anthropic.internal._anth_apply_cache_control) - 74 pop 1 - - 386 75 load_var 9 (blocks) - 76 load_type 17 - 77 load_const 18 ("iter") - 78 virtual_call nargs=1 ntypeargs=0 - 79 store_var 10 (_22) - 80 load_var 10 (_22) - 81 load_type 19 - 82 load_const 20 ("next") - 83 virtual_call nargs=1 ntypeargs=0 - 84 store_var 11 (_23) - 85 load_var 11 (_23) - 86 is_type 6 - 87 pop_jump_if_false +2 (to 89) - 88 jump -76 (to 12) - 89 load_var 11 (_23) - 90 store_var 12 (block) - - 387 91 load_type 0 - 92 load_var2 3 12 - 93 call 4 ntypeargs=1 (baml.Array.push) - 94 pop 1 - 95 jump -15 (to 80) - - 408 96 load_var2 3 4 - 97 init_instance 1 (anthropic.internal.AnthropicPrompt .system, .messages) - 98 store_var 2 (_0) - 99 load_var 2 (_0) - 100 return -} - -function anthropic.internal._anthropic_media_block(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, block_type: string) -> anthropic.internal.AnthMediaBlock { - 308 0 load_var 1 (media) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 3 (resolved) - - 309 4 load_var 3 (resolved) - 5 load_field 0 (url) - 6 store_var 5 (_6) - 7 load_var 5 (_6) - 8 narrow_bind 1 5 - 9 pop_jump_if_false +2 (to 11) - 10 jump +41 (to 51) - - 314 11 load_var 2 (block_type) - 12 load_const 2 ("image") - 13 cmp_op == - 14 jump_if_false +6 (to 20) - 15 pop 1 - 16 load_var 3 (resolved) - 17 load_field 2 (mime_type) - 18 call 1172 ntypeargs=0 (anthropic.internal._anth_supported_image_mime) - 19 unary_op ! - 20 pop_jump_if_false +2 (to 22) - 21 jump +18 (to 39) - - 321 22 load_var 3 (resolved) - 23 load_field 2 (mime_type) - 24 store_var 8 (_19) - - 322 25 load_var 3 (resolved) - 26 load_field 1 (base64) - 27 store_var_load_var 9 (_21) - 28 load_const 3 (null) - 29 cmp_op == - 30 pop_jump_if_false +3 (to 33) - 31 load_const 4 ("") - 32 store_var 9 (_21) - - 319 33 load_const 5 ("base64") - 34 load_var2 8 9 - - 322 35 load_const 3 (null) - 36 init_instance 0 (anthropic.internal.AnthSource .type, .media_type, .data, .url) - 37 store_var 4 (source) - - 309 38 jump +21 (to 59) - - 316 39 load_type 6 - 40 load_var 3 (resolved) - 41 load_field 2 (mime_type) - 42 call 138 ntypeargs=1 (baml.String.from) - 43 store_var 7 (_16) - 44 load_const 7 ("Anthropic does not accept ") - 45 load_var 7 (_16) - 46 bin_op + - 47 load_const 8 (" images: the Messages API supports image/jpeg, image/png, image/gif and image/webp") - 48 bin_op + - - 315 49 call 1168 ntypeargs=0 (anthropic.internal._reject) - 50 throw - - 309 51 load_var 5 (_6) - 52 store_var 6 (url) - - 312 53 load_const 9 ("url") - 54 load_const 3 (null) - 55 load_const 3 (null) - 56 load_var 6 (url) - 57 init_instance 1 (anthropic.internal.AnthSource .type, .media_type, .data, .url) - 58 store_var 4 (source) - - 326 59 load_var2 2 4 - 60 load_const 3 (null) - 61 init_instance 2 (anthropic.internal.AnthMediaBlock .type, .source, .cache_control) - 62 return -} - -function anthropic.internal._anthropic_prompt_blocks(message: ai.PromptMessage, role: string) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - 330 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (blocks) - - 331 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +99 (to 116) - 18 load_var 6 (_6) - 19 store_var 7 (part) - - 332 20 load_var 7 (part) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +75 (to 100) - 26 load_var 7 (part) - 27 store_var 10 (_18) - 28 load_var 10 (_18) - 29 narrow_bind 7 10 - 30 pop_jump_if_false +2 (to 32) - 31 jump +44 (to 75) - 32 load_var 7 (part) - 33 store_var 14 (_29) - 34 load_var 14 (_29) - 35 narrow_bind 8 14 - 36 pop_jump_if_false +2 (to 38) - 37 jump +35 (to 72) - 38 load_var 7 (part) - 39 store_var 15 (_31) - 40 load_var 15 (_31) - 41 narrow_bind 9 15 - 42 pop_jump_if_false +2 (to 44) - 43 jump +4 (to 47) - - 371 44 load_const 10 ("Anthropic does not support video prompt input") - 45 call 1168 ntypeargs=0 (anthropic.internal._reject) - 46 throw - - 332 47 load_var 15 (_31) - 48 store_var 16 (pdf) - - 362 49 load_var 2 (role) - 50 load_const 11 ("user") - 51 cmp_op != - 52 pop_jump_if_false +2 (to 54) - 53 jump +10 (to 63) - - 367 54 load_var 16 (pdf) - 55 load_const 12 ("document") - 56 call 1173 ntypeargs=0 (anthropic.internal._anthropic_media_block) - 57 store_var 18 (_39) - 58 load_type 0 - 59 load_var2 4 18 - 60 call 4 ntypeargs=1 (baml.Array.push) - 61 pop 1 - 62 jump -53 (to 9) - - 364 63 load_type 13 - 64 load_var 2 (role) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 17 (_36) - 67 load_const 14 ("Anthropic only supports PDF input in user messages, found ") - 68 load_var 17 (_36) - 69 bin_op + - - 363 70 call 1168 ntypeargs=0 (anthropic.internal._reject) - 71 throw - - 357 72 load_const 15 ("Anthropic does not support audio prompt input: the Messages API has no audio content block") - 73 call 1168 ntypeargs=0 (anthropic.internal._reject) - 74 throw - - 332 75 load_var 10 (_18) - 76 store_var 11 (image) - - 342 77 load_var 2 (role) - 78 load_const 16 ("user") - 79 cmp_op != - 80 pop_jump_if_false +2 (to 82) - 81 jump +10 (to 91) - - 347 82 load_var 11 (image) - 83 load_const 17 ("image") - 84 call 1173 ntypeargs=0 (anthropic.internal._anthropic_media_block) - 85 store_var 13 (_26) - 86 load_type 0 - 87 load_var2 4 13 - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 344 91 load_type 13 - 92 load_var 2 (role) - 93 call 138 ntypeargs=1 (baml.String.from) - 94 store_var 12 (_23) - 95 load_const 18 ("Anthropic only supports image input in user messages, found ") - 96 load_var 12 (_23) - 97 bin_op + - - 343 98 call 1168 ntypeargs=0 (anthropic.internal._reject) - 99 throw - - 332 100 load_var 8 (_10) - 101 store_var 9 (text) - - 336 102 load_var 9 (text) - 103 call 144 ntypeargs=0 (baml.String.trim) - 104 load_const 19 ("") - 105 cmp_op != - 106 pop_jump_if_false -97 (to 9) - - 337 107 load_type 0 - 108 load_var 4 (blocks) - 109 load_const 20 ("text") - 110 load_var 9 (text) - 111 load_const 21 (null) - 112 init_instance 0 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 113 call 4 ntypeargs=1 (baml.Array.push) - 114 pop 1 - 115 jump -106 (to 9) - - 375 116 load_var 4 (blocks) - 117 store_var 3 (_0) - 118 load_var 3 (_0) - 119 return -} - -function anthropic.internal._anthropic_push_tool_result(msgs: anthropic.internal.AnthropicMessage[], id: string, content: string, is_error: bool) -> void { - 457 0 load_const 0 ("tool_result") - 1 load_var2 2 3 - 2 load_var 4 (is_error) - 3 load_const 1 (null) - 4 init_instance 0 (anthropic.internal.AnthToolResultBlock .type, .tool_use_id, .content, .is_error, .cache_control) - 5 store_var 5 (block) - - 465 6 load_var 1 (msgs) - 7 container_len - 8 store_var 6 (_8) - 9 load_type 2 - 10 load_var2 1 6 - 11 load_const 3 (1) - 12 sub_int - 13 call 3 ntypeargs=1 (baml.Array.at) - 14 store_var 7 (_10) - 15 load_var 7 (_10) - 16 narrow_bind 4 7 - 17 pop_jump_if_false +2 (to 19) - 18 jump +13 (to 31) - - 472 19 load_type 2 - 20 load_var 1 (msgs) - 21 load_const 5 ("user") - 22 load_const 6 (true) - 23 load_var 5 (block) - 24 load_type 7 - 25 alloc_array 1 - 26 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 27 call 4 ntypeargs=1 (baml.Array.push) - 28 pop 1 - - 471 29 load_const 1 (null) - - 465 30 jump +25 (to 55) - 31 load_var 7 (_10) - 32 store_var_load_var 8 (m) - - 466 33 load_field 1 (tool_results) - 34 pop_jump_if_false +2 (to 36) - 35 jump +13 (to 48) - - 469 36 load_type 2 - 37 load_var 1 (msgs) - 38 load_const 8 ("user") - 39 load_const 6 (true) - 40 load_var 5 (block) - 41 load_type 7 - 42 alloc_array 1 - 43 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 44 call 4 ntypeargs=1 (baml.Array.push) - 45 pop 1 - - 468 46 load_const 1 (null) - - 466 47 jump +8 (to 55) - - 467 48 load_type 7 - 49 load_var 8 (m) - 50 load_field 2 (blocks) - 51 load_var 5 (block) - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - - 466 54 load_const 1 (null) - 55 return -} - -function anthropic.internal._anthropic_query_suffix(query_params: map | null) -> string { - 734 0 load_var 1 (query_params) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +75 (to 79) - 5 load_var 1 (query_params) - 6 store_var 2 (params) - - 737 7 load_type 1 - 8 alloc_array 0 - 9 store_var 3 (pairs) - - 738 10 load_type 1 - 11 load_type 1 - 12 load_var 2 (params) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 4 (_8) - 18 load_var 4 (_8) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 5 (_9) - 23 load_var 5 (_9) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +30 (to 56) - 27 load_var 5 (_9) - 28 store_var 6 (key) - - 739 29 load_type 1 - 30 load_var 6 (key) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 7 (_16) - 33 load_type 1 - 34 load_type 1 - 35 load_var2 2 6 - 36 call 38 ntypeargs=2 (baml.Map.get) - 37 store_var_load_var 9 (_21) - 38 load_const 0 (null) - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - 41 load_const 7 ("") - 42 store_var 9 (_21) - 43 load_type 1 - 44 load_var 9 (_21) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 8 (_19) - 47 load_type 1 - 48 load_var2 3 7 - 49 load_const 8 ("=") - 50 bin_op + - 51 load_var 8 (_19) - 52 bin_op + - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -37 (to 18) - - 741 56 load_var 3 (pairs) - 57 container_len - 58 store_var 10 (_30) - 59 load_var 10 (_30) - 60 load_const 9 (0) - 61 cmp_int_op > - 62 pop_jump_if_false +2 (to 64) - 63 jump +3 (to 66) - - 744 64 load_const 10 ("") - - 741 65 jump +15 (to 80) - - 742 66 load_type 1 - 67 load_var 3 (pairs) - 68 load_const 11 ("&") - 69 call 15 ntypeargs=1 (baml.Array.join) - 70 store_var 12 (_32) - 71 load_type 1 - 72 load_var 12 (_32) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 11 (_31) - 75 load_const 12 ("?") - 76 load_var 11 (_31) - 77 bin_op + - - 741 78 jump +2 (to 80) - - 735 79 load_const 13 ("") - 80 return -} - -function anthropic.internal._anthropic_render_messages(msgs: anthropic.internal.AnthropicMessage[]) -> anthropic.internal.AnthMessageParam[] { - 535 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 536 3 load_var 1 (msgs) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +64 (to 80) - 17 load_var 5 (_4) - 18 store_var 6 (m) - - 537 19 load_var 3 (out) - 20 container_len - 21 store_var 7 (_10) - 22 load_type 0 - 23 load_var2 3 7 - 24 load_const 6 (1) - 25 sub_int - 26 call 3 ntypeargs=1 (baml.Array.at) - 27 store_var 8 (_12) - 28 load_var 8 (_12) - 29 narrow_bind 7 8 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 8 (_12) - 32 store_var_load_var 9 (last) - - 538 33 load_field 0 (role) - 34 load_var 6 (m) - 35 load_field 0 (role) - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +18 (to 56) - - 545 39 load_var 6 (m) - 40 load_field 0 (role) - 41 store_var 13 (_29) - 42 load_type 8 - 43 load_var 6 (m) - 44 load_field 2 (blocks) - 45 load_type 8 - 46 alloc_array 0 - 47 call 7 ntypeargs=1 (baml.Array.concat) - 48 store_var 14 (_30) - 49 load_type 0 - 50 load_var2 3 13 - 51 load_var 14 (_30) - 52 init_instance 0 (anthropic.internal.AnthMessageParam .role, .content) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -47 (to 8) - - 539 56 load_var 6 (m) - 57 load_field 2 (blocks) - 58 load_type 9 - 59 load_const 10 ("iter") - 60 virtual_call nargs=1 ntypeargs=0 - 61 store_var 10 (_18) - 62 load_var 10 (_18) - 63 load_type 11 - 64 load_const 12 ("next") - 65 virtual_call nargs=1 ntypeargs=0 - 66 store_var 11 (_19) - 67 load_var 11 (_19) - 68 is_type 5 - 69 pop_jump_if_false +2 (to 71) - 70 jump -62 (to 8) - 71 load_var 11 (_19) - 72 store_var 12 (block) - - 540 73 load_type 8 - 74 load_var 9 (last) - 75 load_field 1 (content) - 76 load_var 12 (block) - 77 call 4 ntypeargs=1 (baml.Array.push) - 78 pop 1 - 79 jump -17 (to 62) - - 547 80 load_var 3 (out) - 81 store_var 2 (_0) - 82 load_var 2 (_0) - 83 return -} - -function anthropic.internal._anthropic_request(c: anthropic.AnthropicClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 775 0 load_var 1 (c) - 1 call 1164 ntypeargs=0 (anthropic.AnthropicClient.resolved_base_url) - 2 store_var_load_var 6 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("https://api.anthropic.com") - 7 store_var 6 (_5) - 8 load_var 6 (_5) - 9 store_var 5 (base) - - 778 10 load_type 2 - 11 load_var 5 (base) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 7 (_10) - 14 load_var 1 (c) - 15 load_field 12 (query_params) - 16 call 1186 ntypeargs=0 (anthropic.internal._anthropic_query_suffix) - 17 store_var 9 (_14) - 18 load_type 2 - 19 load_var 9 (_14) - 20 call 138 ntypeargs=1 (baml.String.from) - 21 store_var 8 (_13) - - 779 22 load_var 1 (c) - 23 call 1187 ntypeargs=0 (anthropic.internal._anthropic_headers) - 24 store_var 10 (_17) - - 780 25 load_var 1 (c) - 26 call 1180 ntypeargs=0 (anthropic.internal._anthropic_body_params) - 27 load_var2 2 3 - 28 call 1185 ntypeargs=0 (anthropic.internal.anthropic_messages_body) - 29 store_var 11 (_18) - - 776 30 load_const 3 ("POST") - - 778 31 load_var 7 (_10) - 32 load_const 4 ("/v1/messages") - 33 bin_op + - 34 load_var 8 (_13) - 35 bin_op + - 36 load_var2 10 11 - 37 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 38 store_var 4 (_0) - 39 load_var 4 (_0) - 40 return -} - -function anthropic.internal._anthropic_sse_failure(message: string) -> ai.errors.Failure { - 1194 0 load_const 0 ("SSE request failed with status ") - 1 store_var 2 (prefix) - - 1195 2 load_var2 1 2 - 3 call 148 ntypeargs=0 (baml.String.starts_with) - 4 pop_jump_if_false +36 (to 40) - - 1196 5 load_var 2 (prefix) - 6 call 139 ntypeargs=0 (baml.String.length) - 7 store_var 4 (_6) - 8 load_var 1 (message) - 9 call 139 ntypeargs=0 (baml.String.length) - 10 store_var 5 (_7) - 11 load_var2 1 4 - 12 load_var 5 (_7) - 13 call 153 ntypeargs=0 (baml.String.slice) - 14 store_var 3 (rest) - - 1197 15 load_var 3 (rest) - 16 load_const 1 (":") - 17 call 155 ntypeargs=0 (baml.String.index_of) - 18 store_var 6 (_9) - 19 load_var 6 (_9) - 20 narrow_bind 2 6 - 21 pop_jump_if_false +19 (to 40) - 22 load_var 6 (_9) - 23 store_var 7 (separator) - - 1198 24 load_var 3 (rest) - 25 load_const 2 (0) - 26 load_var 7 (separator) - 27 call 153 ntypeargs=0 (baml.String.slice) - 28 call 81 ntypeargs=0 (baml.Int.parse) - 29 store_var 8 (status) - 30 jump +5 (to 35) - 31 load_var 9 (e) - 32 throw_if_panic - - 1199 33 load_const 2 (0) - 34 store_var 8 (status) - - 1201 35 load_var 8 (status) - 36 load_const 2 (0) - 37 cmp_int_op > - 38 pop_jump_if_false +2 (to 40) - 39 jump +12 (to 51) - - 1212 40 load_type 3 - 41 load_var 1 (message) - 42 call 138 ntypeargs=1 (baml.String.from) - 43 store_var 14 (_24) - - 1210 44 load_const 4 ("anthropic") - - 1212 45 load_const 5 ("transport failed before a response arrived: ") - 46 load_var 14 (_24) - 47 bin_op + - 48 load_const 6 (null) - 49 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 50 jump +19 (to 69) - - 1204 51 load_var 8 (status) - 52 store_var 10 (_17) - - 1205 53 load_var 7 (separator) - 54 load_const 7 (1) - 55 add_int - 56 store_var 12 (_20) - 57 load_var 3 (rest) - 58 call 139 ntypeargs=0 (baml.String.length) - 59 store_var 13 (_22) - 60 load_var2 3 12 - 61 load_var 13 (_22) - 62 call 153 ntypeargs=0 (baml.String.slice) - 63 call 144 ntypeargs=0 (baml.String.trim) - 64 store_var 11 (_18) - - 1202 65 load_const 8 ("anthropic") - 66 load_var2 10 11 - 67 load_const 9 () - 68 call 977 ntypeargs=0 (ai.errors.classify_http) - 69 return -} - -function anthropic.internal._anthropic_stop_reason(s: string) -> ai.content.StopReason { - 797 0 load_var 1 (s) - 1 load_const 0 ("end_turn") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +28 (to 32) - 5 load_var 1 (s) - 6 load_const 1 ("stop_sequence") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +20 (to 29) - 10 load_var 1 (s) - 11 load_const 2 ("tool_use") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +12 (to 26) - 15 load_var 1 (s) - 16 load_const 3 ("refusal") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +4 (to 23) - - 802 20 load_const 4 (ai.content.StopReason.MaxTokens) - 21 alloc_variant 774 (ai.content.StopReason) - - 797 22 jump +12 (to 34) - - 800 23 load_const 5 (ai.content.StopReason.Refused) - 24 alloc_variant 774 (ai.content.StopReason) - - 797 25 jump +9 (to 34) - - 799 26 load_const 6 (ai.content.StopReason.ToolUse) - 27 alloc_variant 774 (ai.content.StopReason) - - 797 28 jump +6 (to 34) - - 798 29 load_const 7 (ai.content.StopReason.Complete) - 30 alloc_variant 774 (ai.content.StopReason) - - 797 31 jump +3 (to 34) - - 798 32 load_const 7 (ai.content.StopReason.Complete) - 33 alloc_variant 774 (ai.content.StopReason) - 34 return -} - -function anthropic.internal._anthropic_thinking_param(thinking: anthropic.ThinkingConfig | null) -> anthropic.internal.AnthThinkingParam | null { - 615 0 load_var 1 (thinking) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +8 (to 12) - 5 load_var 1 (thinking) - 6 store_var_load_var 2 (t) - - 618 7 load_field 0 (type) - 8 load_var 2 (t) - 9 load_field 1 (budget_tokens) - 10 init_instance 0 (anthropic.internal.AnthThinkingParam .type, .budget_tokens) - - 615 11 jump +2 (to 13) - - 616 12 load_const 0 (null) - 13 return -} - -function anthropic.internal._anthropic_tool_choice_param(choice: anthropic.ToolChoice | null) -> anthropic.internal.AnthToolChoiceParam { - 601 0 load_var 1 (choice) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +10 (to 14) - 5 load_var 1 (choice) - 6 store_var_load_var 2 (c) - - 606 7 load_field 0 (type) - - 607 8 load_var 2 (c) - 9 load_field 1 (name) - - 608 10 load_var 2 (c) - 11 load_field 2 (disable_parallel_tool_use) - 12 init_instance 0 (anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use) - - 601 13 jump +5 (to 18) - - 603 14 load_const 1 ("auto") - 15 load_const 0 (null) - 16 load_const 0 (null) - 17 init_instance 1 (anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use) - 18 return -} - -function anthropic.internal._anthropic_tool_params(toolbox: ai.tools.Toolbox) -> anthropic.internal.AnthToolParam[] { - 586 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 587 3 load_var 1 (toolbox) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +22 (to 39) - 18 load_var 5 (_5) - 19 store_var 6 (t) - - 590 20 load_var 6 (t) - 21 load_field 0 (name) - 22 store_var 7 (_11) - - 591 23 load_var 6 (t) - 24 load_field 1 (description) - 25 store_var 8 (_12) - - 592 26 load_type 6 - 27 load_var 6 (t) - 28 load_field 2 (input_schema) - 29 call 355 ntypeargs=1 (baml.json.to_json) - 30 store_var 9 (_13) - - 588 31 load_type 0 - 32 load_var2 3 7 - - 589 33 load_var2 8 9 - 34 load_const 7 (null) - 35 init_instance 0 (anthropic.internal.AnthToolParam .name, .description, .input_schema, .cache_control) - - 588 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - 38 jump -29 (to 9) - - 597 39 load_var 3 (out) - 40 store_var 2 (_0) - 41 load_var 2 (_0) - 42 return -} - -function anthropic.internal._reject(detail: string) -> ai.errors.InvalidRequest { - 31 0 load_const 0 ("anthropic") - 1 load_const 1 (null) - 2 load_var 1 (detail) - 3 load_const 1 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function anthropic.internal.anthropic_decode_batch(batch: string, state: anthropic.internal.AnthStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1032 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 1033 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +543 (to 560) - 18 load_var 6 (_6) - 19 store_var_load_var 7 (raw) - - 1034 20 load_field 1 (data) - 21 store_var 8 (_11) - 22 load_var 8 (_11) - 23 narrow_bind 6 8 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 8 (_11) - 26 store_var 9 (data) - - 1035 27 load_type 7 - 28 load_var 9 (data) - 29 call 357 ntypeargs=1 (baml.json.from_string) - 30 jump +4 (to 34) - 31 load_var 10 (e) - 32 throw_if_panic - - 1036 33 load_const 8 (null) - - 1038 34 store_var 11 (_17) - 35 load_var 11 (_17) - 36 narrow_bind 9 11 - 37 pop_jump_if_false -28 (to 9) - 38 load_var 11 (_17) - 39 store_var_load_var 12 (event) - - 1039 40 load_field 0 (type) - 41 store_var_load_var 15 (_22) - 42 load_const 8 (null) - 43 cmp_op == - 44 pop_jump_if_false +4 (to 48) - 45 load_var 7 (raw) - 46 load_field 0 (event) - 47 store_var 15 (_22) - 48 load_var 15 (_22) - 49 store_var_load_var 14 (_20) - 50 load_const 8 (null) - 51 cmp_op == - 52 pop_jump_if_false +3 (to 55) - 53 load_const 10 ("") - 54 store_var 14 (_20) - 55 load_var 14 (_20) - 56 store_var_load_var 13 (t) - - 1040 57 load_const 11 ("error") - 58 cmp_op == - 59 pop_jump_if_false +2 (to 61) - 60 jump +495 (to 555) - 61 load_var 13 (t) - 62 load_const 12 ("message_start") - 63 cmp_op == - 64 pop_jump_if_false +2 (to 66) - 65 jump +368 (to 433) - 66 load_var 13 (t) - 67 load_const 13 ("content_block_start") - 68 cmp_op == - 69 pop_jump_if_false +2 (to 71) - 70 jump +257 (to 327) - 71 load_var 13 (t) - 72 load_const 14 ("content_block_delta") - 73 cmp_op == - 74 pop_jump_if_false +2 (to 76) - 75 jump +128 (to 203) - 76 load_var 13 (t) - 77 load_const 15 ("message_delta") - 78 cmp_op == - 79 pop_jump_if_false +2 (to 81) - 80 jump +11 (to 91) - 81 load_var 13 (t) - 82 load_const 16 ("message_stop") - 83 cmp_op == - 84 pop_jump_if_false -75 (to 9) - - 1170 85 load_type 0 - 86 load_var 4 (out) - 87 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 1143 91 load_var 12 (event) - 92 load_field 5 (usage) - 93 store_var 57 (_169) - 94 load_var 57 (_169) - 95 narrow_bind 17 57 - 96 pop_jump_if_false +44 (to 140) - 97 load_var 57 (_169) - 98 store_var_load_var 58 (usage) - - 1145 99 load_field 2 (cache_read_input_tokens) - 100 store_var_load_var 59 (_171) - 101 load_const 8 (null) - 102 cmp_op == - 103 pop_jump_if_false +4 (to 107) - 104 load_var 2 (state) - 105 load_field 3 (cache_read_input_tokens) - 106 store_var 59 (_171) - 107 load_var2 2 59 - 108 store_field 3 (cache_read_input_tokens) - - 1147 109 load_var 58 (usage) - 110 load_field 3 (cache_creation_input_tokens) - 111 store_var_load_var 60 (_174) - - 1148 112 load_const 8 (null) - 113 cmp_op == - 114 pop_jump_if_false +4 (to 118) - 115 load_var 2 (state) - 116 load_field 4 (cache_creation_input_tokens) - 117 store_var 60 (_174) - - 1147 118 load_var2 2 60 - 119 store_field 4 (cache_creation_input_tokens) - - 1150 120 load_var 58 (usage) - 121 load_field 4 (output_tokens_details) - 122 load_const 8 (null) - 123 cmp_op == - 124 pop_jump_if_false +2 (to 126) - 125 jump +5 (to 130) - 126 load_var 58 (usage) - 127 load_field 4 (output_tokens_details) - 128 load_field 0 (0) - 129 jump +2 (to 131) - 130 load_const 8 (null) - 131 store_var_load_var 61 (_177) - 132 load_const 8 (null) - 133 cmp_op == - 134 pop_jump_if_false +4 (to 138) - - 1151 135 load_var 2 (state) - 136 load_field 5 (reasoning_tokens) - 137 store_var 61 (_177) - - 1150 138 load_var2 2 61 - 139 store_field 5 (reasoning_tokens) - - 1153 140 load_var 12 (event) - 141 load_field 2 (delta) - 142 load_const 8 (null) - 143 cmp_op == - 144 pop_jump_if_false +2 (to 146) - 145 jump +6 (to 151) - 146 load_var 12 (event) - 147 load_field 2 (delta) - 148 load_field 5 (5) - 149 store_var 63 (_184) - 150 jump +3 (to 153) - 151 load_const 8 (null) - 152 store_var 63 (_184) - 153 load_var 63 (_184) - 154 load_const 8 (null) - 155 cmp_op == - 156 pop_jump_if_false +2 (to 158) - 157 jump +9 (to 166) - 158 load_var 63 (_184) - 159 store_var 64 (s) - - 1156 160 load_var2 2 64 - 161 store_field 6 (stop_reason_raw) - - 1157 162 load_var 64 (s) - 163 call 1190 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) - 164 store_var 62 (stop) - 165 jump +3 (to 168) - - 1154 166 load_const 8 (null) - 167 store_var 62 (stop) - - 1162 168 load_var 62 (stop) - 169 store_var 65 (_193) - - 1163 170 load_var 12 (event) - 171 load_field 5 (usage) - 172 load_const 8 (null) - 173 cmp_op == - 174 pop_jump_if_false +2 (to 176) - 175 jump +6 (to 181) - 176 load_var 12 (event) - 177 load_field 5 (usage) - 178 load_field 0 (0) - 179 store_var 66 (_194) - 180 jump +3 (to 183) - 181 load_const 8 (null) - 182 store_var 66 (_194) - - 1164 183 load_var 12 (event) - 184 load_field 5 (usage) - 185 load_const 8 (null) - 186 cmp_op == - 187 pop_jump_if_false +2 (to 189) - 188 jump +6 (to 194) - 189 load_var 12 (event) - 190 load_field 5 (usage) - 191 load_field 1 (1) - 192 store_var 67 (_198) - 193 jump +3 (to 196) - 194 load_const 8 (null) - 195 store_var 67 (_198) - - 1160 196 load_type 0 - 197 load_var2 4 65 - - 1161 198 load_var2 66 67 - 199 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1160 200 call 4 ntypeargs=1 (baml.Array.push) - 201 pop 1 - 202 jump -193 (to 9) - - 1106 203 load_var 12 (event) - 204 load_field 2 (delta) - 205 store_var 40 (_119) - 206 load_var 40 (_119) - 207 narrow_bind 18 40 - 208 pop_jump_if_false -199 (to 9) - 209 load_var 40 (_119) - 210 store_var_load_var 41 (d) - - 1107 211 load_field 0 (type) - 212 store_var_load_var 43 (_122) - 213 load_const 8 (null) - 214 cmp_op == - 215 pop_jump_if_false +3 (to 218) - 216 load_const 19 ("") - 217 store_var 43 (_122) - 218 load_var 43 (_122) - 219 store_var_load_var 42 (kind) - - 1108 220 load_const 20 ("text_delta") - 221 cmp_op == - 222 pop_jump_if_false +2 (to 224) - 223 jump +90 (to 313) - 224 load_var 42 (kind) - 225 load_const 21 ("input_json_delta") - 226 cmp_op == - 227 pop_jump_if_false +2 (to 229) - 228 jump +54 (to 282) - 229 load_var 42 (kind) - 230 load_const 22 ("thinking_delta") - 231 cmp_op == - 232 pop_jump_if_false +2 (to 234) - 233 jump +27 (to 260) - 234 load_var 42 (kind) - 235 load_const 23 ("signature_delta") - 236 cmp_op == - 237 pop_jump_if_false -228 (to 9) - - 1131 238 load_type 24 - 239 load_var 2 (state) - 240 load_field 1 (signature) - 241 call 138 ntypeargs=1 (baml.String.from) - 242 store_var 54 (_158) - 243 load_var 41 (d) - 244 load_field 4 (signature) - 245 store_var_load_var 56 (_163) - 246 load_const 8 (null) - 247 cmp_op == - 248 pop_jump_if_false +3 (to 251) - 249 load_const 25 ("") - 250 store_var 56 (_163) - 251 load_type 24 - 252 load_var 56 (_163) - 253 call 138 ntypeargs=1 (baml.String.from) - 254 store_var 55 (_161) - 255 load_var2 2 54 - 256 load_var 55 (_161) - 257 bin_op + - 258 store_field 1 (signature) - - 1108 259 jump -250 (to 9) - - 1127 260 load_type 24 - 261 load_var 2 (state) - 262 load_field 0 (thinking) - 263 call 138 ntypeargs=1 (baml.String.from) - 264 store_var 51 (_148) - 265 load_var 41 (d) - 266 load_field 3 (thinking) - 267 store_var_load_var 53 (_153) - 268 load_const 8 (null) - 269 cmp_op == - 270 pop_jump_if_false +3 (to 273) - 271 load_const 26 ("") - 272 store_var 53 (_153) - 273 load_type 24 - 274 load_var 53 (_153) - 275 call 138 ntypeargs=1 (baml.String.from) - 276 store_var 52 (_151) - 277 load_var2 2 51 - 278 load_var 52 (_151) - 279 bin_op + - 280 store_field 0 (thinking) - - 1108 281 jump -272 (to 9) - - 1116 282 load_var2 2 12 - - 1118 283 load_field 1 (index) - - 1116 284 call 1195 ntypeargs=0 (anthropic.internal._anth_stream_call_at) - 285 store_var 46 (_136) - 286 load_var 46 (_136) - 287 narrow_bind 27 46 - 288 pop_jump_if_false -279 (to 9) - 289 load_var 46 (_136) - 290 store_var 47 (call) - - 1120 291 load_type 24 - 292 load_var 47 (call) - 293 load_field 3 (args_json) - 294 call 138 ntypeargs=1 (baml.String.from) - 295 store_var 48 (_138) - 296 load_var 41 (d) - 297 load_field 2 (partial_json) - 298 store_var_load_var 50 (_143) - 299 load_const 8 (null) - 300 cmp_op == - 301 pop_jump_if_false +3 (to 304) - 302 load_const 28 ("") - 303 store_var 50 (_143) - 304 load_type 24 - 305 load_var 50 (_143) - 306 call 138 ntypeargs=1 (baml.String.from) - 307 store_var 49 (_141) - 308 load_var2 47 48 - 309 load_var 49 (_141) - 310 bin_op + - 311 store_field 3 (args_json) - - 1116 312 jump -303 (to 9) - - 1110 313 load_var 41 (d) - 314 load_field 1 (text) - 315 store_var 44 (_127) - 316 load_var 44 (_127) - 317 narrow_bind 6 44 - 318 pop_jump_if_false -309 (to 9) - 319 load_var 44 (_127) - 320 store_var 45 (text) - - 1111 321 load_type 0 - 322 load_var2 4 45 - 323 init_instance 1 (ai.stream.TextDelta .text) - 324 call 4 ntypeargs=1 (baml.Array.push) - 325 pop 1 - 326 jump -317 (to 9) - - 1071 327 load_var 12 (event) - 328 load_field 3 (content_block) - 329 store_var 25 (_74) - 330 load_var 25 (_74) - 331 narrow_bind 29 25 - 332 pop_jump_if_false -323 (to 9) - 333 load_var 25 (_74) - 334 store_var_load_var 26 (block) - - 1072 335 load_field 0 (type) - 336 store_var_load_var 28 (_77) - 337 load_const 8 (null) - 338 cmp_op == - 339 pop_jump_if_false +3 (to 342) - 340 load_const 30 ("") - 341 store_var 28 (_77) - 342 load_var 28 (_77) - 343 store_var_load_var 27 (kind) - - 1073 344 load_const 31 ("tool_use") - 345 cmp_op == - 346 pop_jump_if_false +2 (to 348) - 347 jump +45 (to 392) - 348 load_var 27 (kind) - 349 load_const 32 ("thinking") - 350 cmp_op == - 351 pop_jump_if_false +2 (to 353) - 352 jump +18 (to 370) - - 1091 353 load_var 26 (block) - 354 load_field 3 (text) - 355 store_var 38 (_109) - 356 load_var 38 (_109) - 357 narrow_bind 6 38 - 358 pop_jump_if_false -349 (to 9) - 359 load_var 38 (_109) - 360 store_var_load_var 39 (text) - - 1092 361 load_const 33 ("") - 362 cmp_op != - 363 pop_jump_if_false -354 (to 9) - - 1093 364 load_type 0 - 365 load_var2 4 39 - 366 init_instance 2 (ai.stream.TextDelta .text) - 367 call 4 ntypeargs=1 (baml.Array.push) - 368 pop 1 - 369 jump -360 (to 9) - - 1086 370 load_type 24 - 371 load_var 2 (state) - 372 load_field 0 (thinking) - 373 call 138 ntypeargs=1 (baml.String.from) - 374 store_var 35 (_99) - 375 load_var 26 (block) - 376 load_field 4 (thinking) - 377 store_var_load_var 37 (_104) - 378 load_const 8 (null) - 379 cmp_op == - 380 pop_jump_if_false +3 (to 383) - 381 load_const 34 ("") - 382 store_var 37 (_104) - 383 load_type 24 - 384 load_var 37 (_104) - 385 call 138 ntypeargs=1 (baml.String.from) - 386 store_var 36 (_102) - 387 load_var2 2 35 - 388 load_var 36 (_102) - 389 bin_op + - 390 store_field 0 (thinking) - - 1073 391 jump -382 (to 9) - - 1075 392 load_var 2 (state) - 393 load_field 2 (tool_calls) - 394 store_var 29 (_82) - - 1077 395 load_var 12 (event) - 396 load_field 1 (index) - 397 store_var_load_var 31 (_85) - 398 load_const 8 (null) - 399 cmp_op == - 400 pop_jump_if_false +5 (to 405) - 401 load_var 2 (state) - 402 load_field 2 (tool_calls) - 403 container_len - 404 store_var 31 (_85) - 405 load_var 31 (_85) - 406 store_var 30 (_84) - - 1078 407 load_var 26 (block) - 408 load_field 1 (id) - 409 store_var_load_var 33 (_90) - 410 load_const 8 (null) - 411 cmp_op == - 412 pop_jump_if_false +3 (to 415) - 413 load_const 35 ("") - 414 store_var 33 (_90) - 415 load_var 33 (_90) - 416 store_var 32 (_89) - - 1079 417 load_var 26 (block) - 418 load_field 2 (name) - 419 store_var_load_var 34 (_94) - 420 load_const 8 (null) - 421 cmp_op == - 422 pop_jump_if_false +3 (to 425) - 423 load_const 36 ("") - 424 store_var 34 (_94) - - 1075 425 load_type 37 - 426 load_var2 29 30 - - 1076 427 load_var2 32 34 - - 1079 428 load_const 38 ("") - 429 init_instance 3 (anthropic.internal.AnthStreamToolCall .index, .id, .name, .args_json) - - 1075 430 call 4 ntypeargs=1 (baml.Array.push) - 431 pop 1 - 432 jump -423 (to 9) - - 1045 433 load_var 12 (event) - 434 load_field 4 (message) - 435 store_var 16 (_32) - 436 load_var 16 (_32) - 437 narrow_bind 39 16 - 438 pop_jump_if_false +55 (to 493) - 439 load_var 16 (_32) - 440 store_var 17 (message) - - 1046 441 load_var2 2 17 - 442 load_field 1 (model) - 443 store_field 7 (model) - - 1047 444 load_var 17 (message) - 445 load_field 3 (usage) - 446 store_var 18 (_35) - 447 load_var 18 (_35) - 448 narrow_bind 17 18 - 449 pop_jump_if_false +44 (to 493) - 450 load_var 18 (_35) - 451 store_var_load_var 19 (usage) - - 1049 452 load_field 2 (cache_read_input_tokens) - 453 store_var_load_var 20 (_37) - 454 load_const 8 (null) - 455 cmp_op == - 456 pop_jump_if_false +4 (to 460) - 457 load_var 2 (state) - 458 load_field 3 (cache_read_input_tokens) - 459 store_var 20 (_37) - 460 load_var2 2 20 - 461 store_field 3 (cache_read_input_tokens) - - 1051 462 load_var 19 (usage) - 463 load_field 3 (cache_creation_input_tokens) - 464 store_var_load_var 21 (_40) - - 1052 465 load_const 8 (null) - 466 cmp_op == - 467 pop_jump_if_false +4 (to 471) - 468 load_var 2 (state) - 469 load_field 4 (cache_creation_input_tokens) - 470 store_var 21 (_40) - - 1051 471 load_var2 2 21 - 472 store_field 4 (cache_creation_input_tokens) - - 1054 473 load_var 19 (usage) - 474 load_field 4 (output_tokens_details) - 475 load_const 8 (null) - 476 cmp_op == - 477 pop_jump_if_false +2 (to 479) - 478 jump +5 (to 483) - 479 load_var 19 (usage) - 480 load_field 4 (output_tokens_details) - 481 load_field 0 (0) - 482 jump +2 (to 484) - 483 load_const 8 (null) - 484 store_var_load_var 22 (_43) - 485 load_const 8 (null) - 486 cmp_op == - 487 pop_jump_if_false +4 (to 491) - - 1055 488 load_var 2 (state) - 489 load_field 5 (reasoning_tokens) - 490 store_var 22 (_43) - - 1054 491 load_var2 2 22 - 492 store_field 5 (reasoning_tokens) - - 1064 493 load_var 12 (event) - 494 load_field 4 (message) - 495 load_const 8 (null) - 496 cmp_op == - 497 pop_jump_if_false +2 (to 499) - 498 jump +20 (to 518) - 499 load_var 12 (event) - 500 load_field 4 (message) - 501 load_field 3 (3) - 502 load_const 8 (null) - 503 cmp_op == - 504 pop_jump_if_false +2 (to 506) - 505 jump +13 (to 518) - 506 load_var 12 (event) - 507 load_field 4 (message) - 508 load_const 8 (null) - 509 cmp_op == - 510 pop_jump_if_false +2 (to 512) - 511 jump +7 (to 518) - 512 load_var 12 (event) - 513 load_field 4 (message) - 514 load_field 3 (3) - 515 load_field 0 (0) - 516 store_var 23 (_51) - 517 jump +3 (to 520) - 518 load_const 8 (null) - 519 store_var 23 (_51) - - 1065 520 load_var 12 (event) - 521 load_field 4 (message) - 522 load_const 8 (null) - 523 cmp_op == - 524 pop_jump_if_false +2 (to 526) - 525 jump +20 (to 545) - 526 load_var 12 (event) - 527 load_field 4 (message) - 528 load_field 3 (3) - 529 load_const 8 (null) - 530 cmp_op == - 531 pop_jump_if_false +2 (to 533) - 532 jump +13 (to 545) - 533 load_var 12 (event) - 534 load_field 4 (message) - 535 load_const 8 (null) - 536 cmp_op == - 537 pop_jump_if_false +2 (to 539) - 538 jump +7 (to 545) - 539 load_var 12 (event) - 540 load_field 4 (message) - 541 load_field 3 (3) - 542 load_field 1 (1) - 543 store_var 24 (_61) - 544 jump +3 (to 547) - 545 load_const 8 (null) - 546 store_var 24 (_61) - - 1061 547 load_type 0 - 548 load_var 4 (out) - - 1062 549 load_const 8 (null) - 550 load_var2 23 24 - 551 init_instance 4 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1061 552 call 4 ntypeargs=1 (baml.Array.push) - 553 pop 1 - 554 jump -545 (to 9) - - 1042 555 load_var 12 (event) - 556 load_field 6 (error) - 557 load_var 9 (data) - 558 call 1196 ntypeargs=0 (anthropic.internal._anth_stream_failure) - 559 throw - - 1185 560 load_var 4 (out) - 561 store_var 3 (_0) - 562 load_var 3 (_0) - 563 return -} - -function anthropic.internal.anthropic_messages_body(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> string { - 723 0 load_var2 1 2 - 1 load_var 3 (stream) - 2 call 1184 ntypeargs=0 (anthropic.internal.anthropic_messages_request) - 3 store_var 4 (request) - - 724 4 load_type 0 - 5 load_var 4 (request) - 6 call 355 ntypeargs=1 (baml.json.to_json) - 7 call 1170 ntypeargs=0 (anthropic.internal._anth_drop_nulls) - - 725 8 load_var 1 (params) - 9 load_field 8 (request_body) - 10 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 11 call 351 ntypeargs=0 (baml.json.stringify) - 12 return -} - -function anthropic.internal.anthropic_messages_request(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> anthropic.internal.AnthropicMessagesRequest { - 630 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 4 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 4 (_5) - 7 call_indirect - - 631 8 call 1175 ntypeargs=0 (anthropic.internal._anthropic_lower_prompt) - 9 store_var 5 (lowered_prompt) - - 632 10 load_var 5 (lowered_prompt) - 11 load_field 0 (system) - 12 store_var 6 (system) - - 633 13 load_var 5 (lowered_prompt) - 14 load_field 1 (messages) - 15 store_var 7 (lowered) - - 637 16 load_var 2 (input) - 17 load_field 1 (journal) - 18 load_var 1 (params) - 19 load_field 9 (client_id) - 20 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 636 21 call 1178 ntypeargs=0 (anthropic.internal._anthropic_lower_journal) - 22 load_type 0 - 23 load_const 1 ("iter") - 24 virtual_call nargs=1 ntypeargs=0 - 25 store_var 8 (_16) - 26 load_var 8 (_16) - 27 load_type 2 - 28 load_const 3 ("next") - 29 virtual_call nargs=1 ntypeargs=0 - 30 store_var 9 (_17) - 31 load_var 9 (_17) - 32 is_type 4 - 33 pop_jump_if_false +2 (to 35) - 34 jump +8 (to 42) - 35 load_var 9 (_17) - 36 store_var 10 (message) - - 639 37 load_type 5 - 38 load_var2 7 10 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -15 (to 26) - - 645 42 load_type 5 - 43 load_var 7 (lowered) - 44 load_const 6 (0) - 45 call 3 ntypeargs=1 (baml.Array.at) - 46 load_const 7 (null) - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +7 (to 56) - 50 load_type 5 - 51 load_var 7 (lowered) - 52 load_const 6 (0) - 53 call 3 ntypeargs=1 (baml.Array.at) - 54 load_field 0 (0) - 55 jump +2 (to 57) - 56 load_const 7 (null) - 57 store_var_load_var 12 (_25) - 58 load_const 7 (null) - 59 cmp_op == - 60 pop_jump_if_false +3 (to 63) - 61 load_const 8 ("") - 62 store_var 12 (_25) - 63 load_var 12 (_25) - 64 store_var_load_var 11 (first_role) - - 649 65 load_const 9 ("user") - 66 cmp_op != - 67 jump_if_false +3 (to 70) - 68 pop 1 - 69 jump +3 (to 72) - 70 store_var 13 (promote_system) - 71 jump +8 (to 79) - 72 load_var 6 (system) - 73 container_len - 74 store_var 14 (_36) - 75 load_var 14 (_36) - 76 load_const 6 (0) - 77 cmp_int_op > - 78 store_var 13 (promote_system) - - 653 79 load_var 7 (lowered) - 80 container_len - 81 store_var 15 (_40) - 82 load_var 15 (_40) - 83 load_const 6 (0) - 84 cmp_int_op > - 85 jump_if_false +5 (to 90) - 86 pop 1 - 87 load_var 11 (first_role) - 88 load_const 10 ("user") - 89 cmp_op != - 90 jump_if_false +8 (to 98) - 91 pop 1 - 92 load_var 6 (system) - 93 container_len - 94 store_var 16 (_42) - 95 load_var 16 (_42) - 96 load_const 6 (0) - 97 cmp_int_op == - - 654 98 load_var 13 (promote_system) - 99 pop_jump_if_false +2 (to 101) - 100 jump +20 (to 120) - - 656 101 pop_jump_if_false +2 (to 103) - 102 jump +3 (to 105) - - 665 103 load_var 7 (lowered) - - 656 104 jump +25 (to 129) - - 657 105 load_type 5 - - 658 106 load_const 11 ("user") - 107 load_const 12 (false) - - 661 108 load_const 13 ("text") - 109 load_const 14 ("(continue)") - 110 load_const 7 (null) - 111 init_instance 0 (anthropic.internal.AnthTextBlock .type, .text, .cache_control) - 112 load_type 15 - 113 alloc_array 1 - 114 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 115 load_type 5 - 116 alloc_array 1 - - 663 117 load_var 7 (lowered) - - 657 118 call 7 ntypeargs=1 (baml.Array.concat) - 119 jump +10 (to 129) - - 655 120 load_type 5 - 121 load_const 16 ("user") - 122 load_const 12 (false) - 123 load_var 6 (system) - 124 init_instance 2 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) - 125 load_type 5 - 126 alloc_array 1 - 127 load_var 7 (lowered) - 128 call 7 ntypeargs=1 (baml.Array.concat) - - 667 129 call 1179 ntypeargs=0 (anthropic.internal._anthropic_render_messages) - 130 store_var 17 (messages) - - 668 131 load_var 17 (messages) - 132 container_len - 133 store_var 18 (_60) - 134 load_var 18 (_60) - 135 load_const 6 (0) - 136 cmp_int_op == - 137 pop_jump_if_false +2 (to 139) - 138 jump +86 (to 224) - - 679 139 load_var 13 (promote_system) - 140 jump_if_false +2 (to 142) - 141 jump +8 (to 149) - 142 pop 1 - 143 load_var 6 (system) - 144 container_len - 145 store_var 20 (_65) - 146 load_var 20 (_65) - 147 load_const 6 (0) - 148 cmp_int_op == - 149 pop_jump_if_false +2 (to 151) - 150 jump +4 (to 154) - - 682 151 load_var 6 (system) - 152 store_var 19 (system_param) - - 679 153 jump +3 (to 156) - - 680 154 load_const 7 (null) - 155 store_var 19 (system_param) - - 684 156 load_var 2 (input) - 157 load_field 2 (toolbox) - 158 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 159 unary_op ! - 160 store_var_load_var 21 (has_tools) - - 685 161 pop_jump_if_false +2 (to 163) - 162 jump +4 (to 166) - - 688 163 load_const 7 (null) - 164 store_var 22 (tool_params) - - 685 165 jump +5 (to 170) - - 686 166 load_var 2 (input) - 167 load_field 2 (toolbox) - 168 call 1181 ntypeargs=0 (anthropic.internal._anthropic_tool_params) - 169 store_var 22 (tool_params) - - 690 170 load_var 21 (has_tools) - 171 pop_jump_if_false +2 (to 173) - 172 jump +4 (to 176) - - 693 173 load_const 7 (null) - 174 store_var 23 (choice) - - 690 175 jump +5 (to 180) - - 691 176 load_var 1 (params) - 177 load_field 7 (tool_choice) - 178 call 1182 ntypeargs=0 (anthropic.internal._anthropic_tool_choice_param) - 179 store_var 23 (choice) - - 695 180 load_var 3 (stream) - 181 pop_jump_if_false +2 (to 183) - 182 jump +4 (to 186) - - 698 183 load_const 7 (null) - 184 store_var 24 (stream_flag) - - 695 185 jump +3 (to 188) - - 696 186 load_const 17 (true) - 187 store_var 24 (stream_flag) - - 701 188 load_var 1 (params) - 189 load_field 0 (model) - 190 store_var 25 (_76) - - 702 191 load_var 1 (params) - 192 load_field 1 (max_tokens) - 193 store_var 26 (_77) - - 703 194 load_var 19 (system_param) - 195 store_var 27 (_78) - - 705 196 load_var 22 (tool_params) - 197 store_var 28 (_80) - - 706 198 load_var 23 (choice) - 199 store_var 29 (_81) - - 707 200 load_var 1 (params) - 201 load_field 2 (temperature) - 202 store_var 30 (_82) - - 708 203 load_var 1 (params) - 204 load_field 3 (top_p) - 205 store_var 31 (_83) - - 709 206 load_var 1 (params) - 207 load_field 4 (top_k) - 208 store_var 32 (_84) - - 710 209 load_var 1 (params) - 210 load_field 5 (stop_sequences) - 211 store_var 33 (_85) - - 711 212 load_var 1 (params) - 213 load_field 6 (thinking) - 214 call 1183 ntypeargs=0 (anthropic.internal._anthropic_thinking_param) - 215 store_var 34 (_86) - - 700 216 load_var2 25 26 - 217 load_var2 27 17 - - 704 218 load_var2 28 29 - 219 load_var2 30 31 - 220 load_var2 32 33 - 221 load_var2 34 24 - - 712 222 init_instance 3 (anthropic.internal.AnthropicMessagesRequest .model, .max_tokens, .system, .messages, .tools, .tool_choice, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .stream) - 223 return - - 669 224 load_const 18 ("anthropic") - 225 load_const 7 (null) - 226 load_const 19 ("the rendered prompt and journal produced no message content") - 227 load_const 7 (null) - 228 init_instance 4 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 229 throw -} - -function anthropic.internal.anthropic_parse(resp: anthropic.internal.AnthropicResponse) -> ai.ModelTurn { - 808 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (content) - - 809 3 load_var 1 (resp) - 4 load_field 4 (content) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +86 (to 103) - 18 load_var 4 (_5) - 19 store_var 5 (b) - - 810 20 load_var 5 (b) - 21 load_field 0 (type) - 22 store_var_load_var 6 (_9) - 23 load_const 6 ("text") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +63 (to 89) - 27 load_var 6 (_9) - 28 load_const 7 ("thinking") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +44 (to 75) - 32 load_var 6 (_9) - 33 load_const 8 ("tool_use") - 34 cmp_op == - 35 pop_jump_if_false -26 (to 9) - - 820 36 load_type 9 - 37 load_type 10 - 38 alloc_map 0 - 39 store_var 9 (empty_args) - - 823 40 load_var 5 (b) - 41 load_field 4 (id) - 42 store_var_load_var 11 (_31) - 43 load_const 11 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 12 ("") - 47 store_var 11 (_31) - 48 load_var 11 (_31) - 49 store_var 10 (_30) - - 824 50 load_var 5 (b) - 51 load_field 5 (name) - 52 store_var_load_var 13 (_35) - 53 load_const 11 (null) - 54 cmp_op == - 55 pop_jump_if_false +3 (to 58) - 56 load_const 13 ("") - 57 store_var 13 (_35) - 58 load_var 13 (_35) - 59 store_var 12 (_34) - - 825 60 load_var 5 (b) - 61 load_field 6 (input) - 62 store_var_load_var 14 (_39) - 63 load_const 11 (null) - 64 cmp_op == - 65 pop_jump_if_false +3 (to 68) - 66 load_var 9 (empty_args) - 67 store_var 14 (_39) - - 821 68 load_type 0 - 69 load_var2 2 10 - - 822 70 load_var2 12 14 - - 825 71 init_instance 0 (ai.content.ToolUse .id, .name, .args) - - 821 72 call 4 ntypeargs=1 (baml.Array.push) - 73 pop 1 - 74 jump -65 (to 9) - - 816 75 load_var 5 (b) - 76 load_field 2 (thinking) - 77 store_var_load_var 8 (_22) - 78 load_const 11 (null) - 79 cmp_op == - 80 pop_jump_if_false +3 (to 83) - 81 load_const 14 ("") - 82 store_var 8 (_22) - 83 load_type 0 - 84 load_var2 2 8 - 85 init_instance 1 (ai.content.Reasoning .summary) - 86 call 4 ntypeargs=1 (baml.Array.push) - 87 pop 1 - 88 jump -79 (to 9) - - 812 89 load_var 5 (b) - 90 load_field 1 (text) - 91 store_var_load_var 7 (_14) - 92 load_const 11 (null) - 93 cmp_op == - 94 pop_jump_if_false +3 (to 97) - 95 load_const 15 ("") - 96 store_var 7 (_14) - 97 load_type 0 - 98 load_var2 2 7 - 99 init_instance 2 (ai.content.Text .text) - 100 call 4 ntypeargs=1 (baml.Array.push) - 101 pop 1 - 102 jump -93 (to 9) - - 836 103 load_var 1 (resp) - 104 load_field 5 (stop_reason) - 105 store_var_load_var 16 (_44) - 106 load_const 11 (null) - 107 cmp_op == - 108 pop_jump_if_false +2 (to 110) - 109 jump +6 (to 115) - 110 load_var 16 (_44) - 111 store_var_load_var 17 (s) - - 838 112 call 1190 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) - 113 store_var 15 (stop) - 114 jump +4 (to 118) - - 837 115 load_const 16 (ai.content.StopReason.Complete) - 116 alloc_variant 774 (ai.content.StopReason) - 117 store_var 15 (stop) - - 841 118 load_var 1 (resp) - 119 load_field 7 (usage) - 120 store_var 19 (_50) - 121 load_var 19 (_50) - 122 narrow_bind 17 19 - 123 pop_jump_if_false +2 (to 125) - 124 jump +4 (to 128) - - 855 125 load_const 11 (null) - 126 store_var 18 (usage) - - 841 127 jump +42 (to 169) - 128 load_var 19 (_50) - 129 store_var_load_var 20 (u) - - 844 130 load_field 0 (input_tokens) - 131 store_var_load_var 22 (_53) - 132 load_const 11 (null) - 133 cmp_op == - 134 pop_jump_if_false +3 (to 137) - 135 load_const 16 (0) - 136 store_var 22 (_53) - 137 load_var 22 (_53) - 138 store_var 21 (_52) - - 845 139 load_var 20 (u) - 140 load_field 1 (output_tokens) - 141 store_var_load_var 24 (_57) - 142 load_const 11 (null) - 143 cmp_op == - 144 pop_jump_if_false +3 (to 147) - 145 load_const 16 (0) - 146 store_var 24 (_57) - 147 load_var 24 (_57) - 148 store_var 23 (_56) - - 850 149 load_var 20 (u) - 150 load_field 3 (cache_read_input_tokens) - 151 store_var 25 (_60) - - 852 152 load_var 20 (u) - 153 load_field 2 (output_tokens_details) - 154 load_const 11 (null) - 155 cmp_op == - 156 pop_jump_if_false +2 (to 158) - 157 jump +6 (to 163) - 158 load_var 20 (u) - 159 load_field 2 (output_tokens_details) - 160 load_field 0 (0) - 161 store_var 26 (_61) - 162 jump +3 (to 165) - 163 load_const 11 (null) - 164 store_var 26 (_61) - - 843 165 load_var2 21 23 - 166 load_var2 25 26 - 167 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 168 store_var 18 (usage) - - 858 169 load_var2 2 15 - 170 load_var 18 (usage) - 171 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) - 172 return -} - -function anthropic.internal.anthropic_render(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> baml.http.Request { - 786 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - 3 return -} - -function anthropic.internal.invoke(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 863 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - 3 store_var 3 (req) - - 864 4 load_type 1 - 5 load_var 3 (req) - 6 load_const 2 ("anthropic") - 7 call 931 ntypeargs=1 (ai.wire.send_as) - - 865 8 call 1191 ntypeargs=0 (anthropic.internal.anthropic_parse) - 9 return -} - -function anthropic.internal.invoke_stream(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 7 - 1 make_cell - 2 store_var 7 - - 1220 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1188 ntypeargs=0 (anthropic.internal._anthropic_request) - - 1221 6 sys_op 252 (baml.http.fetch_sse) - 7 store_var 3 (sse) - 8 jump +30 (to 38) - 9 load_var 4 (e) - 10 is_type 1 - 11 pop_jump_if_false +2 (to 13) - 12 jump +22 (to 34) - 13 load_var 4 (e) - 14 is_type 2 - 15 pop_jump_if_false +2 (to 17) - 16 jump +3 (to 19) - 17 load_var 4 (e) - 18 rethrow - - 1226 19 load_type 3 - 20 load_var 4 (e) - 21 call 138 ntypeargs=1 (baml.String.from) - 22 store_var 6 (_14) - 23 load_type 4 - 24 load_var 6 (_14) - 25 call 138 ntypeargs=1 (baml.String.from) - 26 store_var 5 (_13) - - 1224 27 load_const 5 ("anthropic") - - 1226 28 load_const 6 ("the streaming request timed out: ") - 29 load_var 5 (_13) - 30 bin_op + - 31 load_const 7 (null) - 32 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 33 throw - - 1222 34 load_var 4 (e) - 35 load_field 0 (message) - 36 call 1198 ntypeargs=0 (anthropic.internal._anthropic_sse_failure) - 37 throw - - 1231 38 call 1193 ntypeargs=0 (anthropic.internal.AnthStreamState.new) - 39 store_deref 7 - - 1238 40 load_var2 3 7 - - 1239 41 make_closure 3356 1 - 42 load_const 8 ("anthropic") - - 1237 43 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 44 return -} - -function assert.approx_equal(actual: float, expected: float, eps: float) -> void { - 77 0 load_var 3 (eps) - 1 load_const 0 (0.0) - 2 cmp_float_op < - 3 jump_if_false +2 (to 5) - 4 jump +4 (to 8) - 5 pop 1 - 6 load_var 3 (eps) - 7 call 95 ntypeargs=0 (baml.Float.is_nan) - 8 pop_jump_if_false +4 (to 12) - - 78 9 load_const 1 ("assertion failed: epsilon must be a non-negative number") - 10 call 277 ntypeargs=0 (baml.sys.panic) - 11 pop 1 - - 80 12 load_var2 1 2 - 13 sub_float - 14 call 98 ntypeargs=0 (baml.Float.abs) - 15 store_var 4 (delta) - - 81 16 load_var 4 (delta) - 17 call 95 ntypeargs=0 (baml.Float.is_nan) - 18 jump_if_false +2 (to 20) - 19 jump +4 (to 23) - 20 pop 1 - 21 load_var2 4 3 - 22 cmp_float_op > - 23 pop_jump_if_false +2 (to 25) - 24 jump +3 (to 27) - 25 load_const 2 (null) - 26 jump +35 (to 61) - - 83 27 load_type 3 - 28 load_var 4 (delta) - 29 call 138 ntypeargs=1 (baml.String.from) - 30 store_var 5 (_20) - 31 load_type 3 - 32 load_var 3 (eps) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 6 (_23) - 35 load_type 3 - 36 load_var 1 (actual) - 37 call 138 ntypeargs=1 (baml.String.from) - 38 store_var 7 (_25) - 39 load_type 3 - 40 load_var 2 (expected) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 8 (_27) - 43 load_const 4 ("assertion failed: |left - right| = \"") - 44 load_var 5 (_20) - 45 bin_op + - 46 load_const 5 ("\", eps = \"") - 47 bin_op + - 48 load_var 6 (_23) - 49 bin_op + - 50 load_const 6 ("\", left = \"") - 51 bin_op + - 52 load_var 7 (_25) - 53 bin_op + - 54 load_const 7 ("\", right = \"") - 55 bin_op + - 56 load_var 8 (_27) - 57 bin_op + - 58 load_const 8 ("\"") - 59 bin_op + - - 82 60 call 277 ntypeargs=0 (baml.sys.panic) - 61 return -} - -function assert.contains(haystack: string, needle: string) -> void { - 90 0 load_var2 1 2 - 1 call 147 ntypeargs=0 (baml.String.includes) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +3 (to 9) - - 91 7 load_const 1 ("assertion failed: string does not contain expected substring") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function assert.equal(actual: unknown, expected: unknown) -> void { - 55 0 load_var2 1 2 - 1 call 672 ntypeargs=0 (baml.ops.equals_equals) - 2 unary_op ! - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +23 (to 29) - - 57 7 load_var 1 (actual) - 8 call 898 ntypeargs=0 (assert.format_operand) - 9 store_var 4 (_9) - 10 load_type 1 - 11 load_var 4 (_9) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 3 (_8) - 14 load_var 2 (expected) - 15 call 898 ntypeargs=0 (assert.format_operand) - 16 store_var 6 (_12) - 17 load_type 1 - 18 load_var 6 (_12) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 5 (_11) - 21 load_const 2 ("assertion failed: left = ") - 22 load_var 3 (_8) - 23 bin_op + - 24 load_const 3 (", right = ") - 25 bin_op + - 26 load_var 5 (_11) - 27 bin_op + - - 56 28 call 277 ntypeargs=0 (baml.sys.panic) - 29 return -} - -function assert.format_operand(value: unknown) -> string { - 34 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +5 (to 10) - - 36 6 load_type 1 - 7 load_var 1 (value) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 jump +12 (to 21) - - 34 10 load_var 2 (_2) - 11 store_var 3 (text) - - 35 12 load_type 2 - 13 load_var 3 (text) - 14 call 138 ntypeargs=1 (baml.String.from) - 15 store_var 4 (_5) - 16 load_const 3 ("\"") - 17 load_var 4 (_5) - 18 bin_op + - 19 load_const 4 ("\"") - 20 bin_op + - 21 return -} - -function assert.is_true(condition: bool) -> void { - 5 0 load_var 1 (condition) - 1 unary_op ! - 2 pop_jump_if_false +2 (to 4) - 3 jump +3 (to 6) - 4 load_const 0 (null) - 5 jump +3 (to 8) - - 6 6 load_const 1 ("assertion failed: expected true") - 7 call 277 ntypeargs=0 (baml.sys.panic) - 8 return -} - -function assert.is_type(actual: unknown) -> #0 { - 97 0 load_var 1 (actual) - 1 is_type 0 - 2 pop_jump_if_false +2 (to 4) - 3 jump +22 (to 25) - - 100 4 load_type 0 - 5 store_var 2 (t) - - 101 6 load_type 1 - 7 load_var 2 (t) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 3 (_8) - 10 load_type 2 - 11 load_var 1 (actual) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 4 (_11) - 14 load_const 3 ("assertion failed: expected type \"") - 15 load_var 3 (_8) - 16 bin_op + - 17 load_const 4 ("\", got \"") - 18 bin_op + - 19 load_var 4 (_11) - 20 bin_op + - 21 load_const 5 ("\"") - 22 bin_op + - 23 call 277 ntypeargs=0 (baml.sys.panic) - 24 jump +2 (to 26) - - 98 25 load_var 1 (actual) - 26 return -} - -function assert.not_null(value: unknown | null) -> void { - 12 0 load_var 1 (value) - 1 load_const 0 (null) - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - 5 load_const 0 (null) - 6 jump +3 (to 9) - - 13 7 load_const 1 ("assertion failed: expected non-null value") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function aws.BedrockClient.ai.Client.id(self: aws.BedrockClient) -> string { - 146 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("bedrock/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function aws.BedrockClient.ai.Client.invoke(self: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 150 0 load_var2 1 2 - 1 call 1327 ntypeargs=0 (aws.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 151 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function aws.BedrockClient.new(model: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null, endpoint_url: string | baml.env.Ref | null, max_tokens: int | null, temperature: float | null, top_p: float | null, stop_sequences: string[] | null, tool_choice: string | null, cache_system_prompt: bool, cache_tools: bool, additional_model_request_fields: baml.json.json | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> aws.BedrockClient { - 0 load_var 2 (region) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 97 4 load_const 1 (null) - 5 store_var 2 (region) - 6 load_var 3 (profile) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 98 10 load_const 1 (null) - 11 store_var 3 (profile) - 12 load_var 4 (access_key_id) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 99 16 load_const 1 (null) - 17 store_var 4 (access_key_id) - 18 load_var 5 (secret_access_key) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 100 22 load_const 1 (null) - 23 store_var 5 (secret_access_key) - 24 load_var 6 (session_token) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 101 28 load_const 1 (null) - 29 store_var 6 (session_token) - 30 load_var 7 (endpoint_url) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 102 34 load_const 1 (null) - 35 store_var 7 (endpoint_url) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 103 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (temperature) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 104 46 load_const 1 (null) - 47 store_var 9 (temperature) - 48 load_var 10 (top_p) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 105 52 load_const 1 (null) - 53 store_var 10 (top_p) - 54 load_var 11 (stop_sequences) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 106 58 load_const 1 (null) - 59 store_var 11 (stop_sequences) - 60 load_var 12 (tool_choice) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 107 64 load_const 1 (null) - 65 store_var 12 (tool_choice) - 66 load_var 13 (cache_system_prompt) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 108 70 load_const 2 (false) - 71 store_var 13 (cache_system_prompt) - 72 load_var 14 (cache_tools) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 109 76 load_const 2 (false) - 77 store_var 14 (cache_tools) - 78 load_var 15 (additional_model_request_fields) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 110 82 load_const 1 (null) - 83 store_var 15 (additional_model_request_fields) - 84 load_var 16 (request_body) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 111 88 load_const 1 (null) - 89 store_var 16 (request_body) - 90 load_var 17 (headers) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 112 94 load_const 1 (null) - 95 store_var 17 (headers) - 96 load_var 18 (query_params) - 97 load_const 0 () - 98 cmp_op == - 99 pop_jump_if_false +3 (to 102) - - 113 100 load_const 1 (null) - 101 store_var 18 (query_params) - - 115 102 load_var2 1 2 - 103 load_var2 3 4 - 104 load_var2 5 6 - 105 load_var2 7 8 - 106 load_var2 9 10 - 107 load_var2 11 12 - 108 load_var2 13 14 - 109 load_var2 15 16 - 110 load_var2 17 18 - 111 init_instance 0 (aws.BedrockClient .model, .region, .profile, .access_key_id, .secret_access_key, .session_token, .endpoint_url, .max_tokens, .temperature, .top_p, .stop_sequences, .tool_choice, .cache_system_prompt, .cache_tools, .additional_model_request_fields, .request_body, .headers, .query_params) - 112 return -} - -function aws.BedrockClient.resolved_endpoint_url(self: aws.BedrockClient) -> string | null { - 141 0 load_var 1 (self) - 1 load_field 6 (endpoint_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function aws.internal.ContentBlock.of_audio(audio: aws.internal.AudioBlock) -> aws.internal.ContentBlock { - 175 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document) - 5 load_var 1 (audio) - 6 init_field 4 (audio) - 7 load_var 2 (_2) - 8 init_spread 1 (.toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_cache_point() -> aws.internal.ContentBlock { - 187 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 1 (_1) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 1 (_1) - 4 init_spread 0 (.text, .image, .video, .document, .audio, .toolUse, .toolResult) - 5 load_const 0 ("default") - 6 init_instance 0 (aws.internal.CachePointBlock .type) - 7 init_field 7 (cachePoint) - 8 return -} - -function aws.internal.ContentBlock.of_document(document: aws.internal.DocumentBlock) -> aws.internal.ContentBlock { - 171 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video) - 5 load_var 1 (document) - 6 init_field 3 (document) - 7 load_var 2 (_2) - 8 init_spread 1 (.audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_image(image: aws.internal.ImageBlock) -> aws.internal.ContentBlock { - 163 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text) - 5 load_var 1 (image) - 6 init_field 1 (image) - 7 load_var 2 (_2) - 8 init_spread 1 (.video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_text(text: string) -> aws.internal.ContentBlock { - 159 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 1 (text) - 4 init_field 0 (text) - 5 load_var 2 (_2) - 6 init_spread 0 (.image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 7 return -} - -function aws.internal.ContentBlock.of_tool_result(tool_result: aws.internal.ToolResultBlock) -> aws.internal.ContentBlock { - 183 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document, .audio, .toolUse) - 5 load_var 1 (tool_result) - 6 init_field 6 (toolResult) - 7 load_var 2 (_2) - 8 init_spread 1 (.cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_tool_use(tool_use: aws.internal.ToolUseBlock) -> aws.internal.ContentBlock { - 179 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image, .video, .document, .audio) - 5 load_var 1 (tool_use) - 6 init_field 5 (toolUse) - 7 load_var 2 (_2) - 8 init_spread 1 (.toolResult, .cachePoint) - 9 return -} - -function aws.internal.ContentBlock.of_video(video: aws.internal.VideoBlock) -> aws.internal.ContentBlock { - 167 0 call 1286 ntypeargs=0 (aws.internal._empty_content_block) - 1 store_var 2 (_2) - 2 alloc_instance 730 ntypeargs=0 (aws.internal.ContentBlock) - 3 load_var 2 (_2) - 4 init_spread 0 (.text, .image) - 5 load_var 1 (video) - 6 init_field 2 (video) - 7 load_var 2 (_2) - 8 init_spread 1 (.document, .audio, .toolUse, .toolResult, .cachePoint) - 9 return -} - -function aws.internal.SystemContentBlock.of_cache_point() -> aws.internal.SystemContentBlock { - 216 0 load_const 0 (null) - 1 load_const 1 ("default") - 2 init_instance 0 (aws.internal.CachePointBlock .type) - 3 init_instance 1 (aws.internal.SystemContentBlock .text, .cachePoint) - 4 store_var 1 (_0) - 5 load_var 1 (_0) - 6 return -} - -function aws.internal.SystemContentBlock.of_text(text: string) -> aws.internal.SystemContentBlock { - 212 0 load_var 1 (text) - 1 load_const 0 (null) - 2 init_instance 0 (aws.internal.SystemContentBlock .text, .cachePoint) - 3 store_var 2 (_0) - 4 load_var 2 (_0) - 5 return -} - -function aws.internal.ToolEntry.of_cache_point() -> aws.internal.ToolEntry { - 271 0 load_const 0 (null) - 1 load_const 1 ("default") - 2 init_instance 0 (aws.internal.CachePointBlock .type) - 3 init_instance 1 (aws.internal.ToolEntry .toolSpec, .cachePoint) - 4 store_var 1 (_0) - 5 load_var 1 (_0) - 6 return -} - -function aws.internal.ToolEntry.of_spec(spec: aws.internal.ToolSpec) -> aws.internal.ToolEntry { - 267 0 load_var 1 (spec) - 1 load_const 0 (null) - 2 init_instance 0 (aws.internal.ToolEntry .toolSpec, .cachePoint) - 3 store_var 2 (_0) - 4 load_var 2 (_0) - 5 return -} - -function aws.internal.ToolInputSchema.baml.ToJson.to_json(self: aws.internal.ToolInputSchema) -> baml.json.json { - 247 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 3 (out) - - 248 4 load_type 0 - 5 load_type 1 - 6 load_var 3 (out) - 7 load_const 2 ("json") - 8 load_var 1 (self) - 9 load_field 0 (json_schema) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 249 12 load_var 3 (out) - 13 store_var 2 (_0) - 14 load_var 2 (_0) - 15 return -} - -function aws.internal._apply_query(url: string, params: map | null) -> string { - 1076 0 load_var 2 (params) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +110 (to 114) - 5 load_var 2 (params) - 6 store_var 3 (query) - - 1079 7 load_type 1 - 8 alloc_array 0 - 9 store_var 4 (pairs) - - 1080 10 load_type 1 - 11 load_type 1 - 12 load_var 3 (query) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_9) - 18 load_var 5 (_9) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 6 (_10) - 23 load_var 6 (_10) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +35 (to 61) - 27 load_var 6 (_10) - 28 store_var_load_var 7 (name) - - 1082 29 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 30 store_var 9 (_18) - 31 load_type 1 - 32 load_var 9 (_18) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 8 (_17) - 35 load_type 1 - 36 load_type 1 - 37 load_var2 3 7 - 38 call 38 ntypeargs=2 (baml.Map.get) - 39 store_var_load_var 12 (_24) - 40 load_const 0 (null) - 41 cmp_op == - 42 pop_jump_if_false +3 (to 45) - 43 load_const 7 ("") - 44 store_var 12 (_24) - 45 load_var 12 (_24) - 46 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 47 store_var 11 (_22) - 48 load_type 1 - 49 load_var 11 (_22) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 10 (_21) - - 1081 52 load_type 1 - 53 load_var2 4 8 - - 1082 54 load_const 8 ("=") - 55 bin_op + - 56 load_var 10 (_21) - 57 bin_op + - - 1081 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -42 (to 18) - - 1085 61 load_var 4 (pairs) - 62 container_len - 63 store_var 13 (_33) - 64 load_var 13 (_33) - 65 load_const 9 (0) - 66 cmp_int_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +44 (to 112) - - 1087 69 load_var 1 (url) - 70 load_const 10 ("?") - 71 call 147 ntypeargs=0 (baml.String.includes) - 72 pop_jump_if_false +2 (to 74) - 73 jump +20 (to 93) - - 1090 74 load_type 1 - 75 load_var 1 (url) - 76 call 138 ntypeargs=1 (baml.String.from) - 77 store_var 17 (_43) - 78 load_type 1 - 79 load_var 4 (pairs) - 80 load_const 11 ("&") - 81 call 15 ntypeargs=1 (baml.Array.join) - 82 store_var 19 (_46) - 83 load_type 1 - 84 load_var 19 (_46) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 18 (_45) - 87 load_var 17 (_43) - 88 load_const 12 ("?") - 89 bin_op + - 90 load_var 18 (_45) - 91 bin_op + - - 1087 92 jump +23 (to 115) - - 1088 93 load_type 1 - 94 load_var 1 (url) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 14 (_36) - 97 load_type 1 - 98 load_var 4 (pairs) - 99 load_const 13 ("&") - 100 call 15 ntypeargs=1 (baml.Array.join) - 101 store_var 16 (_39) - 102 load_type 1 - 103 load_var 16 (_39) - 104 call 138 ntypeargs=1 (baml.String.from) - 105 store_var 15 (_38) - 106 load_var 14 (_36) - 107 load_const 14 ("&") - 108 bin_op + - 109 load_var 15 (_38) - 110 bin_op + - - 1087 111 jump +4 (to 115) - - 1086 112 load_var 1 (url) - - 1085 113 jump +2 (to 115) - - 1077 114 load_var 1 (url) - 115 return -} - -function aws.internal._assistant_content(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> aws.internal.ContentBlock[] { - 683 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 684 3 load_var 1 (content) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +46 (to 62) - 17 load_var 5 (_4) - 18 store_var 6 (block) - - 685 19 load_var 6 (block) - 20 store_var 7 (_8) - 21 load_var 7 (_8) - 22 narrow_bind 6 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +28 (to 52) - 25 load_var 6 (block) - 26 store_var 10 (_14) - 27 load_var 10 (_14) - 28 narrow_bind 7 10 - 29 pop_jump_if_false +2 (to 31) - 30 jump -22 (to 8) - 31 load_var 6 (block) - 32 store_var 11 (_15) - 33 load_var 11 (_15) - 34 narrow_bind 8 11 - 35 pop_jump_if_false +2 (to 37) - 36 jump -28 (to 8) - 37 load_var 6 (block) - 38 store_var_load_var 12 (use) - - 701 39 load_field 0 (id) - 40 load_var 12 (use) - 41 load_field 1 (name) - 42 load_var 12 (use) - 43 load_field 2 (args) - 44 init_instance 0 (aws.internal.ToolUseBlock .toolUseId, .name, .input) - - 700 45 call 1283 ntypeargs=0 (aws.internal.ContentBlock.of_tool_use) - 46 store_var 13 (_18) - - 699 47 load_type 0 - 48 load_var2 3 13 - 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - 51 jump -43 (to 8) - - 685 52 load_var 7 (_8) - 53 store_var_load_var 8 (text) - - 687 54 load_field 0 (text) - 55 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 56 store_var 9 (_11) - 57 load_type 0 - 58 load_var2 3 9 - 59 call 4 ntypeargs=1 (baml.Array.push) - 60 pop 1 - 61 jump -53 (to 8) - - 708 62 load_var 3 (out) - 63 store_var 2 (_0) - 64 load_var 2 (_0) - 65 return -} - -function aws.internal._audio_block(audio: baml.media.Audio) -> aws.internal.ContentBlock { - 518 0 load_var 1 (audio) - 1 call 329 ntypeargs=0 (baml.media.Audio.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 521 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 call 1298 ntypeargs=0 (aws.internal._audio_format) - - 522 11 load_var 2 (resolved) - 12 load_const 0 ("audio") - 13 call 1299 ntypeargs=0 (aws.internal._media_source) - - 520 14 init_instance 0 (aws.internal.AudioBlock .format, .source) - - 519 15 call 1282 ntypeargs=0 (aws.internal.ContentBlock.of_audio) - 16 return -} - -function aws.internal._audio_format(mime: string) -> string { - 443 0 load_var 1 (mime) - 1 load_const 0 ("audio/mpeg") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +143 (to 147) - 5 load_var 1 (mime) - 6 load_const 1 ("audio/mp3") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +136 (to 145) - 10 load_var 1 (mime) - 11 load_const 2 ("audio/wav") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +129 (to 143) - 15 load_var 1 (mime) - 16 load_const 3 ("audio/x-wav") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +122 (to 141) - 20 load_var 1 (mime) - 21 load_const 4 ("audio/wave") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +115 (to 139) - 25 load_var 1 (mime) - 26 load_const 5 ("audio/flac") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +108 (to 137) - 30 load_var 1 (mime) - 31 load_const 6 ("audio/x-flac") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +101 (to 135) - 35 load_var 1 (mime) - 36 load_const 7 ("audio/ogg") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +94 (to 133) - 40 load_var 1 (mime) - 41 load_const 8 ("audio/opus") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +87 (to 131) - 45 load_var 1 (mime) - 46 load_const 9 ("audio/aac") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +80 (to 129) - 50 load_var 1 (mime) - 51 load_const 10 ("audio/x-aac") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +73 (to 127) - 55 load_var 1 (mime) - 56 load_const 11 ("audio/mp4") - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +66 (to 125) - 60 load_var 1 (mime) - 61 load_const 12 ("audio/m4a") - 62 cmp_op == - 63 pop_jump_if_false +2 (to 65) - 64 jump +59 (to 123) - 65 load_var 1 (mime) - 66 load_const 13 ("audio/x-m4a") - 67 cmp_op == - 68 pop_jump_if_false +2 (to 70) - 69 jump +52 (to 121) - 70 load_var 1 (mime) - 71 load_const 14 ("audio/x-matroska") - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +45 (to 119) - 75 load_var 1 (mime) - 76 load_const 15 ("audio/mpga") - 77 cmp_op == - 78 pop_jump_if_false +2 (to 80) - 79 jump +38 (to 117) - 80 load_var 1 (mime) - 81 load_const 16 ("audio/pcm") - 82 cmp_op == - 83 pop_jump_if_false +2 (to 85) - 84 jump +31 (to 115) - 85 load_var 1 (mime) - 86 load_const 17 ("audio/x-pcm") - 87 cmp_op == - 88 pop_jump_if_false +2 (to 90) - 89 jump +24 (to 113) - 90 load_var 1 (mime) - 91 load_const 18 ("audio/L16") - 92 cmp_op == - 93 pop_jump_if_false +2 (to 95) - 94 jump +17 (to 111) - 95 load_var 1 (mime) - 96 load_const 19 ("audio/webm") - 97 cmp_op == - 98 pop_jump_if_false +2 (to 100) - 99 jump +10 (to 109) - - 457 100 load_type 20 - 101 load_var 1 (mime) - 102 call 138 ntypeargs=1 (baml.String.from) - 103 store_var 2 (_24) - 104 load_const 21 ("unsupported audio format for Bedrock: ") - 105 load_var 2 (_24) - 106 bin_op + - 107 call 1294 ntypeargs=0 (aws.internal._reject) - 108 throw - - 456 109 load_const 22 ("webm") - - 443 110 jump +38 (to 148) - - 455 111 load_const 23 ("pcm") - - 443 112 jump +36 (to 148) - - 455 113 load_const 24 ("pcm") - - 443 114 jump +34 (to 148) - - 455 115 load_const 25 ("pcm") - - 443 116 jump +32 (to 148) - - 454 117 load_const 26 ("mpga") - - 443 118 jump +30 (to 148) - - 453 119 load_const 27 ("mka") - - 443 120 jump +28 (to 148) - - 452 121 load_const 28 ("m4a") - - 443 122 jump +26 (to 148) - - 452 123 load_const 29 ("m4a") - - 443 124 jump +24 (to 148) - - 451 125 load_const 30 ("mp4") - - 443 126 jump +22 (to 148) - - 450 127 load_const 31 ("x-aac") - - 443 128 jump +20 (to 148) - - 449 129 load_const 32 ("aac") - - 443 130 jump +18 (to 148) - - 448 131 load_const 33 ("opus") - - 443 132 jump +16 (to 148) - - 447 133 load_const 34 ("ogg") - - 443 134 jump +14 (to 148) - - 446 135 load_const 35 ("flac") - - 443 136 jump +12 (to 148) - - 446 137 load_const 36 ("flac") - - 443 138 jump +10 (to 148) - - 445 139 load_const 37 ("wav") - - 443 140 jump +8 (to 148) - - 445 141 load_const 38 ("wav") - - 443 142 jump +6 (to 148) - - 445 143 load_const 39 ("wav") - - 443 144 jump +4 (to 148) - - 444 145 load_const 40 ("mp3") - - 443 146 jump +2 (to 148) - - 444 147 load_const 41 ("mp3") - 148 return -} - -function aws.internal._conversation_role(role: string) -> string { - 624 0 load_var 1 (role) - 1 load_const 0 ("assistant") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 627 5 load_const 1 ("user") - - 624 6 jump +2 (to 8) - - 625 7 load_const 2 ("assistant") - 8 return -} - -function aws.internal._document_block(pdf: baml.media.Pdf) -> aws.internal.ContentBlock { - 499 0 load_var 1 (pdf) - 1 call 322 ntypeargs=0 (baml.media.Pdf.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 500 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 load_const 0 ("application/pdf") - 11 cmp_op != - 12 pop_jump_if_false +2 (to 14) - 13 jump +11 (to 24) - - 509 14 load_var 2 (resolved) - 15 load_const 1 ("document") - 16 call 1299 ntypeargs=0 (aws.internal._media_source) - 17 store_var 5 (_14) - - 504 18 load_const 2 ("pdf") - 19 load_const 3 ("document") - 20 load_var 5 (_14) - 21 init_instance 0 (aws.internal.DocumentBlock .format, .name, .source) - - 503 22 call 1281 ntypeargs=0 (aws.internal.ContentBlock.of_document) - 23 return - - 501 24 load_type 4 - 25 load_var 2 (resolved) - 26 load_field 2 (mime_type) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 4 (_10) - 29 load_const 5 ("unsupported document format for Bedrock: ") - 30 load_var 4 (_10) - 31 bin_op + - 32 call 1294 ntypeargs=0 (aws.internal._reject) - 33 throw -} - -function aws.internal._empty_content_block() -> aws.internal.ContentBlock { - 192 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 load_const 0 (null) - 7 load_const 0 (null) - 8 init_instance 0 (aws.internal.ContentBlock .text, .image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint) - 9 store_var 1 (_0) - 10 load_var 1 (_0) - 11 return -} - -function aws.internal._image_block(image: baml.media.Image) -> aws.internal.ContentBlock { - 477 0 load_var 1 (image) - 1 call 343 ntypeargs=0 (baml.media.Image.url) - 2 call 1295 ntypeargs=0 (aws.internal._is_s3_url) - 3 store_var 3 (_4) - 4 load_var2 1 3 - 5 unary_op ! - 6 call 933 ntypeargs=0 (ai.wire.resolve_media) - 7 store_var 2 (resolved) - - 480 8 load_var 2 (resolved) - 9 load_field 2 (mime_type) - 10 call 1296 ntypeargs=0 (aws.internal._image_format) - - 481 11 load_var 2 (resolved) - 12 load_const 0 ("image") - 13 call 1299 ntypeargs=0 (aws.internal._media_source) - - 479 14 init_instance 0 (aws.internal.ImageBlock .format, .source) - - 478 15 call 1279 ntypeargs=0 (aws.internal.ContentBlock.of_image) - 16 return -} - -function aws.internal._image_format(mime: string) -> string { - 411 0 load_var 1 (mime) - 1 load_const 0 ("image/png") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +38 (to 42) - 5 load_var 1 (mime) - 6 load_const 1 ("image/jpeg") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +31 (to 40) - 10 load_var 1 (mime) - 11 load_const 2 ("image/jpg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 1 (mime) - 16 load_const 3 ("image/gif") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 1 (mime) - 21 load_const 4 ("image/webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - - 416 25 load_type 5 - 26 load_var 1 (mime) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 2 (_9) - 29 load_const 6 ("unsupported image format for Bedrock: ") - 30 load_var 2 (_9) - 31 bin_op + - 32 call 1294 ntypeargs=0 (aws.internal._reject) - 33 throw - - 415 34 load_const 7 ("webp") - - 411 35 jump +8 (to 43) - - 414 36 load_const 8 ("gif") - - 411 37 jump +6 (to 43) - - 413 38 load_const 9 ("jpeg") - - 411 39 jump +4 (to 43) - - 413 40 load_const 10 ("jpeg") - - 411 41 jump +2 (to 43) - - 412 42 load_const 11 ("png") - 43 return -} - -function aws.internal._inference_config(client: aws.BedrockClient) -> aws.internal.InferenceConfig | null { - 866 0 load_var 1 (client) - 1 load_field 7 (max_tokens) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +13 (to 18) - 6 load_var 2 (_3) - 7 store_var_load_var 3 (limit) - - 870 8 load_const 1 (2147483647) - 9 cmp_int_op > - 10 jump_if_false +2 (to 12) - 11 jump +5 (to 16) - 12 pop 1 - 13 load_var 3 (limit) - 14 load_const 0 (0) - 15 cmp_int_op < - 16 pop_jump_if_false +2 (to 18) - 17 jump +60 (to 77) - - 876 18 load_var 1 (client) - 19 load_field 10 (stop_sequences) - 20 store_var_load_var 6 (_16) - 21 load_const 2 (null) - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +17 (to 41) - 25 load_var 6 (_16) - 26 store_var 7 (sequences) - - 879 27 load_var 7 (sequences) - 28 container_len - 29 store_var 8 (_20) - 30 load_var 8 (_20) - 31 load_const 0 (0) - 32 cmp_int_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +4 (to 38) - - 882 35 load_var 7 (sequences) - 36 store_var 5 (stops) - - 879 37 jump +6 (to 43) - - 880 38 load_const 2 (null) - 39 store_var 5 (stops) - - 879 40 jump +3 (to 43) - - 877 41 load_const 2 (null) - 42 store_var 5 (stops) - - 886 43 load_var 1 (client) - 44 load_field 7 (max_tokens) - 45 load_const 2 (null) - 46 call 672 ntypeargs=0 (baml.ops.equals_equals) - 47 jump_if_false +6 (to 53) - 48 pop 1 - - 887 49 load_var 1 (client) - 50 load_field 8 (temperature) - 51 load_const 2 (null) - 52 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 53 jump_if_false +6 (to 59) - 54 pop 1 - - 888 55 load_var 1 (client) - 56 load_field 9 (top_p) - 57 load_const 2 (null) - 58 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 59 jump_if_false +5 (to 64) - 60 pop 1 - - 889 61 load_var 5 (stops) - 62 load_const 2 (null) - 63 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 886 64 pop_jump_if_false +2 (to 66) - 65 jump +10 (to 75) - - 893 66 load_var 1 (client) - 67 load_field 7 (max_tokens) - - 894 68 load_var 1 (client) - 69 load_field 8 (temperature) - - 895 70 load_var 1 (client) - 71 load_field 9 (top_p) - - 896 72 load_var 5 (stops) - 73 init_instance 0 (aws.internal.InferenceConfig .maxTokens, .temperature, .topP, .stopSequences) - 74 jump +2 (to 76) - - 890 75 load_const 2 (null) - 76 return - - 872 77 load_type 3 - 78 load_var 3 (limit) - 79 call 138 ntypeargs=1 (baml.String.from) - 80 store_var 4 (_12) - 81 load_const 4 ("max_tokens value ") - 82 load_var 4 (_12) - 83 bin_op + - 84 load_const 5 (" is out of the supported range (0..=2147483647)") - 85 bin_op + - - 871 86 call 1294 ntypeargs=0 (aws.internal._reject) - 87 throw -} - -function aws.internal._is_malformed_stop(raw: string) -> bool { - 1223 0 load_var 1 (raw) - 1 load_const 0 ("malformed_model_output") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (raw) - 7 load_const 1 ("malformed_tool_use") - 8 cmp_op == - 9 return -} - -function aws.internal._is_opaque_key(key: string) -> bool { - 338 0 load_var 1 (key) - 1 load_const 0 ("additionalModelRequestFields") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("json") - 8 cmp_op == - 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - 12 load_var 1 (key) - 13 load_const 2 ("input") - 14 cmp_op == - 15 return -} - -function aws.internal._is_s3_url(url: string | null) -> bool { - 407 0 load_var 1 (url) - 1 store_var_load_var 2 (_3) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("") - 6 store_var 2 (_3) - 7 load_var 2 (_3) - 8 load_const 2 ("s3://") - 9 call 148 ntypeargs=0 (baml.String.starts_with) - 10 return -} - -function aws.internal._is_unreserved_byte(byte: int) -> bool { - 43 0 load_var 1 (byte) - 1 load_const 0 (48) - 2 cmp_int_op >= - 3 jump_if_false +5 (to 8) - 4 pop 1 - 5 load_var 1 (byte) - 6 load_const 1 (57) - 7 cmp_int_op <= - 8 jump_if_false +2 (to 10) - 9 jump +10 (to 19) - 10 pop 1 - - 44 11 load_var 1 (byte) - 12 load_const 2 (65) - 13 cmp_int_op >= - 14 jump_if_false +5 (to 19) - 15 pop 1 - 16 load_var 1 (byte) - 17 load_const 3 (90) - 18 cmp_int_op <= - - 43 19 jump_if_false +2 (to 21) - 20 jump +10 (to 30) - 21 pop 1 - - 45 22 load_var 1 (byte) - 23 load_const 4 (97) - 24 cmp_int_op >= - 25 jump_if_false +5 (to 30) - 26 pop 1 - 27 load_var 1 (byte) - 28 load_const 5 (122) - 29 cmp_int_op <= - - 43 30 jump_if_false +2 (to 32) - 31 jump +5 (to 36) - 32 pop 1 - - 46 33 load_var 1 (byte) - 34 load_const 6 (45) - 35 cmp_int_op == - - 43 36 jump_if_false +2 (to 38) - 37 jump +5 (to 42) - 38 pop 1 - - 47 39 load_var 1 (byte) - 40 load_const 7 (46) - 41 cmp_int_op == - - 43 42 jump_if_false +2 (to 44) - 43 jump +5 (to 48) - 44 pop 1 - - 48 45 load_var 1 (byte) - 46 load_const 8 (95) - 47 cmp_int_op == - - 43 48 jump_if_false +2 (to 50) - 49 jump +5 (to 54) - 50 pop 1 - - 49 51 load_var 1 (byte) - 52 load_const 9 (126) - 53 cmp_int_op == - 54 return -} - -function aws.internal._lower_journal(journal: ai.Journal, with_status: bool) -> aws.internal.Message[] { - 763 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (pending) - - 764 3 load_var 1 (journal) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +87 (to 104) - 18 load_var 6 (_6) - 19 store_var 7 (event) - - 765 20 load_var 7 (event) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +62 (to 87) - 26 load_var 7 (event) - 27 store_var 11 (_19) - 28 load_var 11 (_19) - 29 narrow_bind 7 11 - 30 pop_jump_if_false +2 (to 32) - 31 jump +34 (to 65) - 32 load_var 7 (event) - 33 store_var 15 (_30) - 34 load_var 15 (_30) - 35 narrow_bind 8 15 - 36 pop_jump_if_false +2 (to 38) - 37 jump +17 (to 54) - 38 load_var 7 (event) - 39 store_var 17 (_36) - 40 load_var 17 (_36) - 41 narrow_bind 9 17 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 17 (_36) - 44 store_var 18 (failed) - - 801 45 load_var2 4 18 - 46 load_field 0 (id) - 47 load_var 18 (failed) - 48 load_field 1 (message) - 49 load_const 10 (true) - 50 load_var 2 (with_status) - 51 call 1311 ntypeargs=0 (aws.internal._push_tool_result) - 52 pop 1 - 53 jump -44 (to 9) - - 765 54 load_var 15 (_30) - 55 store_var 16 (completed) - - 798 56 load_var2 4 16 - 57 load_field 0 (id) - 58 load_var 16 (completed) - 59 load_field 1 (output) - 60 load_const 11 (false) - 61 load_var 2 (with_status) - 62 call 1311 ntypeargs=0 (aws.internal._push_tool_result) - 63 pop 1 - 64 jump -55 (to 9) - - 765 65 load_var 11 (_19) - 66 store_var_load_var 12 (assistant) - - 779 67 load_field 0 (content) - 68 call 1309 ntypeargs=0 (aws.internal._assistant_content) - 69 store_var 13 (content) - - 787 70 load_var 13 (content) - 71 container_len - 72 store_var 14 (_24) - 73 load_var 14 (_24) - 74 load_const 12 (0) - 75 cmp_int_op > - 76 pop_jump_if_false -67 (to 9) - - 788 77 load_type 0 - 78 load_var 4 (pending) - - 790 79 load_const 13 ("assistant") - 80 load_var 13 (content) - 81 init_instance 0 (aws.internal.Message .role, .content) - 82 load_const 11 (false) - 83 init_instance 1 (aws.internal.PendingMessage .message, .tool_results) - - 788 84 call 4 ntypeargs=1 (baml.Array.push) - 85 pop 1 - 86 jump -77 (to 9) - - 765 87 load_var 8 (_10) - 88 store_var_load_var 9 (user) - - 771 89 load_field 0 (content) - 90 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 91 store_var 10 (_16) - - 767 92 load_type 0 - 93 load_var 4 (pending) - - 769 94 load_const 14 ("user") - - 771 95 load_var 10 (_16) - 96 load_type 15 - 97 alloc_array 1 - 98 init_instance 2 (aws.internal.Message .role, .content) - 99 load_const 11 (false) - 100 init_instance 3 (aws.internal.PendingMessage .message, .tool_results) - - 767 101 call 4 ntypeargs=1 (baml.Array.push) - 102 pop 1 - 103 jump -94 (to 9) - - 806 104 load_type 16 - 105 alloc_array 0 - 106 store_var 19 (out) - - 807 107 load_var 4 (pending) - 108 load_type 17 - 109 load_const 18 ("iter") - 110 virtual_call nargs=1 ntypeargs=0 - 111 store_var 20 (_44) - 112 load_var 20 (_44) - 113 load_type 19 - 114 load_const 20 ("next") - 115 virtual_call nargs=1 ntypeargs=0 - 116 store_var 21 (_45) - 117 load_var 21 (_45) - 118 is_type 5 - 119 pop_jump_if_false +2 (to 121) - 120 jump +9 (to 129) - 121 load_var 21 (_45) - 122 store_var 22 (entry) - - 808 123 load_type 16 - 124 load_var2 19 22 - 125 load_field 0 (message) - 126 call 4 ntypeargs=1 (baml.Array.push) - 127 pop 1 - 128 jump -16 (to 112) - - 810 129 load_var 19 (out) - 130 store_var 3 (_0) - 131 load_var 3 (_0) - 132 return -} - -function aws.internal._lower_prompt(prompt: ai.Prompt) -> aws.internal.BedrockPrompt { - 640 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (system) - - 641 3 load_type 1 - 4 alloc_array 0 - 5 store_var 4 (messages) - - 642 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_5) - 12 load_var 5 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_6) - 17 load_var 6 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +70 (to 90) - 21 load_var 6 (_6) - 22 store_var_load_var 7 (message) - - 643 23 load_field 0 (role) - 24 load_const 7 ("system") - 25 cmp_op == - 26 pop_jump_if_false +2 (to 28) - 27 jump +31 (to 58) - - 652 28 load_var 7 (message) - 29 call 1304 ntypeargs=0 (aws.internal._prompt_content) - 30 store_var 12 (content) - - 656 31 load_var 12 (content) - 32 container_len - 33 store_var 13 (_30) - 34 load_var 13 (_30) - 35 load_const 8 (0) - 36 cmp_int_op > - 37 pop_jump_if_false -25 (to 12) - - 657 38 load_var 7 (message) - 39 call 1306 ntypeargs=0 (aws.internal._wants_cache_point) - 40 pop_jump_if_false +7 (to 47) - - 658 41 call 1285 ntypeargs=0 (aws.internal.ContentBlock.of_cache_point) - 42 store_var 14 (_34) - 43 load_type 9 - 44 load_var2 12 14 - 45 call 4 ntypeargs=1 (baml.Array.push) - 46 pop 1 - - 660 47 load_var 7 (message) - 48 load_field 0 (role) - 49 call 1307 ntypeargs=0 (aws.internal._conversation_role) - 50 store_var 15 (_38) - 51 load_type 1 - 52 load_var2 4 15 - 53 load_var 12 (content) - 54 init_instance 0 (aws.internal.Message .role, .content) - 55 call 4 ntypeargs=1 (baml.Array.push) - 56 pop 1 - 57 jump -45 (to 12) - - 644 58 load_var 7 (message) - 59 call 1305 ntypeargs=0 (aws.internal._prompt_system) - 60 load_type 10 - 61 load_const 11 ("iter") - 62 virtual_call nargs=1 ntypeargs=0 - 63 store_var 8 (_14) - 64 load_var 8 (_14) - 65 load_type 12 - 66 load_const 13 ("next") - 67 virtual_call nargs=1 ntypeargs=0 - 68 store_var 9 (_15) - 69 load_var 9 (_15) - 70 is_type 6 - 71 pop_jump_if_false +2 (to 73) - 72 jump +8 (to 80) - 73 load_var 9 (_15) - 74 store_var 10 (block) - - 645 75 load_type 0 - 76 load_var2 3 10 - 77 call 4 ntypeargs=1 (baml.Array.push) - 78 pop 1 - 79 jump -15 (to 64) - - 647 80 load_var 7 (message) - 81 call 1306 ntypeargs=0 (aws.internal._wants_cache_point) - 82 pop_jump_if_false -70 (to 12) - - 648 83 call 1288 ntypeargs=0 (aws.internal.SystemContentBlock.of_cache_point) - 84 store_var 11 (_25) - 85 load_type 0 - 86 load_var2 3 11 - 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - 89 jump -77 (to 12) - - 665 90 load_var2 3 4 - 91 init_instance 1 (aws.internal.BedrockPrompt .system, .messages) - 92 store_var 2 (_0) - 93 load_var 2 (_0) - 94 return -} - -function aws.internal._media_source(resolved: ai.wire.ResolvedMedia, kind: string) -> aws.internal.MediaSource { - 464 0 load_var 1 (resolved) - 1 load_field 1 (base64) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +49 (to 55) - - 467 7 load_var 1 (resolved) - 8 load_field 0 (url) - 9 store_var 5 (_8) - 10 load_var 5 (_8) - 11 narrow_bind 0 5 - 12 pop_jump_if_false +2 (to 14) - 13 jump +12 (to 25) - - 473 14 load_type 1 - 15 load_var 2 (kind) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 9 (_25) - 18 load_const 2 ("Bedrock ") - 19 load_var 9 (_25) - 20 bin_op + - 21 load_const 3 (" content could not be resolved") - 22 bin_op + - 23 call 1294 ntypeargs=0 (aws.internal._reject) - 24 throw - - 467 25 load_var 5 (_8) - 26 store_var 6 (url) - - 468 27 load_var 6 (url) - 28 load_const 4 ("s3://") - 29 call 148 ntypeargs=0 (baml.String.starts_with) - 30 pop_jump_if_false +2 (to 32) - 31 jump +18 (to 49) - - 471 32 load_type 1 - 33 load_var 2 (kind) - 34 call 138 ntypeargs=1 (baml.String.from) - 35 store_var 7 (_17) - 36 load_type 1 - 37 load_var 6 (url) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 8 (_19) - 40 load_const 5 ("Bedrock requires s3:// URIs for ") - 41 load_var 7 (_17) - 42 bin_op + - 43 load_const 6 (" URLs, got: ") - 44 bin_op + - 45 load_var 8 (_19) - 46 bin_op + - 47 call 1294 ntypeargs=0 (aws.internal._reject) - 48 throw - - 469 49 load_const 7 (null) - 50 load_var 6 (url) - 51 load_const 7 (null) - 52 init_instance 0 (aws.internal.S3Location .uri, .bucketOwner) - 53 init_instance 1 (aws.internal.MediaSource .bytes, .s3Location) - 54 jump +5 (to 59) - - 464 55 load_var 3 (_4) - 56 store_var_load_var 4 (data) - - 465 57 load_const 7 (null) - 58 init_instance 2 (aws.internal.MediaSource .bytes, .s3Location) - 59 return -} - -function aws.internal._merge_adjacent_roles(messages: aws.internal.Message[]) -> aws.internal.Message[] { - 931 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 932 3 load_var 1 (messages) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +64 (to 80) - 17 load_var 5 (_4) - 18 store_var 6 (message) - - 933 19 load_var 3 (out) - 20 container_len - 21 store_var 7 (_10) - 22 load_type 0 - 23 load_var2 3 7 - 24 load_const 6 (1) - 25 sub_int - 26 call 3 ntypeargs=1 (baml.Array.at) - 27 store_var 8 (_12) - 28 load_var 8 (_12) - 29 narrow_bind 7 8 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 8 (_12) - 32 store_var_load_var 9 (last) - - 934 33 load_field 0 (role) - 34 load_var 6 (message) - 35 load_field 0 (role) - 36 cmp_op == - 37 pop_jump_if_false +2 (to 39) - 38 jump +18 (to 56) - - 941 39 load_var 6 (message) - 40 load_field 0 (role) - 41 store_var 13 (_29) - 42 load_type 8 - 43 load_var 6 (message) - 44 load_field 1 (content) - 45 load_type 8 - 46 alloc_array 0 - 47 call 7 ntypeargs=1 (baml.Array.concat) - 48 store_var 14 (_30) - 49 load_type 0 - 50 load_var2 3 13 - 51 load_var 14 (_30) - 52 init_instance 0 (aws.internal.Message .role, .content) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -47 (to 8) - - 935 56 load_var 6 (message) - 57 load_field 1 (content) - 58 load_type 9 - 59 load_const 10 ("iter") - 60 virtual_call nargs=1 ntypeargs=0 - 61 store_var 10 (_18) - 62 load_var 10 (_18) - 63 load_type 11 - 64 load_const 12 ("next") - 65 virtual_call nargs=1 ntypeargs=0 - 66 store_var 11 (_19) - 67 load_var 11 (_19) - 68 is_type 5 - 69 pop_jump_if_false +2 (to 71) - 70 jump -62 (to 8) - 71 load_var 11 (_19) - 72 store_var 12 (block) - - 936 73 load_type 8 - 74 load_var 9 (last) - 75 load_field 1 (content) - 76 load_var 12 (block) - 77 call 4 ntypeargs=1 (baml.Array.push) - 78 pop 1 - 79 jump -17 (to 62) - - 943 80 load_var 3 (out) - 81 store_var 2 (_0) - 82 load_var 2 (_0) - 83 return -} - -function aws.internal._merge_headers(base: map, extra: map | null) -> map { - 1057 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 4 (out) - - 1058 4 load_type 0 - 5 load_type 0 - 6 load_var 1 (base) - 7 call 35 ntypeargs=2 (baml.Map.keys) - 8 load_type 1 - 9 load_const 2 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_7) - 12 load_var 5 (_7) - 13 load_type 3 - 14 load_const 4 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_8) - 17 load_var 6 (_8) - 18 is_type 5 - 19 pop_jump_if_false +2 (to 21) - 20 jump +23 (to 43) - 21 load_var 6 (_8) - 22 store_var 7 (name) - - 1059 23 load_var 7 (name) - 24 call 142 ntypeargs=0 (baml.String.to_lower_case) - 25 store_var 8 (_13) - 26 load_type 0 - 27 load_type 0 - 28 load_var2 1 7 - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var_load_var 9 (_15) - 31 load_const 6 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 7 ("") - 35 store_var 9 (_15) - 36 load_type 0 - 37 load_type 0 - 38 load_var2 4 8 - 39 load_var 9 (_15) - 40 call 37 ntypeargs=2 (baml.Map.set) - 41 pop 1 - 42 jump -30 (to 12) - - 1061 43 load_var 2 (extra) - 44 load_const 6 (null) - 45 cmp_op == - 46 pop_jump_if_false +2 (to 48) - 47 jump +42 (to 89) - 48 load_var 2 (extra) - 49 store_var 10 (overrides) - - 1064 50 load_type 0 - 51 load_type 0 - 52 load_var 10 (overrides) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 1 - 55 load_const 8 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 11 (_28) - 58 load_var 11 (_28) - 59 load_type 3 - 60 load_const 9 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 12 (_29) - 63 load_var 12 (_29) - 64 is_type 5 - 65 pop_jump_if_false +2 (to 67) - 66 jump +23 (to 89) - 67 load_var 12 (_29) - 68 store_var 13 (name) - - 1065 69 load_var 13 (name) - 70 call 142 ntypeargs=0 (baml.String.to_lower_case) - 71 store_var 14 (_34) - 72 load_type 0 - 73 load_type 0 - 74 load_var2 10 13 - 75 call 38 ntypeargs=2 (baml.Map.get) - 76 store_var_load_var 15 (_36) - 77 load_const 6 (null) - 78 cmp_op == - 79 pop_jump_if_false +3 (to 82) - 80 load_const 10 ("") - 81 store_var 15 (_36) - 82 load_type 0 - 83 load_type 0 - 84 load_var2 4 14 - 85 load_var 15 (_36) - 86 call 37 ntypeargs=2 (baml.Map.set) - 87 pop 1 - 88 jump -30 (to 58) - - 1070 89 load_var 4 (out) - 90 store_var 3 (_0) - 91 load_var 3 (_0) - 92 return -} - -function aws.internal._prompt_content(message: ai.PromptMessage) -> aws.internal.ContentBlock[] { - 540 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (blocks) - - 541 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +78 (to 95) - 18 load_var 5 (_5) - 19 store_var 6 (part) - - 542 20 load_var 6 (part) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +55 (to 80) - 26 load_var 6 (part) - 27 store_var 10 (_17) - 28 load_var 10 (_17) - 29 narrow_bind 7 10 - 30 pop_jump_if_false +2 (to 32) - 31 jump +40 (to 71) - 32 load_var 6 (part) - 33 store_var 13 (_23) - 34 load_var 13 (_23) - 35 narrow_bind 8 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +25 (to 62) - 38 load_var 6 (part) - 39 store_var 16 (_29) - 40 load_var 16 (_29) - 41 narrow_bind 9 16 - 42 pop_jump_if_false +2 (to 44) - 43 jump +10 (to 53) - 44 load_var 6 (part) - 45 store_var_load_var 19 (pdf) - - 566 46 call 1302 ntypeargs=0 (aws.internal._document_block) - 47 store_var 20 (_37) - 48 load_type 0 - 49 load_var2 3 20 - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -43 (to 9) - - 542 53 load_var 16 (_29) - 54 store_var_load_var 17 (video) - - 562 55 call 1301 ntypeargs=0 (aws.internal._video_block) - 56 store_var 18 (_32) - 57 load_type 0 - 58 load_var2 3 18 - 59 call 4 ntypeargs=1 (baml.Array.push) - 60 pop 1 - 61 jump -52 (to 9) - - 542 62 load_var 13 (_23) - 63 store_var_load_var 14 (audio) - - 558 64 call 1303 ntypeargs=0 (aws.internal._audio_block) - 65 store_var 15 (_26) - 66 load_type 0 - 67 load_var2 3 15 - 68 call 4 ntypeargs=1 (baml.Array.push) - 69 pop 1 - 70 jump -61 (to 9) - - 542 71 load_var 10 (_17) - 72 store_var_load_var 11 (image) - - 554 73 call 1300 ntypeargs=0 (aws.internal._image_block) - 74 store_var 12 (_20) - 75 load_type 0 - 76 load_var2 3 12 - 77 call 4 ntypeargs=1 (baml.Array.push) - 78 pop 1 - 79 jump -70 (to 9) - - 542 80 load_var 7 (_9) - 81 store_var 8 (text) - - 548 82 load_var 8 (text) - 83 call 144 ntypeargs=0 (baml.String.trim) - 84 load_const 10 ("") - 85 cmp_op != - 86 pop_jump_if_false -77 (to 9) - - 549 87 load_var 8 (text) - 88 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 89 store_var 9 (_14) - 90 load_type 0 - 91 load_var2 3 9 - 92 call 4 ntypeargs=1 (baml.Array.push) - 93 pop 1 - 94 jump -85 (to 9) - - 571 95 load_var 3 (blocks) - 96 store_var 2 (_0) - 97 load_var 2 (_0) - 98 return -} - -function aws.internal._prompt_system(message: ai.PromptMessage) -> aws.internal.SystemContentBlock[] { - 577 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (blocks) - - 578 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +27 (to 44) - 18 load_var 5 (_5) - 19 store_var 6 (part) - - 579 20 load_var 6 (part) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - - 589 26 load_const 7 ("Bedrock system messages do not support media content") - 27 call 1294 ntypeargs=0 (aws.internal._reject) - 28 throw - - 579 29 load_var 7 (_9) - 30 store_var 8 (text) - - 583 31 load_var 8 (text) - 32 call 144 ntypeargs=0 (baml.String.trim) - 33 load_const 8 ("") - 34 cmp_op != - 35 pop_jump_if_false -26 (to 9) - - 584 36 load_var 8 (text) - 37 call 1287 ntypeargs=0 (aws.internal.SystemContentBlock.of_text) - 38 store_var 9 (_14) - 39 load_type 0 - 40 load_var2 3 9 - 41 call 4 ntypeargs=1 (baml.Array.push) - 42 pop 1 - 43 jump -34 (to 9) - - 593 44 load_var 3 (blocks) - 45 store_var 2 (_0) - 46 load_var 2 (_0) - 47 return -} - -function aws.internal._prune_nulls(value: baml.json.json) -> baml.json.json { - 342 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +39 (to 44) - 6 load_var 1 (value) - 7 store_var 10 (_31) - 8 load_var 10 (_31) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 369 12 load_var 1 (value) - - 342 13 jump +88 (to 101) - 14 load_var 10 (_31) - 15 store_var 11 (items) - - 363 16 load_type 2 - 17 alloc_array 0 - 18 store_var 12 (out) - - 364 19 load_var 11 (items) - 20 load_type 3 - 21 load_const 4 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 13 (_35) - 24 load_var 13 (_35) - 25 load_type 5 - 26 load_const 6 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 14 (_36) - 29 load_var 14 (_36) - 30 is_type 7 - 31 pop_jump_if_false +2 (to 33) - 32 jump +10 (to 42) - 33 load_var 14 (_36) - 34 store_var_load_var 15 (item) - - 365 35 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - 36 store_var 16 (_41) - 37 load_type 2 - 38 load_var2 12 16 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -17 (to 24) - - 367 42 load_var 12 (out) - - 342 43 jump +58 (to 101) - 44 load_var 2 (_2) - 45 store_var 3 (object) - - 344 46 load_type 8 - 47 load_type 2 - 48 alloc_map 0 - 49 store_var 4 (out) - - 345 50 load_type 8 - 51 load_type 2 - 52 load_var 3 (object) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 9 - 55 load_const 10 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 5 (_8) - 58 load_var 5 (_8) - 59 load_type 11 - 60 load_const 12 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 6 (_9) - 63 load_var 6 (_9) - 64 is_type 7 - 65 pop_jump_if_false +2 (to 67) - 66 jump +34 (to 100) - 67 load_var 6 (_9) - 68 store_var 7 (key) - - 346 69 load_type 8 - 70 load_type 2 - 71 load_var2 3 7 - 72 call 38 ntypeargs=2 (baml.Map.get) - 73 store_var 8 (member) - - 347 74 load_var 8 (member) - 75 load_const 13 (null) - 76 cmp_op == - 77 pop_jump_if_false +2 (to 79) - 78 jump -20 (to 58) - - 350 79 load_var 7 (key) - 80 call 1292 ntypeargs=0 (aws.internal._is_opaque_key) - 81 pop_jump_if_false +2 (to 83) - 82 jump +11 (to 93) - - 354 83 load_var 8 (member) - 84 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - 85 store_var 9 (_27) - 86 load_type 8 - 87 load_type 2 - 88 load_var2 4 7 - 89 load_var 9 (_27) - 90 call 37 ntypeargs=2 (baml.Map.set) - 91 pop 1 - 92 jump -34 (to 58) - - 351 93 load_type 8 - 94 load_type 2 - 95 load_var2 4 7 - 96 load_var 8 (member) - 97 call 37 ntypeargs=2 (baml.Map.set) - 98 pop 1 - 99 jump -41 (to 58) - - 360 100 load_var 4 (out) - 101 return -} - -function aws.internal._push_tool_result(pending: aws.internal.PendingMessage[], id: string, output: string, is_error: bool, with_status: bool) -> void { - 734 0 load_var 5 (with_status) - 1 unary_op ! - 2 pop_jump_if_false +2 (to 4) - 3 jump +10 (to 13) - - 736 4 load_var 4 (is_error) - 5 pop_jump_if_false +2 (to 7) - 6 jump +4 (to 10) - - 739 7 load_const 0 ("success") - 8 store_var 7 (status) - - 736 9 jump +6 (to 15) - - 737 10 load_const 1 ("error") - 11 store_var 7 (status) - - 736 12 jump +3 (to 15) - - 735 13 load_const 2 (null) - 14 store_var 7 (status) - - 742 15 load_var2 2 3 - - 744 16 init_instance 0 (aws.internal.ToolResultContentBlock .text) - 17 load_type 3 - 18 alloc_array 1 - - 745 19 load_var 7 (status) - 20 init_instance 1 (aws.internal.ToolResultBlock .toolUseId, .content, .status) - - 741 21 call 1284 ntypeargs=0 (aws.internal.ContentBlock.of_tool_result) - 22 store_var 8 (block) - - 749 23 load_var 1 (pending) - 24 container_len - 25 store_var 9 (_15) - 26 load_type 4 - 27 load_var2 1 9 - 28 load_const 5 (1) - 29 sub_int - 30 call 3 ntypeargs=1 (baml.Array.at) - 31 store_var 10 (_17) - 32 load_var 10 (_17) - 33 narrow_bind 6 10 - 34 pop_jump_if_false +6 (to 40) - 35 load_var 10 (_17) - 36 store_var_load_var 11 (last) - - 750 37 load_field 1 (tool_results) - 38 pop_jump_if_false +2 (to 40) - 39 jump +15 (to 54) - - 755 40 load_type 4 - 41 load_var 1 (pending) - - 756 42 load_const 7 ("user") - 43 load_var 8 (block) - 44 load_type 8 - 45 alloc_array 1 - 46 init_instance 2 (aws.internal.Message .role, .content) - 47 load_const 9 (true) - 48 init_instance 3 (aws.internal.PendingMessage .message, .tool_results) - - 755 49 call 4 ntypeargs=1 (baml.Array.push) - 50 pop 1 - - 733 51 load_const 2 (null) - 52 store_var 6 (_0) - 53 jump +8 (to 61) - - 751 54 load_type 8 - 55 load_var 11 (last) - 56 load_field 0 (message) - 57 load_field 1 (content) - 58 load_var 8 (block) - 59 call 4 ntypeargs=1 (baml.Array.push) - 60 pop 1 - 61 load_var 6 (_0) - 62 return -} - -function aws.internal._reject(detail: string) -> ai.errors.InvalidRequest { - 398 0 load_const 0 ("aws-bedrock") - 1 load_const 1 (null) - 2 load_var 1 (detail) - 3 load_const 1 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 store_var 2 (_0) - 6 load_var 2 (_0) - 7 return -} - -function aws.internal._supports_tool_result_status(model: string) -> bool { - 722 0 load_var 1 (model) - 1 call 142 ntypeargs=0 (baml.String.to_lower_case) - 2 store_var 2 (id) - - 723 3 load_var 2 (id) - 4 load_const 0 ("anthropic.claude") - 5 call 147 ntypeargs=0 (baml.String.includes) - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_var 2 (id) - 10 load_const 1 ("amazon.nova") - 11 call 147 ntypeargs=0 (baml.String.includes) - 12 return -} - -function aws.internal._system_as_user(system: aws.internal.SystemContentBlock[]) -> aws.internal.Message { - 905 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (content) - - 906 3 load_var 1 (system) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_3) - 8 load_var 4 (_3) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_4) - 13 load_var 5 (_4) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +25 (to 41) - 17 load_var 5 (_4) - 18 store_var_load_var 6 (block) - - 907 19 load_field 0 (text) - 20 store_var 7 (_9) - 21 load_var 7 (_9) - 22 narrow_bind 6 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +8 (to 32) - - 911 25 call 1285 ntypeargs=0 (aws.internal.ContentBlock.of_cache_point) - 26 store_var 10 (_16) - 27 load_type 0 - 28 load_var2 3 10 - 29 call 4 ntypeargs=1 (baml.Array.push) - 30 pop 1 - 31 jump -23 (to 8) - - 907 32 load_var 7 (_9) - 33 store_var_load_var 8 (text) - - 908 34 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 35 store_var 9 (_12) - 36 load_type 0 - 37 load_var2 3 9 - 38 call 4 ntypeargs=1 (baml.Array.push) - 39 pop 1 - 40 jump -32 (to 8) - - 915 41 load_const 7 ("user") - 42 load_var 3 (content) - 43 init_instance 0 (aws.internal.Message .role, .content) - 44 store_var 2 (_0) - 45 load_var 2 (_0) - 46 return -} - -function aws.internal._tool_choice(choice: string) -> aws.internal.ToolChoice { - 820 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (empty) - - 821 4 load_var 1 (choice) - 5 load_const 2 ("auto") - 6 cmp_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +27 (to 35) - 9 load_var 1 (choice) - 10 load_const 3 ("any") - 11 cmp_op == - 12 pop_jump_if_false +2 (to 14) - 13 jump +17 (to 30) - 14 load_var 1 (choice) - 15 load_const 4 ("required") - 16 cmp_op == - 17 pop_jump_if_false +2 (to 19) - 18 jump +7 (to 25) - - 824 19 load_const 5 (null) - 20 load_const 5 (null) - 21 load_var 1 (choice) - 22 init_instance 0 (aws.internal.SpecificToolChoice .name) - 23 init_instance 1 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 24 jump +15 (to 39) - - 823 25 load_const 5 (null) - 26 load_var 2 (empty) - 27 load_const 5 (null) - 28 init_instance 2 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 29 jump +10 (to 39) - - 823 30 load_const 5 (null) - 31 load_var 2 (empty) - 32 load_const 5 (null) - 33 init_instance 3 (aws.internal.ToolChoice .auto, .any, .tool) - - 821 34 jump +5 (to 39) - - 822 35 load_var 2 (empty) - 36 load_const 5 (null) - 37 load_const 5 (null) - 38 init_instance 4 (aws.internal.ToolChoice .auto, .any, .tool) - 39 return -} - -function aws.internal._tool_config(toolbox: ai.tools.Toolbox, tool_choice: string | null, cache_tools: bool) -> aws.internal.ToolConfig | null { - 833 0 load_var 1 (toolbox) - 1 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 2 pop_jump_if_false +2 (to 4) - 3 jump +66 (to 69) - - 836 4 load_type 0 - 5 alloc_array 0 - 6 store_var 4 (entries) - - 837 7 load_var 1 (toolbox) - 8 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_7) - 13 load_var 5 (_7) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_8) - 18 load_var 6 (_8) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +25 (to 46) - 22 load_var 6 (_8) - 23 store_var 7 (tool) - - 841 24 load_var 7 (tool) - 25 load_field 0 (name) - 26 store_var 9 (_15) - - 842 27 load_var 7 (tool) - 28 load_field 1 (description) - 29 store_var 10 (_16) - - 843 30 load_type 6 - 31 load_var 7 (tool) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 store_var 11 (_18) - - 840 35 load_var2 9 10 - - 843 36 load_var 11 (_18) - 37 init_instance 0 (aws.internal.ToolInputSchema .json_schema) - 38 init_instance 1 (aws.internal.ToolSpec .name, .description, .inputSchema) - - 839 39 call 1290 ntypeargs=0 (aws.internal.ToolEntry.of_spec) - 40 store_var 8 (_13) - - 838 41 load_type 0 - 42 load_var2 4 8 - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -32 (to 13) - - 848 46 load_var 3 (cache_tools) - 47 pop_jump_if_false +7 (to 54) - - 849 48 call 1291 ntypeargs=0 (aws.internal.ToolEntry.of_cache_point) - 49 store_var 12 (_23) - 50 load_type 0 - 51 load_var2 4 12 - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - - 854 54 load_var 2 (tool_choice) - 55 load_const 7 (null) - 56 cmp_op == - 57 pop_jump_if_false +2 (to 59) - 58 jump +6 (to 64) - 59 load_var 2 (tool_choice) - 60 store_var_load_var 14 (choice) - - 856 61 call 1313 ntypeargs=0 (aws.internal._tool_choice) - 62 store_var 13 (selection) - 63 jump +3 (to 66) - - 855 64 load_const 7 (null) - 65 store_var 13 (selection) - - 858 66 load_var2 4 13 - 67 init_instance 2 (aws.internal.ToolConfig .tools, .toolChoice) - 68 jump +2 (to 70) - - 834 69 load_const 7 (null) - 70 return -} - -function aws.internal._video_block(video: baml.media.Video) -> aws.internal.ContentBlock { - 489 0 load_var 1 (video) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 2 (resolved) - - 492 4 load_var 2 (resolved) - 5 load_field 2 (mime_type) - 6 call 1297 ntypeargs=0 (aws.internal._video_format) - - 493 7 load_var 2 (resolved) - 8 load_const 1 ("video") - 9 call 1299 ntypeargs=0 (aws.internal._media_source) - - 491 10 init_instance 0 (aws.internal.VideoBlock .format, .source) - - 490 11 call 1280 ntypeargs=0 (aws.internal.ContentBlock.of_video) - 12 return -} - -function aws.internal._video_format(mime: string) -> string { - 424 0 load_var 1 (mime) - 1 load_const 0 ("video/mp4") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +80 (to 84) - 5 load_var 1 (mime) - 6 load_const 1 ("video/mpeg") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +73 (to 82) - 10 load_var 1 (mime) - 11 load_const 2 ("video/mpg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +66 (to 80) - 15 load_var 1 (mime) - 16 load_const 3 ("video/x-mpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +59 (to 78) - 20 load_var 1 (mime) - 21 load_const 4 ("video/x-ms-wmv") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +52 (to 76) - 25 load_var 1 (mime) - 26 load_const 5 ("video/wmv") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +45 (to 74) - 30 load_var 1 (mime) - 31 load_const 6 ("video/x-matroska") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +38 (to 72) - 35 load_var 1 (mime) - 36 load_const 7 ("video/quicktime") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +31 (to 70) - 40 load_var 1 (mime) - 41 load_const 8 ("video/x-flv") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +24 (to 68) - 45 load_var 1 (mime) - 46 load_const 9 ("video/webm") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +17 (to 66) - 50 load_var 1 (mime) - 51 load_const 10 ("video/3gpp") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +10 (to 64) - - 434 55 load_type 11 - 56 load_var 1 (mime) - 57 call 138 ntypeargs=1 (baml.String.from) - 58 store_var 2 (_15) - 59 load_const 12 ("unsupported video format for Bedrock: ") - 60 load_var 2 (_15) - 61 bin_op + - 62 call 1294 ntypeargs=0 (aws.internal._reject) - 63 throw - - 433 64 load_const 13 ("three_gp") - - 424 65 jump +20 (to 85) - - 432 66 load_const 14 ("webm") - - 424 67 jump +18 (to 85) - - 431 68 load_const 15 ("flv") - - 424 69 jump +16 (to 85) - - 430 70 load_const 16 ("mov") - - 424 71 jump +14 (to 85) - - 429 72 load_const 17 ("mkv") - - 424 73 jump +12 (to 85) - - 428 74 load_const 18 ("wmv") - - 424 75 jump +10 (to 85) - - 428 76 load_const 19 ("wmv") - - 424 77 jump +8 (to 85) - - 427 78 load_const 20 ("mpg") - - 424 79 jump +6 (to 85) - - 427 80 load_const 21 ("mpg") - - 424 81 jump +4 (to 85) - - 426 82 load_const 22 ("mpeg") - - 424 83 jump +2 (to 85) - - 425 84 load_const 23 ("mp4") - 85 return -} - -function aws.internal._wants_cache_point(message: ai.PromptMessage) -> bool { - 611 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (message) - 3 load_field 3 (metadata) - 4 load_const 2 ("cache_point") - 5 call 38 ntypeargs=2 (baml.Map.get) - 6 load_const 3 (null) - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 613 10 load_const 4 (true) - - 611 11 jump +2 (to 13) - - 612 12 load_const 5 (false) - 13 return -} - -function aws.internal.build_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> baml.http.Request { - 1101 0 load_var2 1 2 - 1 call 1318 ntypeargs=0 (aws.internal.converse_request) - 2 store_var 4 (_5) - 3 load_type 0 - 4 load_var 4 (_5) - 5 call 355 ntypeargs=1 (baml.json.to_json) - 6 call 1293 ntypeargs=0 (aws.internal._prune_nulls) - - 1102 7 load_var 1 (client) - 8 load_field 15 (request_body) - 9 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 10 store_var 5 (merged) - - 1105 11 load_var 1 (client) - 12 call 1319 ntypeargs=0 (aws.internal.converse_url) - 13 load_var 1 (client) - 14 load_field 17 (query_params) - 15 call 1321 ntypeargs=0 (aws.internal._apply_query) - 16 store_var 6 (_10) - - 1107 17 load_const 1 ("application/json") - 18 load_const 2 ("application/json") - 19 load_const 3 ("content-type") - 20 load_const 4 ("accept") - 21 load_type 5 - 22 load_type 5 - 23 alloc_map 2 - - 1108 24 load_var 1 (client) - 25 load_field 16 (headers) - - 1106 26 call 1320 ntypeargs=0 (aws.internal._merge_headers) - 27 store_var 7 (_13) - - 1110 28 load_var 5 (merged) - 29 call 351 ntypeargs=0 (baml.json.stringify) - 30 store_var 8 (_16) - - 1103 31 load_const 6 ("POST") - 32 load_var2 6 7 - 33 load_var 8 (_16) - 34 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 35 store_var 3 (_0) - 36 load_var 3 (_0) - 37 return -} - -function aws.internal.converse_model_path(model_id: string) -> string { - 72 0 load_var 1 (model_id) - 1 call 1276 ntypeargs=0 (aws.internal.encode_path_label) - 2 store_var 4 (_4) - 3 load_type 0 - 4 load_var 4 (_4) - 5 call 138 ntypeargs=1 (baml.String.from) - 6 store_var 3 (_3) - 7 load_const 1 ("/model/") - 8 load_var 3 (_3) - 9 bin_op + - 10 load_const 2 ("/converse") - 11 bin_op + - 12 store_var 2 (_0) - 13 load_var 2 (_0) - 14 return -} - -function aws.internal.converse_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> aws.internal.ConverseRequest { - 951 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 5 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 5 (_5) - 7 call_indirect - 8 call 1308 ntypeargs=0 (aws.internal._lower_prompt) - 9 store_var 4 (prompt) - - 952 10 load_var 4 (prompt) - 11 load_field 0 (system) - 12 store_var 6 (system) - - 953 13 load_var 1 (client) - 14 load_field 12 (cache_system_prompt) - 15 jump_if_false +8 (to 23) - 16 pop 1 - 17 load_var 6 (system) - 18 container_len - 19 store_var 7 (_11) - 20 load_var 7 (_11) - 21 load_const 0 (0) - 22 cmp_int_op > - 23 pop_jump_if_false +7 (to 30) - - 954 24 call 1288 ntypeargs=0 (aws.internal.SystemContentBlock.of_cache_point) - 25 store_var 8 (_13) - 26 load_type 1 - 27 load_var2 6 8 - 28 call 4 ntypeargs=1 (baml.Array.push) - 29 pop 1 - - 956 30 load_var 4 (prompt) - 31 load_field 1 (messages) - 32 store_var 9 (messages) - - 958 33 load_var 2 (input) - 34 load_field 1 (journal) - 35 store_var 11 (_18) - 36 load_var 1 (client) - 37 load_type 2 - 38 load_const 3 ("id") - 39 virtual_call nargs=1 ntypeargs=0 - 40 store_var 12 (_19) - 41 load_var2 11 12 - 42 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 43 store_var 10 (_17) - - 959 44 load_var 1 (client) - 45 load_field 0 (model) - 46 call 1310 ntypeargs=0 (aws.internal._supports_tool_result_status) - 47 store_var 13 (_20) - - 957 48 load_var2 10 13 - 49 call 1312 ntypeargs=0 (aws.internal._lower_journal) - - 961 50 load_type 4 - 51 load_const 5 ("iter") - 52 virtual_call nargs=1 ntypeargs=0 - 53 store_var 14 (_23) - 54 load_var 14 (_23) - 55 load_type 6 - 56 load_const 7 ("next") - 57 virtual_call nargs=1 ntypeargs=0 - 58 store_var 15 (_24) - 59 load_var 15 (_24) - 60 is_type 8 - 61 pop_jump_if_false +2 (to 63) - 62 jump +8 (to 70) - 63 load_var 15 (_24) - 64 store_var 16 (message) - - 962 65 load_type 9 - 66 load_var2 9 16 - 67 call 4 ntypeargs=1 (baml.Array.push) - 68 pop 1 - 69 jump -15 (to 54) - - 968 70 load_type 9 - 71 load_var 9 (messages) - 72 load_const 0 (0) - 73 call 3 ntypeargs=1 (baml.Array.at) - 74 load_const 10 (null) - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +7 (to 84) - 78 load_type 9 - 79 load_var 9 (messages) - 80 load_const 0 (0) - 81 call 3 ntypeargs=1 (baml.Array.at) - 82 load_field 0 (0) - 83 jump +2 (to 85) - 84 load_const 10 (null) - 85 store_var_load_var 18 (_32) - 86 load_const 10 (null) - 87 cmp_op == - 88 pop_jump_if_false +3 (to 91) - 89 load_const 11 ("") - 90 store_var 18 (_32) - 91 load_var 18 (_32) - 92 store_var_load_var 17 (leading_role) - - 972 93 load_const 12 ("user") - 94 cmp_op != - 95 jump_if_false +3 (to 98) - 96 pop 1 - 97 jump +3 (to 100) - 98 store_var 19 (folded) - 99 jump +8 (to 107) - 100 load_var 6 (system) - 101 container_len - 102 store_var 20 (_43) - 103 load_var 20 (_43) - 104 load_const 0 (0) - 105 cmp_int_op > - 106 store_var 19 (folded) - - 976 107 load_var 9 (messages) - 108 container_len - 109 store_var 21 (_47) - 110 load_var 21 (_47) - 111 load_const 0 (0) - 112 cmp_int_op > - 113 jump_if_false +5 (to 118) - 114 pop 1 - 115 load_var 17 (leading_role) - 116 load_const 13 ("user") - 117 cmp_op != - 118 jump_if_false +8 (to 126) - 119 pop 1 - 120 load_var 6 (system) - 121 container_len - 122 store_var 22 (_49) - 123 load_var 22 (_49) - 124 load_const 0 (0) - 125 cmp_int_op == - - 978 126 load_var 19 (folded) - 127 pop_jump_if_false +2 (to 129) - 128 jump +19 (to 147) - - 980 129 pop_jump_if_false +2 (to 131) - 130 jump +3 (to 133) - - 985 131 load_var 9 (messages) - - 980 132 jump +24 (to 156) - - 981 133 load_const 14 ("(continue)") - 134 call 1278 ntypeargs=0 (aws.internal.ContentBlock.of_text) - 135 store_var 25 (_62) - 136 load_type 9 - 137 load_const 15 ("user") - 138 load_var 25 (_62) - 139 load_type 16 - 140 alloc_array 1 - 141 init_instance 0 (aws.internal.Message .role, .content) - 142 load_type 9 - 143 alloc_array 1 - - 982 144 load_var 9 (messages) - - 981 145 call 7 ntypeargs=1 (baml.Array.concat) - 146 jump +10 (to 156) - - 979 147 load_var 6 (system) - 148 call 1316 ntypeargs=0 (aws.internal._system_as_user) - 149 store_var 24 (_54) - 150 load_type 9 - 151 load_var 24 (_54) - 152 load_type 9 - 153 alloc_array 1 - 154 load_var 9 (messages) - 155 call 7 ntypeargs=1 (baml.Array.concat) - - 977 156 call 1317 ntypeargs=0 (aws.internal._merge_adjacent_roles) - 157 store_var 23 (wire_messages) - - 988 158 load_var 23 (wire_messages) - 159 container_len - 160 store_var 26 (_66) - 161 load_var 26 (_66) - 162 load_const 0 (0) - 163 cmp_int_op == - 164 pop_jump_if_false +2 (to 166) - 165 jump +36 (to 201) - - 991 166 load_var 19 (folded) - 167 jump_if_false +2 (to 169) - 168 jump +8 (to 176) - 169 pop 1 - 170 load_var 6 (system) - 171 container_len - 172 store_var 27 (_71) - 173 load_var 27 (_71) - 174 load_const 0 (0) - 175 cmp_int_op == - 176 pop_jump_if_false +2 (to 178) - 177 jump +3 (to 180) - - 994 178 load_var 6 (system) - - 991 179 jump +2 (to 181) - - 992 180 load_const 10 (null) - - 999 181 store_var 28 (_73) - - 1000 182 load_var 1 (client) - 183 call 1315 ntypeargs=0 (aws.internal._inference_config) - 184 store_var 29 (_74) - - 1001 185 load_var 2 (input) - 186 load_field 2 (toolbox) - 187 load_var 1 (client) - 188 load_field 11 (tool_choice) - 189 load_var 1 (client) - 190 load_field 13 (cache_tools) - 191 call 1314 ntypeargs=0 (aws.internal._tool_config) - 192 store_var 30 (_75) - - 998 193 load_var2 23 28 - 194 load_var2 29 30 - - 1002 195 load_var 1 (client) - 196 load_field 14 (additional_model_request_fields) - 197 init_instance 1 (aws.internal.ConverseRequest .messages, .system, .inferenceConfig, .toolConfig, .additionalModelRequestFields) - 198 store_var 3 (_0) - 199 load_var 3 (_0) - 200 return - - 989 201 load_const 17 ("the rendered prompt and journal produced no message content") - 202 call 1294 ntypeargs=0 (aws.internal._reject) - 203 throw -} - -function aws.internal.converse_url(client: aws.BedrockClient) -> string { - 1010 0 load_var 1 (client) - 1 load_field 0 (model) - 2 call 1277 ntypeargs=0 (aws.internal.converse_model_path) - 3 store_var 2 (path) - - 1011 4 load_var 1 (client) - 5 call 1272 ntypeargs=0 (aws.BedrockClient.resolved_endpoint_url) - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 narrow_bind 0 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +78 (to 88) - - 1023 11 load_var 1 (client) - 12 load_field 1 (region) - 13 store_var 9 (_18) - 14 load_var 9 (_18) - 15 narrow_bind 0 9 - 16 pop_jump_if_false +2 (to 18) - 17 jump +53 (to 70) - - 1029 18 load_const 1 (null) - 19 load_var 1 (client) - 20 load_field 2 (profile) - 21 call 1329 ntypeargs=0 (aws.internal.resolve_region) - 22 jump +19 (to 41) - 23 load_var 13 (e) - 24 throw_if_panic - - 1034 25 load_type 2 - 26 load_var 13 (e) - 27 call 138 ntypeargs=1 (baml.String.from) - 28 store_var 15 (_34) - 29 load_type 3 - 30 load_var 15 (_34) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 14 (_33) - - 1031 33 load_const 4 ("aws-bedrock") - 34 load_const 1 (null) - - 1034 35 load_const 5 ("AWS region resolution failed: ") - 36 load_var 14 (_33) - 37 bin_op + - 38 load_const 1 (null) - 39 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 40 throw - - 1039 41 store_var 16 (_37) - 42 load_var 16 (_37) - 43 narrow_bind 0 16 - 44 pop_jump_if_false +2 (to 46) - 45 jump +7 (to 52) - - 1042 46 load_const 6 ("aws-bedrock") - 47 load_const 1 (null) - 48 load_const 7 ("no AWS region: set the client's `region` option, AWS_REGION, AWS_DEFAULT_REGION, or a `region` key on the active profile (or set `endpoint_url` to bypass region resolution)") - 49 load_const 1 (null) - 50 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 51 throw - - 1039 52 load_var 16 (_37) - 53 store_var 17 (resolved) - - 1040 54 load_type 3 - 55 load_var 17 (resolved) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 18 (_41) - 58 load_type 3 - 59 load_var 2 (path) - 60 call 138 ntypeargs=1 (baml.String.from) - 61 store_var 19 (_44) - 62 load_const 8 ("https://bedrock-runtime.") - 63 load_var 18 (_41) - 64 bin_op + - 65 load_const 9 (".amazonaws.com") - 66 bin_op + - 67 load_var 19 (_44) - 68 bin_op + - 69 jump +49 (to 118) - - 1023 70 load_var 9 (_18) - 71 store_var 10 (explicit) - - 1024 72 load_type 3 - 73 load_var 10 (explicit) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 11 (_22) - 76 load_type 3 - 77 load_var 2 (path) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 12 (_25) - 80 load_const 10 ("https://bedrock-runtime.") - 81 load_var 11 (_22) - 82 bin_op + - 83 load_const 11 (".amazonaws.com") - 84 bin_op + - 85 load_var 12 (_25) - 86 bin_op + - 87 jump +31 (to 118) - - 1011 88 load_var 3 (_5) - 89 store_var 4 (endpoint) - - 1013 90 load_var 4 (endpoint) - 91 load_const 12 ("/") - 92 call 149 ntypeargs=0 (baml.String.ends_with) - 93 pop_jump_if_false +2 (to 95) - 94 jump +4 (to 98) - - 1016 95 load_var 4 (endpoint) - 96 store_var 5 (base) - - 1013 97 jump +11 (to 108) - - 1014 98 load_var 4 (endpoint) - 99 call 139 ntypeargs=0 (baml.String.length) - 100 store_var 6 (_10) - 101 load_var 4 (endpoint) - 102 load_const 13 (0) - 103 load_var 6 (_10) - 104 load_const 0 (1) - 105 sub_int - 106 call 153 ntypeargs=0 (baml.String.slice) - 107 store_var 5 (base) - - 1018 108 load_type 3 - 109 load_var 5 (base) - 110 call 138 ntypeargs=1 (baml.String.from) - 111 store_var 7 (_11) - 112 load_type 3 - 113 load_var 2 (path) - 114 call 138 ntypeargs=1 (baml.String.from) - 115 store_var 8 (_14) - 116 load_var2 7 8 - 117 bin_op + - 118 return -} - -function aws.internal.encode_path_label(value: string) -> string { - 57 0 load_const 0 ("0123456789ABCDEF") - 1 store_var 2 (hex) - - 58 2 load_type 1 - 3 alloc_array 0 - 4 store_var 3 (out) - - 59 5 load_var 1 (value) - 6 call 179 ntypeargs=0 (baml.String.to_utf8) - 7 call 194 ntypeargs=0 (baml.Uint8Array.to_array) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_6) - 12 load_var 4 (_6) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_7) - 17 load_var 5 (_7) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +54 (to 74) - 21 load_var 5 (_7) - 22 store_var_load_var 6 (byte) - - 60 23 call 1275 ntypeargs=0 (aws.internal._is_unreserved_byte) - 24 pop_jump_if_false +2 (to 26) - 25 jump +39 (to 64) - - 64 26 load_var2 2 6 - 27 load_const 7 (16) - 28 div_int - 29 call 157 ntypeargs=0 (baml.String.at) - 30 store_var_load_var 9 (_23) - 31 load_const 8 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 9 ("") - 35 store_var 9 (_23) - 36 load_type 1 - 37 load_var 9 (_23) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 8 (_21) - 40 load_var2 2 6 - 41 load_const 7 (16) - 42 mod_int - 43 call 157 ntypeargs=0 (baml.String.at) - 44 store_var_load_var 11 (_31) - 45 load_const 8 (null) - 46 cmp_op == - 47 pop_jump_if_false +3 (to 50) - 48 load_const 10 ("") - 49 store_var 11 (_31) - 50 load_type 1 - 51 load_var 11 (_31) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 10 (_29) - 54 load_type 1 - 55 load_var 3 (out) - 56 load_const 11 ("%") - 57 load_var 8 (_21) - 58 bin_op + - 59 load_var 10 (_29) - 60 bin_op + - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -51 (to 12) - - 61 64 load_var 6 (byte) - 65 load_type 12 - 66 alloc_array 1 - 67 call 182 ntypeargs=0 (baml.String.from_code_points) - 68 store_var 7 (_14) - 69 load_type 1 - 70 load_var2 3 7 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -61 (to 12) - - 67 74 load_type 1 - 75 load_var 3 (out) - 76 load_const 13 ("") - 77 call 15 ntypeargs=1 (baml.Array.join) - 78 return -} - -function aws.internal.invoke(client: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1328 0 load_var2 1 2 - 1 call 1322 ntypeargs=0 (aws.internal.build_request) - 2 store_var 4 (_4) - 3 load_var2 1 4 - 4 call 1323 ntypeargs=0 (aws.internal.sign) - 5 store_var 3 (request) - - 1329 6 load_type 0 - 7 load_var 3 (request) - 8 load_const 1 ("aws-bedrock") - 9 call 931 ntypeargs=1 (ai.wire.send_as) - 10 call 1326 ntypeargs=0 (aws.internal.parse_response) - 11 return -} - -function aws.internal.parse_response(response: aws.internal.ConverseResponse) -> ai.ModelTurn { - 1257 0 load_var 1 (response) - 1 load_field 1 (stopReason) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +6 (to 11) - 6 load_var 2 (_3) - 7 store_var_load_var 3 (raw) - - 1258 8 call 1324 ntypeargs=0 (aws.internal._is_malformed_stop) - 9 pop_jump_if_false +2 (to 11) - 10 jump +203 (to 213) - - 1265 11 load_var 1 (response) - 12 load_field 0 (output) - 13 load_const 1 (null) - 14 cmp_op == - 15 pop_jump_if_false +2 (to 17) - 16 jump +6 (to 22) - 17 load_var 1 (response) - 18 load_field 0 (output) - 19 load_field 0 (0) - 20 store_var 5 (message) - 21 jump +3 (to 24) - 22 load_const 1 (null) - 23 store_var 5 (message) - - 1266 24 load_var 5 (message) - 25 load_const 1 (null) - 26 call 672 ntypeargs=0 (baml.ops.equals_equals) - 27 pop_jump_if_false +2 (to 29) - 28 jump +176 (to 204) - - 1272 29 load_type 2 - 30 alloc_array 0 - 31 store_var 7 (content) - - 1273 32 load_var 5 (message) - 33 load_field 1 (1) - 34 store_var_load_var 9 (_23) - 35 load_const 1 (null) - 36 cmp_op == - 37 pop_jump_if_false +4 (to 41) - 38 load_type 3 - 39 alloc_array 0 - 40 store_var 9 (_23) - 41 load_var 9 (_23) - 42 store_var_load_var 8 (blocks) - - 1274 43 load_type 4 - 44 load_const 5 ("iter") - 45 virtual_call nargs=1 ntypeargs=0 - 46 store_var 10 (_27) - 47 load_var 10 (_27) - 48 load_type 6 - 49 load_const 7 ("next") - 50 virtual_call nargs=1 ntypeargs=0 - 51 store_var 11 (_28) - 52 load_var 11 (_28) - 53 is_type 8 - 54 pop_jump_if_false +2 (to 56) - 55 jump +95 (to 150) - 56 load_var 11 (_28) - 57 store_var_load_var 12 (block) - - 1275 58 load_field 0 (text) - 59 store_var 13 (_33) - 60 load_var 13 (_33) - 61 narrow_bind 0 13 - 62 pop_jump_if_false +2 (to 64) - 63 jump +79 (to 142) - - 1278 64 load_var 12 (block) - 65 load_field 1 (toolUse) - 66 store_var 15 (_40) - 67 load_var 15 (_40) - 68 narrow_bind 9 15 - 69 pop_jump_if_false +2 (to 71) - 70 jump +31 (to 101) - - 1288 71 load_var 12 (block) - 72 load_field 2 (reasoningContent) - 73 store_var 23 (_59) - 74 load_var 23 (_59) - 75 narrow_bind 10 23 - 76 pop_jump_if_false -29 (to 47) - 77 load_var 23 (_59) - 78 store_var_load_var 24 (reasoning) - - 1289 79 load_field 0 (reasoningText) - 80 load_const 1 (null) - 81 cmp_op == - 82 pop_jump_if_false +2 (to 84) - 83 jump +5 (to 88) - 84 load_var 24 (reasoning) - 85 load_field 0 (reasoningText) - 86 load_field 0 (0) - 87 jump +2 (to 89) - 88 load_const 1 (null) - 89 store_var 25 (_65) - 90 load_var 25 (_65) - 91 narrow_bind 0 25 - 92 pop_jump_if_false -45 (to 47) - 93 load_var 25 (_65) - 94 store_var 26 (summary) - - 1290 95 load_type 2 - 96 load_var2 7 26 - 97 init_instance 0 (ai.content.Reasoning .summary) - 98 call 4 ntypeargs=1 (baml.Array.push) - 99 pop 1 - 100 jump -53 (to 47) - - 1278 101 load_var 15 (_40) - 102 store_var 16 (use) - - 1279 103 load_type 11 - 104 load_type 12 - 105 alloc_map 0 - 106 store_var 17 (empty) - - 1282 107 load_var 16 (use) - 108 load_field 0 (toolUseId) - 109 store_var_load_var 19 (_46) - 110 load_const 1 (null) - 111 cmp_op == - 112 pop_jump_if_false +3 (to 115) - 113 load_const 13 ("") - 114 store_var 19 (_46) - 115 load_var 19 (_46) - 116 store_var 18 (_45) - - 1283 117 load_var 16 (use) - 118 load_field 1 (name) - 119 store_var_load_var 21 (_50) - 120 load_const 1 (null) - 121 cmp_op == - 122 pop_jump_if_false +3 (to 125) - 123 load_const 14 ("") - 124 store_var 21 (_50) - 125 load_var 21 (_50) - 126 store_var 20 (_49) - - 1284 127 load_var 16 (use) - 128 load_field 2 (input) - 129 store_var_load_var 22 (_54) - 130 load_const 1 (null) - 131 cmp_op == - 132 pop_jump_if_false +3 (to 135) - 133 load_var 17 (empty) - 134 store_var 22 (_54) - - 1280 135 load_type 2 - 136 load_var2 7 18 - - 1281 137 load_var2 20 22 - - 1284 138 init_instance 1 (ai.content.ToolUse .id, .name, .args) - - 1280 139 call 4 ntypeargs=1 (baml.Array.push) - 140 pop 1 - 141 jump -94 (to 47) - - 1275 142 load_var 13 (_33) - 143 store_var 14 (text) - - 1276 144 load_type 2 - 145 load_var2 7 14 - 146 init_instance 2 (ai.content.Text .text) - 147 call 4 ntypeargs=1 (baml.Array.push) - 148 pop 1 - 149 jump -102 (to 47) - - 1301 150 load_var 1 (response) - 151 load_field 1 (stopReason) - 152 store_var_load_var 28 (_72) - 153 load_const 1 (null) - 154 cmp_op == - 155 pop_jump_if_false +2 (to 157) - 156 jump +6 (to 162) - 157 load_var 28 (_72) - 158 store_var_load_var 29 (raw) - - 1303 159 call 1325 ntypeargs=0 (aws.internal.stop_reason) - 160 store_var 27 (stop) - 161 jump +4 (to 165) - - 1302 162 load_const 15 (ai.content.StopReason.Complete) - 163 alloc_variant 774 (ai.content.StopReason) - 164 store_var 27 (stop) - - 1306 165 load_var 1 (response) - 166 load_field 2 (usage) - 167 store_var_load_var 31 (_77) - 168 load_const 1 (null) - 169 cmp_op == - 170 pop_jump_if_false +2 (to 172) - 171 jump +27 (to 198) - 172 load_var 31 (_77) - 173 store_var_load_var 32 (reported) - - 1310 174 load_field 0 (inputTokens) - 175 store_var_load_var 34 (_81) - 176 load_const 1 (null) - 177 cmp_op == - 178 pop_jump_if_false +3 (to 181) - 179 load_const 15 (0) - 180 store_var 34 (_81) - 181 load_var 34 (_81) - 182 store_var 33 (_80) - - 1311 183 load_var 32 (reported) - 184 load_field 1 (outputTokens) - 185 store_var_load_var 35 (_85) - 186 load_const 1 (null) - 187 cmp_op == - 188 pop_jump_if_false +3 (to 191) - 189 load_const 15 (0) - 190 store_var 35 (_85) - - 1309 191 load_var2 33 35 - - 1312 192 load_var 32 (reported) - 193 load_field 3 (cacheReadInputTokens) - 194 load_const 1 (null) - 195 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 196 store_var 30 (usage) - - 1306 197 jump +3 (to 200) - - 1307 198 load_const 1 (null) - 199 store_var 30 (usage) - - 1320 200 load_var2 7 27 - 201 load_var 30 (usage) - 202 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) - 203 return - - 1269 204 load_type 16 - 205 load_var 1 (response) - 206 call 355 ntypeargs=1 (baml.json.to_json) - 207 call 351 ntypeargs=0 (baml.json.stringify) - 208 store_var 6 (_18) - - 1267 209 load_const 17 ("aws-bedrock") - 210 load_var 6 (_18) - 211 init_instance 5 (ai.errors.ParseFailed .provider, .raw_output) - 212 throw - - 1261 213 load_type 16 - 214 load_var 1 (response) - 215 call 355 ntypeargs=1 (baml.json.to_json) - 216 call 351 ntypeargs=0 (baml.json.stringify) - 217 store_var 4 (_8) - - 1259 218 load_const 18 ("aws-bedrock") - 219 load_var 4 (_8) - 220 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) - 221 throw -} - -function aws.internal.resolve_region(region: string | null, profile: string | null) -> string | null { - 61 0 load_var2 1 2 - 1 sys_op 984 (ai.internal._aws_resolve_region) - 2 return -} - -function aws.internal.sign(client: aws.BedrockClient, request: baml.http.Request) -> baml.http.Request { - 1117 0 load_var2 2 1 - - 1120 1 load_field 1 (region) - - 1121 2 load_var 1 (client) - 3 load_field 2 (profile) - - 1122 4 load_var 1 (client) - 5 load_field 3 (access_key_id) - - 1123 6 load_var 1 (client) - 7 load_field 4 (secret_access_key) - - 1124 8 load_var 1 (client) - 9 load_field 5 (session_token) - 10 load_const 0 ("bedrock") - 11 init_instance 0 (aws.internal.AwsSignOptions .region, .profile, .access_key_id, .secret_access_key, .session_token, .service) - - 1117 12 call 1328 ntypeargs=0 (aws.internal.sign_request) - 13 jump +19 (to 32) - 14 load_var 3 (e) - 15 throw_if_panic - - 1136 16 load_type 1 - 17 load_var 3 (e) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 5 (_13) - 20 load_type 2 - 21 load_var 5 (_13) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 4 (_12) - - 1133 24 load_const 3 ("aws-bedrock") - 25 load_const 4 (null) - - 1136 26 load_const 5 ("AWS SigV4 signing failed: ") - 27 load_var 4 (_12) - 28 bin_op + - 29 load_const 4 (null) - 30 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 31 throw - 32 return -} - -function aws.internal.sign_request(req: baml.http.Request, opts: aws.internal.AwsSignOptions) -> baml.http.Request { - 45 0 load_var2 1 2 - - 47 1 load_field 5 (service) - - 48 2 load_var 2 (opts) - 3 load_field 0 (region) - - 49 4 load_var 2 (opts) - 5 load_field 1 (profile) - - 50 6 load_var 2 (opts) - 7 load_field 2 (access_key_id) - - 51 8 load_var 2 (opts) - 9 load_field 3 (secret_access_key) - - 52 10 load_var 2 (opts) - 11 load_field 4 (session_token) - 12 sys_op 983 (ai.internal._aws_sign_request) - 13 return -} - -function aws.internal.stop_reason(raw: string) -> ai.content.StopReason { - 1230 0 load_var 1 (raw) - 1 load_const 0 ("tool_use") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +44 (to 48) - 5 load_var 1 (raw) - 6 load_const 1 ("max_tokens") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +36 (to 45) - 10 load_var 1 (raw) - 11 load_const 2 ("model_context_window_exceeded") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +28 (to 42) - 15 load_var 1 (raw) - 16 load_const 3 ("content_filtered") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +20 (to 39) - 20 load_var 1 (raw) - 21 load_const 4 ("guardrail_intervened") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +12 (to 36) - 25 load_var 1 (raw) - 26 store_var_load_var 2 (r) - - 1240 27 call 1324 ntypeargs=0 (aws.internal._is_malformed_stop) - - 1230 28 pop_jump_if_false +2 (to 30) - 29 jump +4 (to 33) - - 1242 30 load_const 5 (ai.content.StopReason.Complete) - 31 alloc_variant 774 (ai.content.StopReason) - - 1230 32 jump +18 (to 50) - - 1240 33 load_const 6 (ai.content.StopReason.Refused) - 34 alloc_variant 774 (ai.content.StopReason) - - 1230 35 jump +15 (to 50) - - 1236 36 load_const 6 (ai.content.StopReason.Refused) - 37 alloc_variant 774 (ai.content.StopReason) - - 1230 38 jump +12 (to 50) - - 1236 39 load_const 6 (ai.content.StopReason.Refused) - 40 alloc_variant 774 (ai.content.StopReason) - - 1230 41 jump +9 (to 50) - - 1235 42 load_const 7 (ai.content.StopReason.MaxTokens) - 43 alloc_variant 774 (ai.content.StopReason) - - 1230 44 jump +6 (to 50) - - 1235 45 load_const 7 (ai.content.StopReason.MaxTokens) - 46 alloc_variant 774 (ai.content.StopReason) - - 1230 47 jump +3 (to 50) - - 1231 48 load_const 8 (ai.content.StopReason.ToolUse) - 49 alloc_variant 774 (ai.content.StopReason) - 50 return -} - -function boundary.LocalId.capture(self: boundary.LocalId, inputs: bool | null, output: bool | null, error: bool | null) -> boundary.LocalId { -} - -function boundary.id() -> boundary.LocalId { -} - -function boundary.id.current() -> string { -} - -function claude_code.ClaudeCodeClient.ai.Client.id(self: claude_code.ClaudeCodeClient) -> string { - 40 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 1 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("claude-code/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function claude_code.ClaudeCodeClient.ai.Client.invoke(self: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 44 0 load_var2 1 2 - 1 call 1363 ntypeargs=0 (claude_code.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 45 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function claude_code.ClaudeCodeClient.new(model: string, executable: string, cwd: string | null, timeout_ms: int, permission_mode: string, harness_tools: string[], mcp_servers: map | null) -> claude_code.ClaudeCodeClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 18 4 load_const 1 ("haiku") - 5 store_var 1 (model) - 6 load_var 2 (executable) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 19 10 load_const 2 ("claude") - 11 store_var 2 (executable) - 12 load_var 3 (cwd) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 20 16 load_const 3 (null) - 17 store_var 3 (cwd) - 18 load_var 4 (timeout_ms) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 21 22 load_const 4 (240000) - 23 store_var 4 (timeout_ms) - 24 load_var 5 (permission_mode) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 22 28 load_const 5 ("default") - 29 store_var 5 (permission_mode) - 30 load_var 6 (harness_tools) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +4 (to 37) - - 23 34 load_type 6 - 35 alloc_array 0 - 36 store_var 6 (harness_tools) - 37 load_var 7 (mcp_servers) - 38 load_const 0 () - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - - 24 41 load_const 3 (null) - 42 store_var 7 (mcp_servers) - - 26 43 load_type 6 - 44 load_type 7 - 45 alloc_map 0 - 46 store_var 8 (servers) - - 34 47 load_var 7 (mcp_servers) - 48 store_var_load_var 9 (_17) - 49 load_const 3 (null) - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - 52 load_var 8 (servers) - 53 store_var 9 (_17) - - 27 54 load_var2 2 1 - 55 load_var2 3 4 - 56 load_var2 5 6 - - 34 57 load_var 9 (_17) - 58 init_instance 0 (claude_code.ClaudeCodeClient .executable, .model, .cwd, .timeout_ms, .permission_mode, .harness_tools, .mcp_servers) - 59 return -} - -function claude_code.internal._log_cc_event(raw: baml.json.json) -> void { - 163 0 load_type 0 - 1 load_var 1 (raw) - 2 load_const 1 (".type") - 3 load_const 2 ("?") - 4 call 364 ntypeargs=1 (baml.json.path_or) - 5 store_var 3 (kind) - - 164 6 load_var 3 (kind) - 7 load_const 3 ("system") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +331 (to 341) - 11 load_var 3 (kind) - 12 load_const 4 ("assistant") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +177 (to 192) - 16 load_var 3 (kind) - 17 load_const 5 ("user") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +23 (to 43) - 21 load_var 3 (kind) - 22 load_const 6 ("result") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +382 (to 407) - - 203 26 load_type 0 - 27 load_var 3 (kind) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 38 (_141) - 30 load_const 7 ("$baml_log") - 31 load_const 8 ("info") - 32 load_const 9 ("cc event: ") - 33 load_var 38 (_141) - 34 bin_op + - 35 load_const 10 ("level") - 36 load_const 11 ("data") - 37 load_type 0 - 38 load_type 12 - 39 alloc_map 2 - 40 send_event - 41 pop 1 - 42 jump +365 (to 407) - - 178 43 load_type 0 - 44 alloc_array 0 - 45 store_var 24 (parts) - - 179 46 load_type 13 - 47 load_var 1 (raw) - 48 load_const 14 (".message.content") - 49 load_type 15 - 50 alloc_array 0 - 51 call 364 ntypeargs=1 (baml.json.path_or) - - 180 52 load_type 16 - 53 load_const 17 ("iter") - 54 virtual_call nargs=1 ntypeargs=0 - 55 store_var 25 (_89) - 56 load_var 25 (_89) - 57 load_type 18 - 58 load_const 19 ("next") - 59 virtual_call nargs=1 ntypeargs=0 - 60 store_var 26 (_90) - 61 load_var 26 (_90) - 62 is_type 20 - 63 pop_jump_if_false +2 (to 65) - 64 jump +96 (to 160) - 65 load_var 26 (_90) - 66 store_var 27 (b) - - 181 67 load_type 0 - 68 load_var 27 (b) - 69 load_const 21 (".type") - 70 load_const 22 ("?") - 71 call 364 ntypeargs=1 (baml.json.path_or) - 72 store_var 28 (bt) - - 182 73 load_var 28 (bt) - 74 load_const 23 ("text") - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +64 (to 141) - 78 load_var 28 (bt) - 79 load_const 24 ("thinking") - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +40 (to 122) - 83 load_var 28 (bt) - 84 load_const 25 ("tool_use") - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +17 (to 104) - 88 load_var 28 (bt) - 89 load_const 26 ("tool_result") - 90 cmp_op == - 91 pop_jump_if_false +2 (to 93) - 92 jump +6 (to 98) - - 195 93 load_type 0 - 94 load_var2 24 28 - 95 call 4 ntypeargs=1 (baml.Array.push) - 96 pop 1 - 97 jump -41 (to 56) - - 194 98 load_type 0 - 99 load_var 24 (parts) - 100 load_const 27 ("tool_result") - 101 call 4 ntypeargs=1 (baml.Array.push) - 102 pop 1 - 103 jump -47 (to 56) - - 192 104 load_type 0 - 105 load_var 27 (b) - 106 load_const 28 (".name") - 107 load_const 29 ("?") - 108 call 364 ntypeargs=1 (baml.json.path_or) - 109 store_var 34 (_119) - 110 load_type 0 - 111 load_var 34 (_119) - 112 call 138 ntypeargs=1 (baml.String.from) - 113 store_var 33 (_118) - 114 load_type 0 - 115 load_var 24 (parts) - 116 load_const 30 ("tool_use: ") - 117 load_var 33 (_118) - 118 bin_op + - 119 call 4 ntypeargs=1 (baml.Array.push) - 120 pop 1 - 121 jump -65 (to 56) - - 188 122 load_type 0 - 123 load_var 27 (b) - 124 load_const 31 (".thinking") - 125 load_const 32 ("") - 126 call 364 ntypeargs=1 (baml.json.path_or) - 127 call 1359 ntypeargs=0 (claude_code.internal._preview) - 128 store_var 32 (_110) - 129 load_type 0 - 130 load_var 32 (_110) - 131 call 138 ntypeargs=1 (baml.String.from) - 132 store_var 31 (_109) - - 187 133 load_type 0 - 134 load_var 24 (parts) - - 188 135 load_const 33 ("thinking: ") - 136 load_var 31 (_109) - 137 bin_op + - - 187 138 call 4 ntypeargs=1 (baml.Array.push) - 139 pop 1 - 140 jump -84 (to 56) - - 184 141 load_type 0 - 142 load_var 27 (b) - 143 load_const 34 (".text") - 144 load_const 35 ("") - 145 call 364 ntypeargs=1 (baml.json.path_or) - 146 call 1359 ntypeargs=0 (claude_code.internal._preview) - 147 store_var 30 (_101) - 148 load_type 0 - 149 load_var 30 (_101) - 150 call 138 ntypeargs=1 (baml.String.from) - 151 store_var 29 (_100) - 152 load_type 0 - 153 load_var 24 (parts) - 154 load_const 36 ("text: ") - 155 load_var 29 (_100) - 156 bin_op + - 157 call 4 ntypeargs=1 (baml.Array.push) - 158 pop 1 - 159 jump -103 (to 56) - - 198 160 load_type 37 - 161 load_var 3 (kind) - 162 call 138 ntypeargs=1 (baml.String.from) - 163 store_var 35 (_132) - 164 load_type 0 - 165 load_var 24 (parts) - 166 load_const 38 (" | ") - 167 call 15 ntypeargs=1 (baml.Array.join) - 168 store_var 37 (_136) - 169 load_type 0 - 170 load_var 37 (_136) - 171 call 138 ntypeargs=1 (baml.String.from) - 172 store_var 36 (_135) - 173 load_const 39 ("$baml_log") - 174 load_const 40 ("info") - 175 load_const 41 ("cc event: ") - 176 load_var 35 (_132) - 177 bin_op + - 178 load_const 42 (" [") - 179 bin_op + - 180 load_var 36 (_135) - 181 bin_op + - 182 load_const 43 ("]") - 183 bin_op + - 184 load_const 44 ("level") - 185 load_const 45 ("data") - 186 load_type 0 - 187 load_type 12 - 188 alloc_map 2 - 189 send_event - 190 pop 1 - 191 jump +216 (to 407) - - 178 192 load_type 0 - 193 alloc_array 0 - 194 store_var 10 (parts) - - 179 195 load_type 13 - 196 load_var 1 (raw) - 197 load_const 46 (".message.content") - 198 load_type 15 - 199 alloc_array 0 - 200 call 364 ntypeargs=1 (baml.json.path_or) - - 180 201 load_type 16 - 202 load_const 47 ("iter") - 203 virtual_call nargs=1 ntypeargs=0 - 204 store_var 11 (_33) - 205 load_var 11 (_33) - 206 load_type 18 - 207 load_const 48 ("next") - 208 virtual_call nargs=1 ntypeargs=0 - 209 store_var 12 (_34) - 210 load_var 12 (_34) - 211 is_type 20 - 212 pop_jump_if_false +2 (to 214) - 213 jump +96 (to 309) - 214 load_var 12 (_34) - 215 store_var 13 (b) - - 181 216 load_type 0 - 217 load_var 13 (b) - 218 load_const 49 (".type") - 219 load_const 50 ("?") - 220 call 364 ntypeargs=1 (baml.json.path_or) - 221 store_var 14 (bt) - - 182 222 load_var 14 (bt) - 223 load_const 51 ("text") - 224 cmp_op == - 225 pop_jump_if_false +2 (to 227) - 226 jump +64 (to 290) - 227 load_var 14 (bt) - 228 load_const 52 ("thinking") - 229 cmp_op == - 230 pop_jump_if_false +2 (to 232) - 231 jump +40 (to 271) - 232 load_var 14 (bt) - 233 load_const 53 ("tool_use") - 234 cmp_op == - 235 pop_jump_if_false +2 (to 237) - 236 jump +17 (to 253) - 237 load_var 14 (bt) - 238 load_const 54 ("tool_result") - 239 cmp_op == - 240 pop_jump_if_false +2 (to 242) - 241 jump +6 (to 247) - - 195 242 load_type 0 - 243 load_var2 10 14 - 244 call 4 ntypeargs=1 (baml.Array.push) - 245 pop 1 - 246 jump -41 (to 205) - - 194 247 load_type 0 - 248 load_var 10 (parts) - 249 load_const 55 ("tool_result") - 250 call 4 ntypeargs=1 (baml.Array.push) - 251 pop 1 - 252 jump -47 (to 205) - - 192 253 load_type 0 - 254 load_var 13 (b) - 255 load_const 56 (".name") - 256 load_const 57 ("?") - 257 call 364 ntypeargs=1 (baml.json.path_or) - 258 store_var 20 (_63) - 259 load_type 0 - 260 load_var 20 (_63) - 261 call 138 ntypeargs=1 (baml.String.from) - 262 store_var 19 (_62) - 263 load_type 0 - 264 load_var 10 (parts) - 265 load_const 58 ("tool_use: ") - 266 load_var 19 (_62) - 267 bin_op + - 268 call 4 ntypeargs=1 (baml.Array.push) - 269 pop 1 - 270 jump -65 (to 205) - - 188 271 load_type 0 - 272 load_var 13 (b) - 273 load_const 59 (".thinking") - 274 load_const 60 ("") - 275 call 364 ntypeargs=1 (baml.json.path_or) - 276 call 1359 ntypeargs=0 (claude_code.internal._preview) - 277 store_var 18 (_54) - 278 load_type 0 - 279 load_var 18 (_54) - 280 call 138 ntypeargs=1 (baml.String.from) - 281 store_var 17 (_53) - - 187 282 load_type 0 - 283 load_var 10 (parts) - - 188 284 load_const 61 ("thinking: ") - 285 load_var 17 (_53) - 286 bin_op + - - 187 287 call 4 ntypeargs=1 (baml.Array.push) - 288 pop 1 - 289 jump -84 (to 205) - - 184 290 load_type 0 - 291 load_var 13 (b) - 292 load_const 62 (".text") - 293 load_const 63 ("") - 294 call 364 ntypeargs=1 (baml.json.path_or) - 295 call 1359 ntypeargs=0 (claude_code.internal._preview) - 296 store_var 16 (_45) - 297 load_type 0 - 298 load_var 16 (_45) - 299 call 138 ntypeargs=1 (baml.String.from) - 300 store_var 15 (_44) - 301 load_type 0 - 302 load_var 10 (parts) - 303 load_const 64 ("text: ") - 304 load_var 15 (_44) - 305 bin_op + - 306 call 4 ntypeargs=1 (baml.Array.push) - 307 pop 1 - 308 jump -103 (to 205) - - 198 309 load_type 37 - 310 load_var 3 (kind) - 311 call 138 ntypeargs=1 (baml.String.from) - 312 store_var 21 (_76) - 313 load_type 0 - 314 load_var 10 (parts) - 315 load_const 65 (" | ") - 316 call 15 ntypeargs=1 (baml.Array.join) - 317 store_var 23 (_80) - 318 load_type 0 - 319 load_var 23 (_80) - 320 call 138 ntypeargs=1 (baml.String.from) - 321 store_var 22 (_79) - 322 load_const 66 ("$baml_log") - 323 load_const 67 ("info") - 324 load_const 68 ("cc event: ") - 325 load_var 21 (_76) - 326 bin_op + - 327 load_const 69 (" [") - 328 bin_op + - 329 load_var 22 (_79) - 330 bin_op + - 331 load_const 70 ("]") - 332 bin_op + - 333 load_const 71 ("level") - 334 load_const 72 ("data") - 335 load_type 0 - 336 load_type 12 - 337 alloc_map 2 - 338 send_event - 339 pop 1 - 340 jump +67 (to 407) - - 166 341 load_type 0 - 342 load_var 1 (raw) - 343 load_const 73 (".subtype") - 344 load_const 74 ("?") - 345 call 364 ntypeargs=1 (baml.json.path_or) - 346 store_var 4 (subtype) - - 167 347 load_var 4 (subtype) - 348 load_const 75 ("thinking_tokens") - 349 cmp_op == - 350 pop_jump_if_false +2 (to 352) - 351 jump +32 (to 383) - - 173 352 load_type 0 - 353 load_var 1 (raw) - 354 load_const 76 (".model") - 355 load_const 77 ("?") - 356 call 364 ntypeargs=1 (baml.json.path_or) - 357 store_var 7 (model) - - 174 358 load_type 0 - 359 load_var 4 (subtype) - 360 call 138 ntypeargs=1 (baml.String.from) - 361 store_var 8 (_21) - 362 load_type 0 - 363 load_var 7 (model) - 364 call 138 ntypeargs=1 (baml.String.from) - 365 store_var 9 (_24) - 366 load_const 78 ("$baml_log") - 367 load_const 79 ("info") - 368 load_const 80 ("cc event: system/") - 369 load_var 8 (_21) - 370 bin_op + - 371 load_const 81 (" model=") - 372 bin_op + - 373 load_var 9 (_24) - 374 bin_op + - 375 load_const 82 ("level") - 376 load_const 83 ("data") - 377 load_type 0 - 378 load_type 12 - 379 alloc_map 2 - 380 send_event - 381 pop 1 - 382 jump +25 (to 407) - - 170 383 load_type 84 - 384 load_var 1 (raw) - 385 load_const 85 (".estimated_tokens") - 386 load_const 86 (0) - 387 call 364 ntypeargs=1 (baml.json.path_or) - 388 store_var 5 (estimated) - - 171 389 load_type 84 - 390 load_var 5 (estimated) - 391 call 138 ntypeargs=1 (baml.String.from) - 392 store_var 6 (_13) - 393 load_const 87 ("$baml_log") - 394 load_const 88 ("debug") - 395 load_const 89 ("cc event: thinking ~") - 396 load_var 6 (_13) - 397 bin_op + - 398 load_const 90 (" tokens") - 399 bin_op + - 400 load_const 91 ("level") - 401 load_const 92 ("data") - 402 load_type 0 - 403 load_type 12 - 404 alloc_map 2 - 405 send_event - 406 pop 1 - - 162 407 load_const 93 (null) - 408 store_var 2 (_0) - 409 load_var 2 (_0) - 410 return -} - -function claude_code.internal._preview(text: string) -> string { - 154 0 load_var 1 (text) - 1 call 139 ntypeargs=0 (baml.String.length) - 2 load_const 0 (120) - 3 cmp_int_op > - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 157 6 load_var 1 (text) - - 154 7 jump +11 (to 18) - - 155 8 load_var 1 (text) - 9 load_const 1 (0) - 10 load_const 0 (120) - 11 call 153 ntypeargs=0 (baml.String.slice) - 12 store_var 2 (_5) - 13 load_type 2 - 14 load_var 2 (_5) - 15 call 138 ntypeargs=1 (baml.String.from) - 16 load_const 3 ("...") - 17 bin_op + - 18 return -} - -function claude_code.internal._read_result(p: baml.sys.Process) -> baml.json.json { - 127 0 load_const 0 (null) - 1 store_var 2 (result) - - 128 2 load_var 1 (p) - 3 load_field 0 (stdout) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 3 (_4) - 8 load_var 3 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_5) - 13 load_var 4 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +35 (to 51) - 17 load_var 4 (_5) - 18 store_var 5 (line) - - 129 19 load_var 5 (line) - 20 call 144 ntypeargs=0 (baml.String.trim) - 21 store_var 6 (trimmed) - - 130 22 load_var 6 (trimmed) - 23 call 139 ntypeargs=0 (baml.String.length) - 24 load_const 6 (0) - 25 cmp_int_op > - 26 pop_jump_if_false -18 (to 8) - - 131 27 load_var 6 (trimmed) - 28 call 350 ntypeargs=0 (baml.json.parse) - 29 store_var 7 (raw) - 30 jump +7 (to 37) - 31 load_var 8 (e) - 32 throw_if_panic - - 133 33 load_const 7 ("claude-code") - 34 load_var 6 (trimmed) - 35 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 36 throw - - 136 37 load_var 7 (raw) - 38 call 1360 ntypeargs=0 (claude_code.internal._log_cc_event) - 39 pop 1 - - 137 40 load_type 8 - 41 load_var 7 (raw) - 42 load_const 9 (".type") - 43 load_const 10 ("") - 44 call 364 ntypeargs=1 (baml.json.path_or) - 45 load_const 11 ("result") - 46 cmp_op == - 47 pop_jump_if_false -39 (to 8) - - 138 48 load_var 7 (raw) - 49 store_var 2 (result) - - 137 50 jump -42 (to 8) - - 144 51 load_var 2 (result) - 52 load_const 0 (null) - 53 call 672 ntypeargs=0 (baml.ops.equals_equals) - 54 pop_jump_if_false +2 (to 56) - 55 jump +3 (to 58) - - 150 56 load_var 2 (result) - 57 return - - 145 58 load_const 12 ("claude-code") - 59 load_const 13 ("the Claude Code CLI stream ended without a result event") - 60 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 61 throw -} - -function claude_code.internal._type_schema(t: string) -> map { - 89 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 3 (m) - - 90 4 load_type 0 - 5 load_type 1 - 6 load_var 3 (m) - 7 load_const 2 ("type") - 8 load_var 1 (t) - 9 call 37 ntypeargs=2 (baml.Map.set) - 10 pop 1 - - 91 11 load_var 3 (m) - 12 store_var 2 (_0) - 13 load_var 2 (_0) - 14 return -} - -function claude_code.internal.allowed_mcp_tools(c: claude_code.ClaudeCodeClient) -> string { - 223 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (c) - 3 load_field 6 (mcp_servers) - 4 call 35 ntypeargs=2 (baml.Map.keys) - 5 store_var 3 (_3) - 6 load_type 0 - 7 load_type 0 - 8 load_type 2 - 9 load_var 3 (_3) - - 224 10 make_closure 4211 0 - - 223 11 call 16 ntypeargs=3 (baml.Array.map) - 12 store_var 2 (_2) - 13 load_type 0 - 14 load_var 2 (_2) - 15 load_const 3 (",") - 16 call 15 ntypeargs=1 (baml.Array.join) - 17 return -} - -function claude_code.internal.envelope_schema(output_type: type) -> map { - 52 0 load_var 1 (output_type) - 1 sys_op 365 (baml.json.schema) - 2 store_var 4 (_3) - 3 load_type 0 - 4 load_var 4 (_3) - 5 call 358 ntypeargs=1 (baml.json.from_json) - 6 store_var 3 (final_root) - - 53 7 load_type 1 - 8 load_type 2 - 9 load_var 3 (final_root) - 10 load_const 3 ("$defs") - 11 call 39 ntypeargs=2 (baml.Map.delete) - 12 store_var 5 (definitions) - - 54 13 load_type 1 - 14 load_type 2 - 15 alloc_map 0 - 16 store_var 6 (call_props) - - 55 17 load_const 4 ("string") - 18 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 19 store_var 7 (_10) - 20 load_type 1 - 21 load_type 2 - 22 load_var 6 (call_props) - 23 load_const 5 ("id") - 24 load_var 7 (_10) - 25 call 37 ntypeargs=2 (baml.Map.set) - 26 pop 1 - - 56 27 load_const 6 ("string") - 28 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 29 store_var 8 (_14) - 30 load_type 1 - 31 load_type 2 - 32 load_var 6 (call_props) - 33 load_const 7 ("name") - 34 load_var 8 (_14) - 35 call 37 ntypeargs=2 (baml.Map.set) - 36 pop 1 - - 57 37 load_const 8 ("object") - 38 call 1356 ntypeargs=0 (claude_code.internal._type_schema) - 39 store_var 9 (_18) - 40 load_type 1 - 41 load_type 2 - 42 load_var 6 (call_props) - 43 load_const 9 ("args") - 44 load_var 9 (_18) - 45 call 37 ntypeargs=2 (baml.Map.set) - 46 pop 1 - - 58 47 load_type 1 - 48 load_type 2 - 49 alloc_map 0 - 50 store_var 10 (call_item) - - 59 51 load_type 1 - 52 load_type 2 - 53 load_var 10 (call_item) - 54 load_const 10 ("type") - 55 load_const 11 ("object") - 56 call 37 ntypeargs=2 (baml.Map.set) - 57 pop 1 - - 60 58 load_type 1 - 59 load_type 2 - 60 load_var 10 (call_item) - 61 load_const 12 ("properties") - 62 load_var 6 (call_props) - 63 call 37 ntypeargs=2 (baml.Map.set) - 64 pop 1 - - 61 65 load_type 1 - 66 load_type 2 - 67 load_var 10 (call_item) - 68 load_const 13 ("required") - 69 load_const 14 ("id") - 70 load_const 15 ("name") - 71 load_const 16 ("args") - 72 load_type 1 - 73 alloc_array 3 - 74 call 37 ntypeargs=2 (baml.Map.set) - 75 pop 1 - - 62 76 load_type 1 - 77 load_type 2 - 78 load_var 10 (call_item) - 79 load_const 17 ("additionalProperties") - 80 load_const 18 (false) - 81 call 37 ntypeargs=2 (baml.Map.set) - 82 pop 1 - - 63 83 load_type 1 - 84 load_type 2 - 85 alloc_map 0 - 86 store_var 11 (calls_array) - - 64 87 load_type 1 - 88 load_type 2 - 89 load_var 11 (calls_array) - 90 load_const 19 ("type") - 91 load_const 20 ("array") - 92 call 37 ntypeargs=2 (baml.Map.set) - 93 pop 1 - - 65 94 load_type 1 - 95 load_type 2 - 96 load_var 11 (calls_array) - 97 load_const 21 ("items") - 98 load_var 10 (call_item) - 99 call 37 ntypeargs=2 (baml.Map.set) - 100 pop 1 - - 66 101 load_type 1 - 102 load_type 2 - 103 alloc_map 0 - 104 store_var 12 (calls_props) - - 67 105 load_type 1 - 106 load_type 2 - 107 load_var 12 (calls_props) - 108 load_const 22 ("calls") - 109 load_var 11 (calls_array) - 110 call 37 ntypeargs=2 (baml.Map.set) - 111 pop 1 - - 68 112 load_type 1 - 113 load_type 2 - 114 alloc_map 0 - 115 store_var 13 (calls_schema) - - 69 116 load_type 1 - 117 load_type 2 - 118 load_var 13 (calls_schema) - 119 load_const 23 ("type") - 120 load_const 24 ("object") - 121 call 37 ntypeargs=2 (baml.Map.set) - 122 pop 1 - - 70 123 load_type 1 - 124 load_type 2 - 125 load_var 13 (calls_schema) - 126 load_const 25 ("properties") - 127 load_var 12 (calls_props) - 128 call 37 ntypeargs=2 (baml.Map.set) - 129 pop 1 - - 71 130 load_type 1 - 131 load_type 2 - 132 load_var 13 (calls_schema) - 133 load_const 26 ("required") - 134 load_const 27 ("calls") - 135 load_type 1 - 136 alloc_array 1 - 137 call 37 ntypeargs=2 (baml.Map.set) - 138 pop 1 - - 72 139 load_type 1 - 140 load_type 2 - 141 load_var 13 (calls_schema) - 142 load_const 28 ("additionalProperties") - 143 load_const 18 (false) - 144 call 37 ntypeargs=2 (baml.Map.set) - 145 pop 1 - - 73 146 load_type 1 - 147 load_type 2 - 148 alloc_map 0 - 149 store_var 14 (outcome) - - 74 150 load_type 0 - 151 load_var 3 (final_root) - 152 call 355 ntypeargs=1 (baml.json.to_json) - 153 store_var 15 (_67) - 154 load_type 0 - 155 load_var 13 (calls_schema) - 156 call 355 ntypeargs=1 (baml.json.to_json) - 157 store_var 16 (_70) - 158 load_type 1 - 159 load_type 2 - 160 load_var 14 (outcome) - 161 load_const 29 ("anyOf") - 162 load_var2 15 16 - 163 load_type 30 - 164 alloc_array 2 - 165 call 37 ntypeargs=2 (baml.Map.set) - 166 pop 1 - - 75 167 load_type 1 - 168 load_type 2 - 169 alloc_map 0 - 170 store_var 17 (props) - - 76 171 load_type 1 - 172 load_type 2 - 173 load_var 17 (props) - 174 load_const 31 ("outcome") - 175 load_var 14 (outcome) - 176 call 37 ntypeargs=2 (baml.Map.set) - 177 pop 1 - - 77 178 load_type 1 - 179 load_type 2 - 180 alloc_map 0 - 181 store_var 18 (envelope) - - 78 182 load_type 1 - 183 load_type 2 - 184 load_var 18 (envelope) - 185 load_const 32 ("type") - 186 load_const 33 ("object") - 187 call 37 ntypeargs=2 (baml.Map.set) - 188 pop 1 - - 79 189 load_type 1 - 190 load_type 2 - 191 load_var 18 (envelope) - 192 load_const 34 ("properties") - 193 load_var 17 (props) - 194 call 37 ntypeargs=2 (baml.Map.set) - 195 pop 1 - - 80 196 load_type 1 - 197 load_type 2 - 198 load_var 18 (envelope) - 199 load_const 35 ("required") - 200 load_const 36 ("outcome") - 201 load_type 1 - 202 alloc_array 1 - 203 call 37 ntypeargs=2 (baml.Map.set) - 204 pop 1 - - 81 205 load_type 1 - 206 load_type 2 - 207 load_var 18 (envelope) - 208 load_const 37 ("additionalProperties") - 209 load_const 18 (false) - 210 call 37 ntypeargs=2 (baml.Map.set) - 211 pop 1 - - 82 212 load_var 5 (definitions) - 213 load_const 38 (null) - 214 call 672 ntypeargs=0 (baml.ops.equals_equals) - 215 unary_op ! - 216 pop_jump_if_false +8 (to 224) - - 83 217 load_type 1 - 218 load_type 2 - 219 load_var 18 (envelope) - 220 load_const 39 ("$defs") - 221 load_var 5 (definitions) - 222 call 37 ntypeargs=2 (baml.Map.set) - 223 pop 1 - - 85 224 load_var 18 (envelope) - 225 store_var 2 (_0) - 226 load_var 2 (_0) - 227 return -} - -function claude_code.internal.invoke(c: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 237 0 load_const 0 ("") - 1 load_var 2 (input) - 2 load_field 0 (prompt) - 3 call_indirect - 4 call 909 ntypeargs=0 (ai.Prompt.text) - 5 store_var 4 (instructions) - - 238 6 load_var 2 (input) - 7 load_field 2 (toolbox) - 8 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 9 unary_op ! - 10 store_var_load_var 5 (has_tools) - - 239 11 pop_jump_if_false +2 (to 13) - 12 jump +6 (to 18) - - 242 13 load_var 2 (input) - 14 load_field 3 (output_type) - 15 sys_op 365 (baml.json.schema) - 16 store_var 6 (schema) - 17 jump +9 (to 26) - - 240 18 load_var 2 (input) - 19 load_field 3 (output_type) - 20 call 1355 ntypeargs=0 (claude_code.internal.envelope_schema) - 21 store_var 7 (_11) - 22 load_type 1 - 23 load_var 7 (_11) - 24 call 355 ntypeargs=1 (baml.json.to_json) - 25 store_var 6 (schema) - - 244 26 load_var 5 (has_tools) - 27 pop_jump_if_false +2 (to 29) - 28 jump +17 (to 45) - - 247 29 load_type 2 - 30 load_var 4 (instructions) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 14 (_29) - 33 load_var 2 (input) - 34 load_field 1 (journal) - 35 call 1354 ntypeargs=0 (claude_code.internal.transcript_text) - 36 store_var 16 (_33) - 37 load_type 2 - 38 load_var 16 (_33) - 39 call 138 ntypeargs=1 (baml.String.from) - 40 store_var 15 (_32) - 41 load_var2 14 15 - 42 bin_op + - 43 store_var 8 (prompt_text) - - 244 44 jump +26 (to 70) - - 245 45 load_type 2 - 46 load_var 4 (instructions) - 47 call 138 ntypeargs=1 (baml.String.from) - 48 store_var 9 (_18) - 49 load_var 2 (input) - 50 load_field 1 (journal) - 51 call 1354 ntypeargs=0 (claude_code.internal.transcript_text) - 52 store_var 11 (_22) - 53 load_type 2 - 54 load_var 11 (_22) - 55 call 138 ntypeargs=1 (baml.String.from) - 56 store_var 10 (_21) - 57 load_var 2 (input) - 58 load_field 2 (toolbox) - 59 call 1357 ntypeargs=0 (claude_code.internal.tool_protocol) - 60 store_var 13 (_26) - 61 load_type 2 - 62 load_var 13 (_26) - 63 call 138 ntypeargs=1 (baml.String.from) - 64 store_var 12 (_25) - 65 load_var2 9 10 - 66 bin_op + - 67 load_var 12 (_25) - 68 bin_op + - 69 store_var 8 (prompt_text) - - 251 70 load_type 2 - 71 load_var 1 (c) - 72 load_field 1 (model) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 17 (_41) - 75 load_var 8 (prompt_text) - 76 call 139 ntypeargs=0 (baml.String.length) - 77 store_var 19 (_45) - 78 load_type 3 - 79 load_var 19 (_45) - 80 call 138 ntypeargs=1 (baml.String.from) - 81 store_var 18 (_44) - 82 load_var 2 (input) - 83 load_field 2 (toolbox) - 84 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 85 container_len - 86 store_var 21 (_48) - 87 load_type 3 - 88 load_var 21 (_48) - 89 call 138 ntypeargs=1 (baml.String.from) - 90 store_var 20 (_47) - - 250 91 load_const 4 ("$baml_log") - 92 load_const 5 ("info") - - 251 93 load_const 6 ("claude-code invoke: model=") - 94 load_var 17 (_41) - 95 bin_op + - 96 load_const 7 (" prompt_chars=") - 97 bin_op + - 98 load_var 18 (_44) - 99 bin_op + - 100 load_const 8 (" baml_tools=") - 101 bin_op + - 102 load_var 20 (_47) - 103 bin_op + - 104 load_const 9 ("level") - 105 load_const 10 ("data") - 106 load_type 2 - 107 load_type 11 - 108 alloc_map 2 - - 250 109 send_event - 110 pop 1 - - 253 111 load_type 2 - 112 alloc_array 0 - 113 store_var 22 (args) - - 254 114 load_type 2 - 115 load_var 22 (args) - 116 load_const 12 ("-p") - 117 call 4 ntypeargs=1 (baml.Array.push) - 118 pop 1 - - 255 119 load_type 2 - 120 load_var 22 (args) - 121 load_const 13 ("--output-format") - 122 call 4 ntypeargs=1 (baml.Array.push) - 123 pop 1 - - 256 124 load_type 2 - 125 load_var 22 (args) - 126 load_const 14 ("stream-json") - 127 call 4 ntypeargs=1 (baml.Array.push) - 128 pop 1 - - 257 129 load_type 2 - 130 load_var 22 (args) - 131 load_const 15 ("--verbose") - 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - - 258 134 load_type 2 - 135 load_var 22 (args) - 136 load_const 16 ("--model") - 137 call 4 ntypeargs=1 (baml.Array.push) - 138 pop 1 - - 259 139 load_type 2 - 140 load_var2 22 1 - 141 load_field 1 (model) - 142 call 4 ntypeargs=1 (baml.Array.push) - 143 pop 1 - - 260 144 load_type 2 - 145 load_var 22 (args) - 146 load_const 17 ("--permission-mode") - 147 call 4 ntypeargs=1 (baml.Array.push) - 148 pop 1 - - 261 149 load_type 2 - 150 load_var2 22 1 - 151 load_field 4 (permission_mode) - 152 call 4 ntypeargs=1 (baml.Array.push) - 153 pop 1 - - 262 154 load_type 2 - 155 load_var 22 (args) - 156 load_const 18 ("--no-session-persistence") - 157 call 4 ntypeargs=1 (baml.Array.push) - 158 pop 1 - - 263 159 load_type 2 - 160 load_var 22 (args) - 161 load_const 19 ("--tools") - 162 call 4 ntypeargs=1 (baml.Array.push) - 163 pop 1 - - 264 164 load_type 2 - 165 load_var 1 (c) - 166 load_field 5 (harness_tools) - 167 load_const 20 (",") - 168 call 15 ntypeargs=1 (baml.Array.join) - 169 store_var 23 (_76) - 170 load_type 2 - 171 load_var2 22 23 - 172 call 4 ntypeargs=1 (baml.Array.push) - 173 pop 1 - - 271 174 load_var 1 (c) - 175 call 1361 ntypeargs=0 (claude_code.internal.mcp_config_json) - 176 store_var 24 (_81) - 177 load_var 24 (_81) - 178 narrow_bind 21 24 - 179 pop_jump_if_false +31 (to 210) - 180 load_var 24 (_81) - 181 store_var 25 (mcp) - - 272 182 load_type 2 - 183 load_var 22 (args) - 184 load_const 22 ("--mcp-config") - 185 call 4 ntypeargs=1 (baml.Array.push) - 186 pop 1 - - 273 187 load_type 2 - 188 load_var2 22 25 - 189 call 4 ntypeargs=1 (baml.Array.push) - 190 pop 1 - - 274 191 load_type 2 - 192 load_var 22 (args) - 193 load_const 23 ("--strict-mcp-config") - 194 call 4 ntypeargs=1 (baml.Array.push) - 195 pop 1 - - 275 196 load_var 1 (c) - 197 call 1362 ntypeargs=0 (claude_code.internal.allowed_mcp_tools) - 198 store_var 27 (_93) - 199 load_type 2 - 200 load_var 27 (_93) - 201 call 138 ntypeargs=1 (baml.String.from) - 202 store_var 26 (_92) - 203 load_type 2 - 204 load_var 22 (args) - 205 load_const 24 ("--allowedTools=") - 206 load_var 26 (_92) - 207 bin_op + - 208 call 4 ntypeargs=1 (baml.Array.push) - 209 pop 1 - - 277 210 load_type 2 - 211 load_var 22 (args) - 212 load_const 25 ("--json-schema") - 213 call 4 ntypeargs=1 (baml.Array.push) - 214 pop 1 - - 278 215 load_var 6 (schema) - 216 call 351 ntypeargs=0 (baml.json.stringify) - 217 store_var 28 (_99) - 218 load_type 2 - 219 load_var2 22 28 - 220 call 4 ntypeargs=1 (baml.Array.push) - 221 pop 1 - - 279 222 load_type 2 - 223 load_var2 22 8 - 224 call 4 ntypeargs=1 (baml.Array.push) - 225 pop 1 - - 282 226 load_var 1 (c) - 227 load_field 0 (executable) - - 283 228 load_var2 22 1 - - 284 229 load_field 2 (cwd) - 230 load_const 26 (null) - 231 load_var 1 (c) - 232 load_field 3 (timeout_ms) - 233 load_const 26 (null) - 234 load_const 26 (null) - 235 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) - 236 sys_op 273 (baml.sys.start_process) - 237 store_var 29 (p) - 238 jump +18 (to 256) - - 281 239 load_var 30 (e) - 240 throw_if_panic - - 289 241 load_type 27 - 242 load_var 30 (e) - 243 call 138 ntypeargs=1 (baml.String.from) - 244 store_var 32 (_115) - 245 load_type 2 - 246 load_var 32 (_115) - 247 call 138 ntypeargs=1 (baml.String.from) - 248 store_var 31 (_114) - - 287 249 load_const 28 ("claude-code") - - 289 250 load_const 29 ("the Claude Code CLI could not start: ") - 251 load_var 31 (_114) - 252 bin_op + - 253 load_const 26 (null) - 254 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 255 throw - - 298 256 load_var 29 (p) - 257 sys_op 268 (baml.sys.Process.close_stdin) - 258 pop 1 - 259 jump +3 (to 262) - 260 load_var 35 (e) - 261 throw_if_panic - - 303 262 load_var 29 (p) - 263 call 1358 ntypeargs=0 (claude_code.internal._read_result) - 264 store_var 36 (result) - - 304 265 load_var 29 (p) - 266 sys_op 269 (baml.sys.Process.wait) - 267 store_var 37 (exit) - 268 jump +18 (to 286) - 269 load_var 38 (e) - 270 throw_if_panic - - 308 271 load_type 30 - 272 load_var 38 (e) - 273 call 138 ntypeargs=1 (baml.String.from) - 274 store_var 40 (_129) - 275 load_type 2 - 276 load_var 40 (_129) - 277 call 138 ntypeargs=1 (baml.String.from) - 278 store_var 39 (_128) - - 306 279 load_const 31 ("claude-code") - - 308 280 load_const 32 ("the Claude Code CLI did not terminate cleanly: ") - 281 load_var 39 (_128) - 282 bin_op + - 283 load_const 26 (null) - 284 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 285 throw - - 313 286 load_var 37 (exit) - 287 call 262 ntypeargs=0 (baml.sys.ProcessExit.ok) - 288 unary_op ! - 289 pop_jump_if_false +2 (to 291) - 290 jump +257 (to 547) - - 322 291 load_type 33 - 292 load_var 36 (result) - 293 load_const 34 (".is_error") - 294 load_const 35 (false) - 295 call 364 ntypeargs=1 (baml.json.path_or) - 296 pop_jump_if_false +2 (to 298) - 297 jump +237 (to 534) - - 330 298 load_type 2 - 299 load_var 36 (result) - 300 load_const 36 (".subtype") - 301 load_const 37 ("?") - 302 call 364 ntypeargs=1 (baml.json.path_or) - 303 store_var 45 (_154) - 304 load_type 2 - 305 load_var 45 (_154) - 306 call 138 ntypeargs=1 (baml.String.from) - 307 store_var 44 (_153) - 308 load_type 38 - 309 load_var 36 (result) - 310 load_const 39 (".total_cost_usd") - 311 load_const 40 (0.0) - 312 call 364 ntypeargs=1 (baml.json.path_or) - 313 store_var 47 (_159) - 314 load_type 38 - 315 load_var 47 (_159) - 316 call 138 ntypeargs=1 (baml.String.from) - 317 store_var 46 (_158) - 318 load_type 2 - 319 load_var 36 (result) - 320 load_const 41 (".session_id") - 321 load_const 42 ("?") - 322 call 364 ntypeargs=1 (baml.json.path_or) - 323 store_var 49 (_164) - 324 load_type 2 - 325 load_var 49 (_164) - 326 call 138 ntypeargs=1 (baml.String.from) - 327 store_var 48 (_163) - - 329 328 load_const 43 ("$baml_log") - 329 load_const 44 ("info") - - 330 330 load_const 45 ("claude-code result: subtype=") - 331 load_var 44 (_153) - 332 bin_op + - 333 load_const 46 (" cost_usd=") - 334 bin_op + - 335 load_var 46 (_158) - 336 bin_op + - 337 load_const 47 (" session=") - 338 bin_op + - 339 load_var 48 (_163) - 340 bin_op + - 341 load_const 48 ("level") - 342 load_const 49 ("data") - 343 load_type 2 - 344 load_type 11 - 345 alloc_map 2 - - 329 346 send_event - 347 pop 1 - - 332 348 load_type 50 - 349 load_var 36 (result) - 350 load_const 51 (".structured_output") - 351 call 363 ntypeargs=1 (baml.json.path) - 352 store_var 50 (structured) - 353 jump +20 (to 373) - 354 load_var 51 (e) - 355 throw_if_panic - - 334 356 load_type 2 - 357 load_var 36 (result) - 358 load_const 52 (".result") - 359 load_const 53 ("") - 360 call 364 ntypeargs=1 (baml.json.path_or) - 361 call 350 ntypeargs=0 (baml.json.parse) - 362 store_var 50 (structured) - 363 jump +10 (to 373) - 364 load_var 52 (inner) - 365 throw_if_panic - - 338 366 load_var 36 (result) - 367 call 351 ntypeargs=0 (baml.json.stringify) - 368 store_var 53 (_177) - - 336 369 load_const 54 ("claude-code") - 370 load_var 53 (_177) - 371 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 372 throw - - 346 373 load_type 3 - 374 load_var 36 (result) - 375 load_const 55 (".usage.input_tokens") - 376 load_const 56 (0) - 377 call 364 ntypeargs=1 (baml.json.path_or) - 378 store_var 55 (_180) - - 347 379 load_type 3 - 380 load_var 36 (result) - 381 load_const 57 (".usage.output_tokens") - 382 load_const 56 (0) - 383 call 364 ntypeargs=1 (baml.json.path_or) - 384 store_var 56 (_183) - - 348 385 load_type 58 - 386 load_var 36 (result) - 387 load_const 59 (".usage.cache_read_input_tokens") - 388 load_const 26 (null) - 389 call 364 ntypeargs=1 (baml.json.path_or) - 390 store_var 57 (_186) - - 345 391 load_var2 55 56 - 392 load_var 57 (_186) - 393 load_const 26 (null) - 394 init_instance 4 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 395 store_var 54 (usage) - - 352 396 load_type 60 - 397 alloc_array 0 - 398 store_var 58 (content) - - 353 399 load_const 56 (ai.content.StopReason.Complete) - 400 alloc_variant 774 (ai.content.StopReason) - 401 store_var 59 (stop) - - 354 402 load_var 5 (has_tools) - 403 pop_jump_if_false +2 (to 405) - 404 jump +10 (to 414) - - 382 405 load_var 50 (structured) - 406 call 351 ntypeargs=0 (baml.json.stringify) - 407 store_var 77 (_247) - 408 load_type 60 - 409 load_var2 58 77 - 410 init_instance 5 (ai.content.Text .text) - 411 call 4 ntypeargs=1 (baml.Array.push) - 412 pop 1 - 413 jump +112 (to 525) - - 355 414 load_type 50 - 415 load_var 36 (result) - 416 load_const 61 (".structured_output.outcome") - 417 load_var 50 (structured) - 418 call 364 ntypeargs=1 (baml.json.path_or) - 419 store_var 60 (outcome) - - 356 420 load_type 62 - 421 load_var 60 (outcome) - 422 load_const 63 (".calls") - 423 load_const 26 (null) - 424 call 364 ntypeargs=1 (baml.json.path_or) - - 357 425 store_var 61 (_199) - 426 load_var 61 (_199) - 427 narrow_bind 64 61 - 428 pop_jump_if_false +2 (to 430) - 429 jump +10 (to 439) - - 379 430 load_var 60 (outcome) - 431 call 351 ntypeargs=0 (baml.json.stringify) - 432 store_var 76 (_242) - 433 load_type 60 - 434 load_var2 58 76 - 435 init_instance 6 (ai.content.Text .text) - 436 call 4 ntypeargs=1 (baml.Array.push) - 437 pop 1 - 438 jump +87 (to 525) - - 357 439 load_var 61 (_199) - 440 store_var 62 (call_list) - - 358 441 load_const 56 (0) - 442 store_var 63 (i) - - 359 443 load_var 62 (call_list) - 444 load_type 65 - 445 load_const 66 ("iter") - 446 virtual_call nargs=1 ntypeargs=0 - 447 store_var 64 (_203) - 448 load_var 64 (_203) - 449 load_type 67 - 450 load_const 68 ("next") - 451 virtual_call nargs=1 ntypeargs=0 - 452 store_var 65 (_204) - 453 load_var 65 (_204) - 454 is_type 69 - 455 pop_jump_if_false +2 (to 457) - 456 jump +66 (to 522) - 457 load_var 65 (_204) - 458 store_var 66 (raw_call) - - 363 459 load_var 2 (input) - 460 load_field 1 (journal) - 461 call 905 ntypeargs=0 (ai.Journal.entries) - 462 container_len - 463 store_var 69 (_214) - 464 load_type 3 - 465 load_var 69 (_214) - 466 call 138 ntypeargs=1 (baml.String.from) - 467 store_var 68 (_213) - 468 load_type 3 - 469 load_var 63 (i) - 470 call 138 ntypeargs=1 (baml.String.from) - 471 store_var 70 (_218) - - 360 472 load_type 2 - - 361 473 load_var 66 (raw_call) - 474 load_const 70 (".id") - - 363 475 load_const 71 ("cc_call_") - 476 load_var 68 (_213) - 477 bin_op + - 478 load_const 72 ("_") - 479 bin_op + - 480 load_var 70 (_218) - 481 bin_op + - - 360 482 call 364 ntypeargs=1 (baml.json.path_or) - 483 store_var 67 (id) - - 365 484 load_type 2 - 485 load_var 66 (raw_call) - 486 load_const 73 (".name") - 487 load_const 74 ("") - 488 call 364 ntypeargs=1 (baml.json.path_or) - 489 store_var 71 (name) - - 367 490 load_type 50 - 491 load_var 66 (raw_call) - 492 load_const 75 (".args") - 493 load_type 2 - 494 load_type 50 - 495 alloc_map 0 - 496 call 364 ntypeargs=1 (baml.json.path_or) - 497 store_var 74 (_227) - - 366 498 load_type 1 - 499 load_var 74 (_227) - 500 call 358 ntypeargs=1 (baml.json.from_json) - 501 store_var 72 (call_args) - 502 jump +9 (to 511) - 503 load_var 73 (e) - 504 throw_if_panic - - 370 505 load_type 2 - 506 load_type 11 - 507 alloc_map 0 - 508 store_var 75 (empty) - - 371 509 load_var 75 (empty) - 510 store_var 72 (call_args) - - 374 511 load_type 60 - 512 load_var2 58 67 - 513 load_var2 71 72 - 514 init_instance 7 (ai.content.ToolUse .id, .name, .args) - 515 call 4 ntypeargs=1 (baml.Array.push) - 516 pop 1 - - 375 517 load_var 63 (i) - 518 load_const 21 (1) - 519 add_int - 520 store_var 63 (i) - - 359 521 jump -73 (to 448) - - 377 522 load_const 21 (ai.content.StopReason.ToolUse) - 523 alloc_variant 774 (ai.content.StopReason) - 524 store_var 59 (stop) - - 384 525 load_var2 58 59 - 526 load_var 54 (usage) - 527 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) - 528 store_var 3 (_0) - - 295 529 load_var 29 (p) - 530 sys_op 271 (baml.sys.Process.close) - 531 pop 1 - 532 load_var 3 (_0) - 533 return - - 325 534 load_type 2 - 535 load_var 36 (result) - 536 load_const 76 (".subtype") - 537 load_const 77 ("error") - 538 call 364 ntypeargs=1 (baml.json.path_or) - 539 store_var 42 (_143) - - 326 540 load_var 36 (result) - 541 call 351 ntypeargs=0 (baml.json.stringify) - 542 store_var 43 (_146) - - 323 543 load_const 78 ("claude-code") - 544 load_var2 42 43 - 545 init_instance 9 (ai.errors.Refused .provider, .reason, .raw_body) - 546 throw - - 317 547 load_type 3 - 548 load_var 37 (exit) - 549 load_field 0 (exit_code) - 550 call 138 ntypeargs=1 (baml.String.from) - 551 store_var 41 (_136) - 552 jump +6 (to 558) - - 295 553 load_var 29 (p) - 554 sys_op 271 (baml.sys.Process.close) - 555 pop 1 - - 231 556 load_var 33 (_118) - 557 rethrow - - 314 558 load_const 79 ("claude-code") - 559 load_const 26 (null) - - 317 560 load_const 80 ("the Claude Code CLI exited with code ") - 561 load_var 41 (_136) - 562 bin_op + - 563 load_const 26 (null) - 564 init_instance 10 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 565 throw -} - -function claude_code.internal.mcp_config_json(c: claude_code.ClaudeCodeClient) -> string | null { - 211 0 load_var 1 (c) - 1 load_field 6 (mcp_servers) - 2 container_len - 3 store_var 2 (_3) - 4 load_var 2 (_3) - 5 load_const 0 (0) - 6 cmp_int_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 214 9 load_type 1 - 10 load_type 2 - 11 alloc_map 0 - 12 store_var 3 (wrapper) - - 215 13 load_type 1 - 14 load_type 2 - 15 load_var 3 (wrapper) - 16 load_const 3 ("mcpServers") - 17 load_var 1 (c) - 18 load_field 6 (mcp_servers) - 19 call 37 ntypeargs=2 (baml.Map.set) - 20 pop 1 - - 216 21 load_type 4 - 22 load_var 3 (wrapper) - 23 call 355 ntypeargs=1 (baml.json.to_json) - 24 call 351 ntypeargs=0 (baml.json.stringify) - 25 jump +2 (to 27) - - 212 26 load_const 5 (null) - 27 return -} - -function claude_code.internal.tool_protocol(tb: ai.tools.Toolbox) -> string { - 99 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (catalog) - - 100 3 load_var 1 (tb) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +41 (to 58) - 18 load_var 5 (_5) - 19 store_var 6 (t) - - 102 20 load_type 0 - 21 load_var 6 (t) - 22 load_field 0 (name) - 23 call 138 ntypeargs=1 (baml.String.from) - 24 store_var 7 (_16) - 25 load_type 0 - 26 load_var 6 (t) - 27 load_field 1 (description) - 28 call 138 ntypeargs=1 (baml.String.from) - 29 store_var 8 (_19) - 30 load_type 6 - 31 load_var 6 (t) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 call 351 ntypeargs=0 (baml.json.stringify) - 35 store_var 10 (_23) - 36 load_type 0 - 37 load_var 10 (_23) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 9 (_22) - - 101 40 load_type 0 - 41 load_var 3 (catalog) - - 102 42 load_const 7 ("{\"name\": \"") - 43 load_var 7 (_16) - 44 bin_op + - 45 load_const 8 ("\", \"description\": \"") - 46 bin_op + - 47 load_var 8 (_19) - 48 bin_op + - 49 load_const 9 ("\", \"parameters\": ") - 50 bin_op + - 51 load_var 9 (_22) - 52 bin_op + - 53 load_const 10 ("}") - 54 bin_op + - - 101 55 call 4 ntypeargs=1 (baml.Array.push) - 56 pop 1 - 57 jump -48 (to 9) - - 121 58 load_type 0 - 59 load_var 3 (catalog) - 60 load_const 11 (", ") - 61 call 15 ntypeargs=1 (baml.Array.join) - 62 store_var 12 (_31) - - 105 63 load_type 0 - 64 load_var 12 (_31) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 11 (_30) - 67 load_const 12 ("\n\nThe output contract is one object with an outcome field. Set outcome\nto either the final result or a tool request. The tools in the catalog\nbelow are NOT installed in your environment — never attempt to invoke\nthem directly; any such attempt fails. The ONLY way to run one is to\nfinish your reply with outcome set to\n{\"calls\": [{\"id\": \"\", \"name\": \"\", \"args\": {...}}]};\nthe caller executes the calls and re-invokes you with their results in\nthe conversation. If the Conversation so far section shows no tool\nresults yet, your outcome MUST be a calls request — never invent data a\ntool can provide. After tool results appear in the conversation, use\nthem; the Conversation so far section is authoritative. A tool result\nwith is_error=false means that call already ran — never repeat the same\nsuccessful tool call. Request only tools that are still necessary, or\nreturn the final result.\n\nApplication tool catalog (request via outcome.calls only):\n[") - 68 load_var 11 (_30) - 69 bin_op + - 70 load_const 13 ("]") - 71 bin_op + - 72 store_var 2 (_0) - 73 load_var 2 (_0) - 74 return -} - -function claude_code.internal.transcript_text(j: ai.Journal) -> string { - 7 0 load_type 0 - 1 alloc_array 0 - 2 store_var 2 (lines) - - 8 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_4) - 9 load_var 3 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_5) - 14 load_var 4 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +173 (to 190) - 18 load_var 4 (_5) - 19 store_var 5 (e) - - 9 20 load_var 5 (e) - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 narrow_bind 6 6 - 24 pop_jump_if_false +2 (to 26) - 25 jump +150 (to 175) - 26 load_var 5 (e) - 27 store_var 9 (_17) - 28 load_var 9 (_17) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +60 (to 91) - 32 load_var 5 (e) - 33 store_var 23 (_55) - 34 load_var 23 (_55) - 35 narrow_bind 8 23 - 36 pop_jump_if_false +2 (to 38) - 37 jump +30 (to 67) - 38 load_var 5 (e) - 39 store_var 27 (_68) - 40 load_var 27 (_68) - 41 narrow_bind 9 27 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 27 (_68) - 44 store_var 28 (failed) - - 34 45 load_type 0 - 46 load_var 28 (failed) - 47 load_field 0 (id) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 29 (_74) - 50 load_type 0 - 51 load_var 28 (failed) - 52 load_field 1 (message) - 53 call 138 ntypeargs=1 (baml.String.from) - 54 store_var 30 (_77) - 55 load_type 0 - 56 load_var 2 (lines) - 57 load_const 10 ("tool result id=") - 58 load_var 29 (_74) - 59 bin_op + - 60 load_const 11 (" is_error=true: ") - 61 bin_op + - 62 load_var 30 (_77) - 63 bin_op + - 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - 66 jump -57 (to 9) - - 9 67 load_var 23 (_55) - 68 store_var 24 (done) - - 31 69 load_type 0 - 70 load_var 24 (done) - 71 load_field 0 (id) - 72 call 138 ntypeargs=1 (baml.String.from) - 73 store_var 25 (_61) - 74 load_type 0 - 75 load_var 24 (done) - 76 load_field 1 (output) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 26 (_64) - 79 load_type 0 - 80 load_var 2 (lines) - 81 load_const 12 ("tool result id=") - 82 load_var 25 (_61) - 83 bin_op + - 84 load_const 13 (" is_error=false: ") - 85 bin_op + - 86 load_var 26 (_64) - 87 bin_op + - 88 call 4 ntypeargs=1 (baml.Array.push) - 89 pop 1 - 90 jump -81 (to 9) - - 9 91 load_var 9 (_17) - 92 store_var_load_var 10 (a) - - 14 93 load_field 0 (content) - 94 load_type 14 - 95 load_const 15 ("iter") - 96 virtual_call nargs=1 ntypeargs=0 - 97 store_var 11 (_20) - 98 load_var 11 (_20) - 99 load_type 16 - 100 load_const 17 ("next") - 101 virtual_call nargs=1 ntypeargs=0 - 102 store_var 12 (_21) - 103 load_var 12 (_21) - 104 is_type 5 - 105 pop_jump_if_false +2 (to 107) - 106 jump -97 (to 9) - 107 load_var 12 (_21) - 108 store_var 13 (b) - - 15 109 load_var 13 (b) - 110 store_var 14 (_25) - 111 load_var 14 (_25) - 112 narrow_bind 18 14 - 113 pop_jump_if_false +2 (to 115) - 114 jump +46 (to 160) - 115 load_var 13 (b) - 116 store_var 17 (_33) - 117 load_var 17 (_33) - 118 narrow_bind 19 17 - 119 pop_jump_if_false -21 (to 98) - 120 load_var 17 (_33) - 121 store_var 18 (c) - - 21 122 load_type 0 - 123 load_var 18 (c) - 124 load_field 0 (id) - 125 call 138 ntypeargs=1 (baml.String.from) - 126 store_var 19 (_42) - 127 load_type 0 - 128 load_var 18 (c) - 129 load_field 1 (name) - 130 call 138 ntypeargs=1 (baml.String.from) - 131 store_var 20 (_45) - 132 load_type 20 - 133 load_var 18 (c) - 134 load_field 2 (args) - 135 call 355 ntypeargs=1 (baml.json.to_json) - 136 call 351 ntypeargs=0 (baml.json.stringify) - 137 store_var 22 (_49) - 138 load_type 0 - 139 load_var 22 (_49) - 140 call 138 ntypeargs=1 (baml.String.from) - 141 store_var 21 (_48) - - 20 142 load_type 0 - 143 load_var 2 (lines) - - 21 144 load_const 21 ("assistant tool_call: {\"id\": \"") - 145 load_var 19 (_42) - 146 bin_op + - 147 load_const 22 ("\", \"name\": \"") - 148 bin_op + - 149 load_var 20 (_45) - 150 bin_op + - 151 load_const 23 ("\", \"args\": ") - 152 bin_op + - 153 load_var 21 (_48) - 154 bin_op + - 155 load_const 24 ("}") - 156 bin_op + - - 20 157 call 4 ntypeargs=1 (baml.Array.push) - 158 pop 1 - 159 jump -61 (to 98) - - 15 160 load_var 14 (_25) - 161 store_var 15 (t) - - 17 162 load_type 0 - 163 load_var 15 (t) - 164 load_field 0 (text) - 165 call 138 ntypeargs=1 (baml.String.from) - 166 store_var 16 (_29) - 167 load_type 0 - 168 load_var 2 (lines) - 169 load_const 25 ("assistant: ") - 170 load_var 16 (_29) - 171 bin_op + - 172 call 4 ntypeargs=1 (baml.Array.push) - 173 pop 1 - 174 jump -76 (to 98) - - 9 175 load_var 6 (_9) - 176 store_var 7 (u) - - 11 177 load_type 0 - 178 load_var 7 (u) - 179 load_field 0 (content) - 180 call 138 ntypeargs=1 (baml.String.from) - 181 store_var 8 (_13) - 182 load_type 0 - 183 load_var 2 (lines) - 184 load_const 26 ("user: ") - 185 load_var 8 (_13) - 186 bin_op + - 187 call 4 ntypeargs=1 (baml.Array.push) - 188 pop 1 - 189 jump -180 (to 9) - - 41 190 load_var 2 (lines) - 191 container_len - 192 store_var 31 (_82) - 193 load_var 31 (_82) - 194 load_const 27 (0) - 195 cmp_int_op == - 196 pop_jump_if_false +2 (to 198) - 197 jump +14 (to 211) - - 44 198 load_type 0 - 199 load_var 2 (lines) - 200 load_const 28 ("\n") - 201 call 15 ntypeargs=1 (baml.Array.join) - 202 store_var 33 (_84) - 203 load_type 0 - 204 load_var 33 (_84) - 205 call 138 ntypeargs=1 (baml.String.from) - 206 store_var 32 (_83) - 207 load_const 29 ("\n\nConversation so far:\n") - 208 load_var 32 (_83) - 209 bin_op + - - 41 210 jump +2 (to 212) - - 42 211 load_const 30 ("") - 212 return -} - -function google.GoogleClient.ai.Client.id(self: google.GoogleClient) -> string { - 125 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("google/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function google.GoogleClient.ai.Client.invoke(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 129 0 load_var2 1 2 - 1 call 1246 ntypeargs=0 (google.internal.gemini_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 130 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.GoogleClient.ai.stream.StreamingClient.invoke_stream(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 137 0 load_var2 1 2 - 1 call 1248 ntypeargs=0 (google.internal.gemini_invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 138 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.GoogleClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.GoogleClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 70 4 load_const 1 ("gemini-2.5-flash") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 71 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 72 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (request_body) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 73 22 load_const 2 (null) - 23 store_var 4 (request_body) - 24 load_var 5 (headers) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 74 28 load_const 2 (null) - 29 store_var 5 (headers) - 30 load_var 6 (query_params) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 75 34 load_const 2 (null) - 35 store_var 6 (query_params) - 36 load_var 7 (temperature) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 76 40 load_const 2 (null) - 41 store_var 7 (temperature) - 42 load_var 8 (max_output_tokens) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 77 46 load_const 2 (null) - 47 store_var 8 (max_output_tokens) - 48 load_var 9 (top_p) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 78 52 load_const 2 (null) - 53 store_var 9 (top_p) - 54 load_var 10 (top_k) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 79 58 load_const 2 (null) - 59 store_var 10 (top_k) - 60 load_var 11 (stop_sequences) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 80 64 load_const 2 (null) - 65 store_var 11 (stop_sequences) - 66 load_var 12 (response_modalities) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 81 70 load_const 2 (null) - 71 store_var 12 (response_modalities) - 72 load_var 13 (safety_settings) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 82 76 load_const 2 (null) - 77 store_var 13 (safety_settings) - - 84 78 load_var2 1 2 - 79 load_var2 3 4 - 80 load_var2 5 6 - 81 load_var2 7 8 - 82 load_var2 9 10 - 83 load_var2 11 12 - 84 load_var 13 (safety_settings) - 85 init_instance 0 (google.GoogleClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings) - 86 return -} - -function google.GoogleClient.resolved_api_key(self: google.GoogleClient) -> string { - 107 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("GOOGLE_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 113 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("GOOGLE_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 3 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - - 110 18 load_const 4 ("google") - 19 load_const 5 (null) - - 113 20 load_const 6 ("google needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 21 load_var 4 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 107 26 load_var 2 (_4) - 27 store_var 3 (k) - - 108 28 load_var 3 (k) - 29 return -} - -function google.GoogleClient.resolved_base_url(self: google.GoogleClient) -> string | null { - 120 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.SafetySetting.new(category: string, threshold: string) -> google.SafetySetting { - 22 0 load_var2 1 2 - 1 init_instance 0 (google.SafetySetting .category, .threshold) - 2 store_var 3 (_0) - 3 load_var 3 (_0) - 4 return -} - -function google.VertexClient.ai.Client.id(self: google.VertexClient) -> string { - 109 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("vertex/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function google.VertexClient.ai.Client.invoke(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 113 0 load_var2 1 2 - 1 call 1265 ntypeargs=0 (google.internal.vertex_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 114 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.VertexClient.ai.stream.StreamingClient.invoke_stream(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 121 0 load_var2 1 2 - 1 call 1267 ntypeargs=0 (google.internal.vertex_invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 122 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function google.VertexClient.new(model: string, project_id: string | null, location: string | null, credentials_json: string | null, credentials_file: string | null, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.VertexClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 57 4 load_const 1 ("gemini-2.5-flash") - 5 store_var 1 (model) - 6 load_var 2 (project_id) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 58 10 load_const 2 (null) - 11 store_var 2 (project_id) - 12 load_var 3 (location) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 59 16 load_const 2 (null) - 17 store_var 3 (location) - 18 load_var 4 (credentials_json) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 60 22 load_const 2 (null) - 23 store_var 4 (credentials_json) - 24 load_var 5 (credentials_file) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 61 28 load_const 2 (null) - 29 store_var 5 (credentials_file) - 30 load_var 6 (api_key) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 62 34 load_const 2 (null) - 35 store_var 6 (api_key) - 36 load_var 7 (base_url) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 63 40 load_const 2 (null) - 41 store_var 7 (base_url) - 42 load_var 8 (request_body) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 64 46 load_const 2 (null) - 47 store_var 8 (request_body) - 48 load_var 9 (headers) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 65 52 load_const 2 (null) - 53 store_var 9 (headers) - 54 load_var 10 (query_params) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 66 58 load_const 2 (null) - 59 store_var 10 (query_params) - 60 load_var 11 (temperature) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 67 64 load_const 2 (null) - 65 store_var 11 (temperature) - 66 load_var 12 (max_output_tokens) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 68 70 load_const 2 (null) - 71 store_var 12 (max_output_tokens) - 72 load_var 13 (top_p) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 69 76 load_const 2 (null) - 77 store_var 13 (top_p) - 78 load_var 14 (top_k) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 70 82 load_const 2 (null) - 83 store_var 14 (top_k) - 84 load_var 15 (stop_sequences) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 71 88 load_const 2 (null) - 89 store_var 15 (stop_sequences) - 90 load_var 16 (response_modalities) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 72 94 load_const 2 (null) - 95 store_var 16 (response_modalities) - 96 load_var 17 (safety_settings) - 97 load_const 0 () - 98 cmp_op == - 99 pop_jump_if_false +3 (to 102) - - 73 100 load_const 2 (null) - 101 store_var 17 (safety_settings) - - 75 102 load_var2 1 2 - 103 load_var2 3 4 - 104 load_var2 5 6 - 105 load_var2 7 8 - 106 load_var2 9 10 - 107 load_var2 11 12 - 108 load_var2 13 14 - 109 load_var2 15 16 - 110 load_var 17 (safety_settings) - 111 init_instance 0 (google.VertexClient .model, .project_id, .location, .credentials_json, .credentials_file, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings) - 112 return -} - -function google.VertexClient.resolved_api_key(self: google.VertexClient) -> string | null { - 99 0 load_var 1 (self) - 1 load_field 5 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.VertexClient.resolved_base_url(self: google.VertexClient) -> string | null { - 104 0 load_var 1 (self) - 1 load_field 6 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function google.internal.GmPart.of_file_data(data: google.internal.GmFileData) -> google.internal.GmPart { - 86 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_var 1 (data) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function google.internal.GmPart.of_function_call(call: google.internal.GmFunctionCall, signature: string | null) -> google.internal.GmPart { - 100 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_var 1 (call) - 4 load_const 0 (null) - 5 load_var 2 (signature) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 store_var 3 (_0) - 8 load_var 3 (_0) - 9 return -} - -function google.internal.GmPart.of_function_response(response: google.internal.GmFunctionResponse) -> google.internal.GmPart { - 111 0 load_const 0 (null) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_var 1 (response) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function google.internal.GmPart.of_inline_data(data: google.internal.GmInlineData) -> google.internal.GmPart { - 75 0 load_const 0 (null) - 1 load_var 1 (data) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function google.internal.GmPart.of_text(text: string) -> google.internal.GmPart { - 64 0 load_var 1 (text) - 1 load_const 0 (null) - 2 load_const 0 (null) - 3 load_const 0 (null) - 4 load_const 0 (null) - 5 load_const 0 (null) - 6 init_instance 0 (google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature) - 7 store_var 2 (_0) - 8 load_var 2 (_0) - 9 return -} - -function google.internal._gm_apply_headers(headers: map, extra: map | null) -> map { - 339 0 load_var 2 (extra) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 345 6 load_var 1 (headers) - - 339 7 jump +43 (to 50) - 8 load_var 3 (_3) - 9 store_var 4 (items) - - 340 10 load_type 1 - 11 load_type 1 - 12 load_var 4 (items) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_8) - 18 load_var 5 (_8) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 6 (_9) - 23 load_var 6 (_9) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +23 (to 49) - 27 load_var 6 (_9) - 28 store_var 7 (name) - - 341 29 load_var 7 (name) - 30 call 142 ntypeargs=0 (baml.String.to_lower_case) - 31 store_var 8 (_14) - 32 load_type 1 - 33 load_type 1 - 34 load_var2 4 7 - 35 call 38 ntypeargs=2 (baml.Map.get) - 36 store_var_load_var 9 (_16) - 37 load_const 7 (null) - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - 40 load_const 8 ("") - 41 store_var 9 (_16) - 42 load_type 1 - 43 load_type 1 - 44 load_var2 1 8 - 45 load_var 9 (_16) - 46 call 37 ntypeargs=2 (baml.Map.set) - 47 pop 1 - 48 jump -30 (to 18) - - 343 49 load_var 1 (headers) - 50 return -} - -function google.internal._gm_apply_query(url: string, params: map | null) -> string { - 316 0 load_var 2 (params) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 328 6 load_var 1 (url) - - 316 7 jump +77 (to 84) - 8 load_var 3 (_3) - 9 store_var 4 (items) - - 317 10 load_var 1 (url) - 11 store_var 5 (out) - - 318 12 load_type 1 - 13 load_type 1 - 14 load_var 4 (items) - 15 call 35 ntypeargs=2 (baml.Map.keys) - 16 load_type 2 - 17 load_const 3 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 6 (_9) - 20 load_var 6 (_9) - 21 load_type 4 - 22 load_const 5 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 7 (_10) - 25 load_var 7 (_10) - 26 is_type 6 - 27 pop_jump_if_false +2 (to 29) - 28 jump +55 (to 83) - 29 load_var 7 (_10) - 30 store_var 8 (name) - - 319 31 load_var 5 (out) - 32 load_const 7 ("?") - 33 call 147 ntypeargs=0 (baml.String.includes) - 34 pop_jump_if_false +2 (to 36) - 35 jump +4 (to 39) - - 322 36 load_const 8 ("?") - 37 store_var 9 (separator) - - 319 38 jump +3 (to 41) - - 320 39 load_const 9 ("&") - 40 store_var 9 (separator) - - 324 41 load_type 1 - 42 load_var 5 (out) - 43 call 138 ntypeargs=1 (baml.String.from) - 44 store_var 10 (_19) - 45 load_type 1 - 46 load_var 9 (separator) - 47 call 138 ntypeargs=1 (baml.String.from) - 48 store_var 11 (_22) - 49 load_var 8 (name) - 50 call 1220 ntypeargs=0 (google.internal._gm_encode_query) - 51 store_var 13 (_26) - 52 load_type 1 - 53 load_var 13 (_26) - 54 call 138 ntypeargs=1 (baml.String.from) - 55 store_var 12 (_25) - 56 load_type 1 - 57 load_type 1 - 58 load_var2 4 8 - 59 call 38 ntypeargs=2 (baml.Map.get) - 60 store_var_load_var 16 (_32) - 61 load_const 10 (null) - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - 64 load_const 11 ("") - 65 store_var 16 (_32) - 66 load_var 16 (_32) - 67 call 1220 ntypeargs=0 (google.internal._gm_encode_query) - 68 store_var 15 (_30) - 69 load_type 1 - 70 load_var 15 (_30) - 71 call 138 ntypeargs=1 (baml.String.from) - 72 store_var 14 (_29) - 73 load_var2 10 11 - 74 bin_op + - 75 load_var 12 (_25) - 76 bin_op + - 77 load_const 12 ("=") - 78 bin_op + - 79 load_var 14 (_29) - 80 bin_op + - 81 store_var 5 (out) - - 318 82 jump -62 (to 20) - - 326 83 load_var 5 (out) - 84 return -} - -function google.internal._gm_call_id_signature(id: string) -> string | null { - 549 0 call 1230 ntypeargs=0 (google.internal._gm_sig_marker) - 1 store_var 2 (marker) - - 550 2 load_var2 1 2 - 3 call 155 ntypeargs=0 (baml.String.index_of) - 4 store_var 3 (_5) - 5 load_var 3 (_5) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +3 (to 11) - - 553 9 load_const 1 (null) - - 550 10 jump +16 (to 26) - 11 load_var 3 (_5) - 12 store_var 4 (at) - - 551 13 load_var 4 (at) - 14 store_var 6 (_8) - 15 load_var 2 (marker) - 16 call 139 ntypeargs=0 (baml.String.length) - 17 load_var 6 (_8) - 18 add_int - 19 store_var 5 (_7) - 20 load_var 1 (id) - 21 call 139 ntypeargs=0 (baml.String.length) - 22 store_var 7 (_10) - 23 load_var2 1 5 - 24 load_var 7 (_10) - 25 call 153 ntypeargs=0 (baml.String.slice) - 26 return -} - -function google.internal._gm_decode_batch(batch: string, provider: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 973 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 974 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +269 (to 286) - 18 load_var 6 (_6) - 19 store_var_load_var 7 (raw) - - 975 20 load_field 1 (data) - 21 store_var_load_var 9 (_12) - 22 load_const 6 (null) - 23 cmp_op == - 24 pop_jump_if_false +3 (to 27) - 25 load_const 7 ("") - 26 store_var 9 (_12) - 27 load_var 9 (_12) - 28 call 144 ntypeargs=0 (baml.String.trim) - 29 store_var 8 (payload) - - 978 30 load_var 8 (payload) - 31 load_const 8 ("") - 32 cmp_op == - 33 jump_if_false +2 (to 35) - 34 jump +5 (to 39) - 35 pop 1 - 36 load_var 8 (payload) - 37 load_const 9 ("[DONE]") - 38 cmp_op == - 39 pop_jump_if_false +2 (to 41) - 40 jump -31 (to 9) - - 981 41 load_type 10 - 42 load_var 8 (payload) - 43 call 357 ntypeargs=1 (baml.json.from_string) - 44 store_var 10 (resp) - 45 jump +6 (to 51) - 46 load_var 11 (e) - 47 throw_if_panic - - 983 48 load_var2 2 8 - 49 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 50 throw - - 989 51 load_var 10 (resp) - 52 load_field 5 (error) - 53 store_var 12 (_26) - 54 load_var 12 (_26) - 55 narrow_bind 11 12 - 56 pop_jump_if_false +2 (to 58) - 57 jump +205 (to 262) - - 992 58 load_var 10 (resp) - 59 load_field 0 (candidates) - 60 load_const 6 (null) - 61 cmp_op == - 62 pop_jump_if_false +2 (to 64) - 63 jump +8 (to 71) - 64 load_const 12 (0) - 65 load_var 10 (resp) - 66 load_field 0 (candidates) - 67 make_bound_method 3 - 68 call_indirect - 69 store_var 17 (cand) - 70 jump +3 (to 73) - 71 load_const 6 (null) - 72 store_var 17 (cand) - - 993 73 load_var 17 (cand) - 74 load_const 6 (null) - 75 cmp_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +16 (to 93) - 78 load_var 17 (cand) - 79 load_field 0 (0) - 80 load_const 6 (null) - 81 cmp_op == - 82 pop_jump_if_false +2 (to 84) - 83 jump +10 (to 93) - 84 load_var 17 (cand) - 85 load_const 6 (null) - 86 cmp_op == - 87 pop_jump_if_false +2 (to 89) - 88 jump +5 (to 93) - 89 load_var 17 (cand) - 90 load_field 0 (0) - 91 load_field 1 (1) - 92 jump +2 (to 94) - 93 load_const 6 (null) - 94 store_var_load_var 19 (_43) - 95 load_const 6 (null) - 96 cmp_op == - 97 pop_jump_if_false +4 (to 101) - 98 load_type 13 - 99 alloc_array 0 - 100 store_var 19 (_43) - 101 load_var 19 (_43) - 102 store_var_load_var 18 (parts) - - 994 103 load_type 14 - 104 load_const 15 ("iter") - 105 virtual_call nargs=1 ntypeargs=0 - 106 store_var 20 (_56) - 107 load_var 20 (_56) - 108 load_type 16 - 109 load_const 17 ("next") - 110 virtual_call nargs=1 ntypeargs=0 - 111 store_var 21 (_57) - 112 load_var 21 (_57) - 113 is_type 5 - 114 pop_jump_if_false +2 (to 116) - 115 jump +27 (to 142) - 116 load_var 21 (_57) - 117 store_var_load_var 22 (p) - - 995 118 load_field 0 (text) - 119 store_var 23 (_62) - 120 load_var 23 (_62) - 121 narrow_bind 18 23 - 122 pop_jump_if_false -15 (to 107) - 123 load_var 23 (_62) - 124 store_var 24 (t) - - 996 125 load_var 22 (p) - 126 load_field 1 (thought) - 127 store_var_load_var 25 (_65) - 128 load_const 6 (null) - 129 cmp_op == - 130 pop_jump_if_false +3 (to 133) - 131 load_const 19 (false) - 132 store_var 25 (_65) - 133 load_var 25 (_65) - 134 pop_jump_if_false +2 (to 136) - 135 jump -28 (to 107) - - 999 136 load_type 0 - 137 load_var2 4 24 - 138 init_instance 1 (ai.stream.TextDelta .text) - 139 call 4 ntypeargs=1 (baml.Array.push) - 140 pop 1 - 141 jump -34 (to 107) - - 1006 142 load_var 17 (cand) - 143 load_const 6 (null) - 144 cmp_op == - 145 pop_jump_if_false +2 (to 147) - 146 jump +4 (to 150) - 147 load_var 17 (cand) - 148 load_field 1 (1) - 149 jump +2 (to 151) - 150 load_const 6 (null) - 151 store_var_load_var 27 (_73) - 152 load_const 6 (null) - 153 cmp_op == - 154 pop_jump_if_false +3 (to 157) - 155 load_const 20 ("") - 156 store_var 27 (_73) - 157 load_var 27 (_73) - 158 store_var 26 (finish) - - 1007 159 load_var 10 (resp) - 160 load_field 2 (promptFeedback) - 161 load_const 6 (null) - 162 cmp_op == - 163 pop_jump_if_false +2 (to 165) - 164 jump +5 (to 169) - 165 load_var 10 (resp) - 166 load_field 2 (promptFeedback) - 167 load_field 0 (0) - 168 jump +2 (to 170) - 169 load_const 6 (null) - 170 load_const 6 (null) - 171 call 672 ntypeargs=0 (baml.ops.equals_equals) - 172 unary_op ! - 173 store_var 28 (blocked) - - 1008 174 load_var 26 (finish) - 175 load_const 21 ("MAX_TOKENS") - 176 cmp_op == - 177 pop_jump_if_false +2 (to 179) - 178 jump +25 (to 203) - - 1010 179 load_var 28 (blocked) - 180 jump_if_false +2 (to 182) - 181 jump +4 (to 185) - 182 pop 1 - 183 load_var 26 (finish) - 184 call 1238 ntypeargs=0 (google.internal._gm_is_blocked) - 185 pop_jump_if_false +2 (to 187) - 186 jump +13 (to 199) - - 1012 187 load_var 26 (finish) - 188 load_const 22 ("") - 189 cmp_op != - 190 pop_jump_if_false +2 (to 192) - 191 jump +4 (to 195) - - 1015 192 load_const 6 (null) - 193 store_var 29 (stop) - - 1012 194 jump +12 (to 206) - - 1013 195 load_const 12 (ai.content.StopReason.Complete) - 196 alloc_variant 774 (ai.content.StopReason) - 197 store_var 29 (stop) - - 1012 198 jump +8 (to 206) - - 1011 199 load_const 23 (ai.content.StopReason.Refused) - 200 alloc_variant 774 (ai.content.StopReason) - 201 store_var 29 (stop) - - 1010 202 jump +4 (to 206) - - 1009 203 load_const 24 (ai.content.StopReason.MaxTokens) - 204 alloc_variant 774 (ai.content.StopReason) - 205 store_var 29 (stop) - - 1017 206 load_var 10 (resp) - 207 load_field 1 (usageMetadata) - 208 store_var 30 (usage) - - 1018 209 load_var 29 (stop) - 210 load_const 6 (null) - 211 call 672 ntypeargs=0 (baml.ops.equals_equals) - 212 unary_op ! - 213 jump_if_false +2 (to 215) - 214 jump +6 (to 220) - 215 pop 1 - 216 load_var 30 (usage) - 217 load_const 6 (null) - 218 call 672 ntypeargs=0 (baml.ops.equals_equals) - 219 unary_op ! - 220 pop_jump_if_false +31 (to 251) - - 1021 221 load_var 29 (stop) - 222 store_var 31 (_102) - - 1022 223 load_var 30 (usage) - 224 load_const 6 (null) - 225 cmp_op == - 226 pop_jump_if_false +2 (to 228) - 227 jump +5 (to 232) - 228 load_var 30 (usage) - 229 load_field 0 (0) - 230 store_var 32 (_103) - 231 jump +3 (to 234) - 232 load_const 6 (null) - 233 store_var 32 (_103) - - 1023 234 load_var 30 (usage) - 235 load_const 6 (null) - 236 cmp_op == - 237 pop_jump_if_false +2 (to 239) - 238 jump +5 (to 243) - 239 load_var 30 (usage) - 240 load_field 1 (1) - 241 store_var 33 (_107) - 242 jump +3 (to 245) - 243 load_const 6 (null) - 244 store_var 33 (_107) - - 1019 245 load_type 0 - 246 load_var2 4 31 - - 1020 247 load_var2 32 33 - 248 init_instance 2 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1019 249 call 4 ntypeargs=1 (baml.Array.push) - 250 pop 1 - - 1033 251 load_var 29 (stop) - 252 load_const 6 (null) - 253 call 672 ntypeargs=0 (baml.ops.equals_equals) - 254 unary_op ! - 255 pop_jump_if_false -246 (to 9) - - 1034 256 load_type 0 - 257 load_var 4 (out) - 258 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 259 call 4 ntypeargs=1 (baml.Array.push) - 260 pop 1 - 261 jump -252 (to 9) - - 989 262 load_var 12 (_26) - 263 store_var_load_var 13 (err) - - 990 264 load_field 0 (code) - 265 store_var_load_var 15 (_30) - 266 load_const 6 (null) - 267 cmp_op == - 268 pop_jump_if_false +3 (to 271) - 269 load_const 12 (0) - 270 store_var 15 (_30) - 271 load_var 15 (_30) - 272 store_var 14 (_29) - 273 load_var 13 (err) - 274 load_field 1 (message) - 275 store_var_load_var 16 (_34) - 276 load_const 6 (null) - 277 cmp_op == - 278 pop_jump_if_false +3 (to 281) - 279 load_var 8 (payload) - 280 store_var 16 (_34) - 281 load_var2 2 14 - 282 load_var 16 (_34) - 283 load_const 25 () - 284 call 977 ntypeargs=0 (ai.errors.classify_http) - 285 throw - - 1042 286 load_var 4 (out) - 287 store_var 3 (_0) - 288 load_var 3 (_0) - 289 return -} - -function google.internal._gm_encode_call_id(id: string, signature: string | null) -> string { - 540 0 load_var 2 (signature) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 543 6 load_var 1 (id) - - 540 7 jump +21 (to 28) - 8 load_var 3 (_3) - 9 store_var 4 (sig) - - 541 10 load_type 1 - 11 load_var 1 (id) - 12 call 138 ntypeargs=1 (baml.String.from) - 13 store_var 5 (_6) - 14 call 1230 ntypeargs=0 (google.internal._gm_sig_marker) - 15 store_var 7 (_9) - 16 load_type 1 - 17 load_var 7 (_9) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 6 (_8) - 20 load_type 1 - 21 load_var 4 (sig) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 8 (_11) - 24 load_var2 5 6 - 25 bin_op + - 26 load_var 8 (_11) - 27 bin_op + - 28 return -} - -function google.internal._gm_encode_query(value: string) -> string { - 299 0 load_var 1 (value) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("\"") - 8 load_const 5 ("%22") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("#") - 11 load_const 7 ("%23") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("&") - 14 load_const 9 ("%26") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("+") - 17 load_const 11 ("%2B") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - 19 load_const 12 ("/") - 20 load_const 13 ("%2F") - 21 call 160 ntypeargs=0 (baml.String.replace_all) - 22 load_const 14 ("<") - 23 load_const 15 ("%3C") - 24 call 160 ntypeargs=0 (baml.String.replace_all) - 25 load_const 16 ("=") - 26 load_const 17 ("%3D") - 27 call 160 ntypeargs=0 (baml.String.replace_all) - 28 load_const 18 (">") - 29 load_const 19 ("%3E") - 30 call 160 ntypeargs=0 (baml.String.replace_all) - 31 load_const 20 ("?") - 32 load_const 21 ("%3F") - 33 call 160 ntypeargs=0 (baml.String.replace_all) - 34 return -} - -function google.internal._gm_generation_config(temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null) -> google.internal.GmGenerationConfig | null { - 360 0 load_var 1 (temperature) - 1 load_const 0 (null) - 2 call 672 ntypeargs=0 (baml.ops.equals_equals) - 3 jump_if_false +5 (to 8) - 4 pop 1 - - 361 5 load_var 2 (max_output_tokens) - 6 load_const 0 (null) - 7 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 8 jump_if_false +5 (to 13) - 9 pop 1 - - 362 10 load_var 3 (top_p) - 11 load_const 0 (null) - 12 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 13 jump_if_false +5 (to 18) - 14 pop 1 - - 363 15 load_var 4 (top_k) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 18 jump_if_false +5 (to 23) - 19 pop 1 - - 364 20 load_var 5 (stop_sequences) - 21 load_const 0 (null) - 22 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 360 23 jump_if_false +5 (to 28) - 24 pop 1 - - 365 25 load_var 6 (response_modalities) - 26 load_const 0 (null) - 27 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 359 28 pop_jump_if_false +2 (to 30) - 29 jump +6 (to 35) - - 369 30 load_var2 1 2 - 31 load_var2 3 4 - 32 load_var2 5 6 - 33 init_instance 0 (google.internal.GmGenerationConfig .temperature, .maxOutputTokens, .topP, .topK, .stopSequences, .responseModalities) - - 359 34 jump +2 (to 36) - - 367 35 load_const 0 (null) - 36 return -} - -function google.internal._gm_is_blocked(finish: string) -> bool { - 801 0 load_var 1 (finish) - 1 load_const 0 ("SAFETY") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 802 6 load_var 1 (finish) - 7 load_const 1 ("RECITATION") - 8 cmp_op == - - 801 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 803 12 load_var 1 (finish) - 13 load_const 2 ("PROHIBITED_CONTENT") - 14 cmp_op == - - 801 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 804 18 load_var 1 (finish) - 19 load_const 3 ("BLOCKLIST") - 20 cmp_op == - - 801 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 805 24 load_var 1 (finish) - 25 load_const 4 ("SPII") - 26 cmp_op == - - 801 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 806 30 load_var 1 (finish) - 31 load_const 5 ("IMAGE_SAFETY") - 32 cmp_op == - 33 return -} - -function google.internal._gm_is_opaque_key(key: string) -> bool { - 263 0 load_var 1 (key) - 1 load_const 0 ("args") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (key) - 7 load_const 1 ("response") - 8 cmp_op == - 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - 12 load_var 1 (key) - 13 load_const 2 ("parametersJsonSchema") - 14 cmp_op == - 15 return -} - -function google.internal._gm_is_provider_uri(url: string) -> bool { - 399 0 load_var 1 (url) - 1 load_const 0 ("gs://") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 400 6 load_var 1 (url) - 7 load_const 1 ("://generativelanguage.googleapis.com/v1beta/files/") - 8 call 147 ntypeargs=0 (baml.String.includes) - - 399 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 401 12 load_var 1 (url) - 13 load_const 2 ("://www.youtube.com/") - 14 call 147 ntypeargs=0 (baml.String.includes) - - 399 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 402 18 load_var 1 (url) - 19 load_const 3 ("://youtube.com/") - 20 call 147 ntypeargs=0 (baml.String.includes) - - 399 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 403 24 load_var 1 (url) - 25 load_const 4 ("://m.youtube.com/") - 26 call 147 ntypeargs=0 (baml.String.includes) - - 399 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 404 30 load_var 1 (url) - 31 load_const 5 ("://youtu.be/") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 return -} - -function google.internal._gm_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> google.internal.GmPart { - 431 0 load_var 1 (media) - 1 call 1224 ntypeargs=0 (google.internal._gm_media_url) - - 432 2 store_var 4 (_5) - 3 load_var 4 (_5) - 4 narrow_bind 0 4 - 5 pop_jump_if_false +2 (to 7) - 6 jump +4 (to 10) - - 435 7 load_const 1 (false) - 8 store_var 3 (passthrough) - - 432 9 jump +5 (to 14) - 10 load_var 4 (_5) - 11 store_var_load_var 5 (url) - - 433 12 call 1225 ntypeargs=0 (google.internal._gm_is_provider_uri) - 13 store_var 3 (passthrough) - - 437 14 load_var 2 (fetch_url) - 15 jump_if_false +3 (to 18) - 16 pop 1 - 17 jump +3 (to 20) - 18 store_var 7 (_9) - 19 jump +4 (to 23) - 20 load_var 3 (passthrough) - 21 unary_op ! - 22 store_var 7 (_9) - 23 load_var2 1 7 - 24 call 933 ntypeargs=0 (ai.wire.resolve_media) - 25 store_var 6 (resolved) - - 438 26 load_var 6 (resolved) - 27 load_field 0 (url) - 28 store_var 8 (_12) - 29 load_var 8 (_12) - 30 narrow_bind 0 8 - 31 pop_jump_if_false +2 (to 33) - 32 jump +16 (to 48) - - 444 33 load_var 6 (resolved) - 34 load_field 2 (mime_type) - 35 store_var 10 (_20) - 36 load_var 6 (resolved) - 37 load_field 1 (base64) - 38 store_var_load_var 11 (_22) - 39 load_const 2 (null) - 40 cmp_op == - 41 pop_jump_if_false +3 (to 44) - 42 load_const 3 ("") - 43 store_var 11 (_22) - 44 load_var2 10 11 - 45 init_instance 0 (google.internal.GmInlineData .mimeType, .data) - - 443 46 call 1214 ntypeargs=0 (google.internal.GmPart.of_inline_data) - 47 jump +9 (to 56) - - 438 48 load_var 8 (_12) - 49 store_var_load_var 9 (url) - - 440 50 load_var 6 (resolved) - 51 load_field 2 (mime_type) - 52 call 1226 ntypeargs=0 (google.internal._gm_mime_for_uri) - 53 load_var 9 (url) - 54 init_instance 1 (google.internal.GmFileData .mimeType, .fileUri) - - 439 55 call 1215 ntypeargs=0 (google.internal.GmPart.of_file_data) - 56 return -} - -function google.internal._gm_media_url(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> string | null { - 385 0 load_var 1 (media) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +28 (to 33) - 6 load_var 1 (media) - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 narrow_bind 1 4 - 10 pop_jump_if_false +2 (to 12) - 11 jump +17 (to 28) - 12 load_var 1 (media) - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 narrow_bind 2 6 - 16 pop_jump_if_false +2 (to 18) - 17 jump +6 (to 23) - 18 load_var 1 (media) - 19 store_var 8 (pdf) - - 389 20 load_var 8 (pdf) - 21 call 322 ntypeargs=0 (baml.media.Pdf.url) - 22 jump +15 (to 37) - - 385 23 load_var 6 (_6) - 24 store_var 7 (video) - - 388 25 load_var 7 (video) - 26 call 336 ntypeargs=0 (baml.media.Video.url) - 27 jump +10 (to 37) - - 385 28 load_var 4 (_4) - 29 store_var 5 (audio) - - 387 30 load_var 5 (audio) - 31 call 329 ntypeargs=0 (baml.media.Audio.url) - 32 jump +5 (to 37) - - 385 33 load_var 2 (_2) - 34 store_var 3 (image) - - 386 35 load_var 3 (image) - 36 call 343 ntypeargs=0 (baml.media.Image.url) - 37 return -} - -function google.internal._gm_mime_for_uri(url: string, mime: string) -> string | null { - 411 0 load_var 1 (url) - 1 load_const 0 ("gs://") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +10 (to 14) - - 413 5 load_var 1 (url) - 6 load_const 1 ("youtu") - 7 call 147 ntypeargs=0 (baml.String.includes) - 8 pop_jump_if_false +2 (to 10) - 9 jump +3 (to 12) - - 416 10 load_var 2 (mime) - - 413 11 jump +4 (to 15) - - 414 12 load_const 2 (null) - - 413 13 jump +2 (to 15) - - 412 14 load_var 2 (mime) - 15 return -} - -function google.internal._gm_open_sse(req: baml.http.Request, provider: string) -> baml.http.SseStream { - 952 0 load_var 1 (req) - 1 sys_op 252 (baml.http.fetch_sse) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 953 5 load_var2 2 3 - 6 call 1241 ntypeargs=0 (google.internal._gm_sse_failure) - 7 throw - 8 return -} - -function google.internal._gm_output_media(mime: string, data: string) -> ai.content.Media { - 785 0 load_var 1 (mime) - 1 load_const 0 ("audio/") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +20 (to 24) - - 787 5 load_var 1 (mime) - 6 load_const 1 ("video/") - 7 call 148 ntypeargs=0 (baml.String.starts_with) - 8 pop_jump_if_false +2 (to 10) - 9 jump +12 (to 21) - - 789 10 load_var 1 (mime) - 11 load_const 2 ("application/pdf") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +4 (to 18) - - 792 15 load_var2 2 1 - 16 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 17 jump +9 (to 26) - - 790 18 load_var2 2 1 - 19 call 328 ntypeargs=0 (baml.media.Pdf.from_base64) - 20 jump +6 (to 26) - - 788 21 load_var2 2 1 - 22 call 342 ntypeargs=0 (baml.media.Video.from_base64) - 23 jump +3 (to 26) - - 786 24 load_var2 2 1 - 25 call 335 ntypeargs=0 (baml.media.Audio.from_base64) - - 794 26 load_const 3 () - 27 load_const 3 () - 28 call 904 ntypeargs=0 (ai.content.Media.new) - 29 return -} - -function google.internal._gm_prompt_parts(message: ai.PromptMessage, fetch_url: bool) -> google.internal.GmPart[] { - 450 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (parts) - - 451 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +76 (to 93) - 18 load_var 6 (_6) - 19 store_var 7 (part) - - 452 20 load_var 7 (part) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +59 (to 84) - 26 load_var 7 (part) - 27 store_var 11 (_16) - 28 load_var 11 (_16) - 29 narrow_bind 7 11 - 30 pop_jump_if_false +2 (to 32) - 31 jump +43 (to 74) - 32 load_var 7 (part) - 33 store_var 14 (_22) - 34 load_var 14 (_22) - 35 narrow_bind 8 14 - 36 pop_jump_if_false +2 (to 38) - 37 jump +27 (to 64) - 38 load_var 7 (part) - 39 store_var 17 (_28) - 40 load_var 17 (_28) - 41 narrow_bind 9 17 - 42 pop_jump_if_false +2 (to 44) - 43 jump +11 (to 54) - 44 load_var 7 (part) - 45 store_var_load_var 20 (pdf) - - 470 46 load_var 2 (fetch_url) - 47 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 48 store_var 21 (_36) - 49 load_type 0 - 50 load_var2 4 21 - 51 call 4 ntypeargs=1 (baml.Array.push) - 52 pop 1 - 53 jump -44 (to 9) - - 452 54 load_var 17 (_28) - 55 store_var_load_var 18 (video) - - 466 56 load_var 2 (fetch_url) - 57 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 58 store_var 19 (_31) - 59 load_type 0 - 60 load_var2 4 19 - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -54 (to 9) - - 452 64 load_var 14 (_22) - 65 store_var_load_var 15 (audio) - - 462 66 load_var 2 (fetch_url) - 67 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 68 store_var 16 (_25) - 69 load_type 0 - 70 load_var2 4 16 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -64 (to 9) - - 452 74 load_var 11 (_16) - 75 store_var_load_var 12 (image) - - 458 76 load_var 2 (fetch_url) - 77 call 1227 ntypeargs=0 (google.internal._gm_media_part) - 78 store_var 13 (_19) - 79 load_type 0 - 80 load_var2 4 13 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -74 (to 9) - - 452 84 load_var 8 (_10) - 85 store_var_load_var 9 (text) - - 454 86 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 87 store_var 10 (_13) - 88 load_type 0 - 89 load_var2 4 10 - 90 call 4 ntypeargs=1 (baml.Array.push) - 91 pop 1 - 92 jump -83 (to 9) - - 475 93 load_var 4 (parts) - 94 store_var 3 (_0) - 95 load_var 3 (_0) - 96 return -} - -function google.internal._gm_sig_marker() -> string { - 536 0 load_const 0 ("~gts~") - 1 store_var 1 (_0) - 2 load_var 1 (_0) - 3 return -} - -function google.internal._gm_sse_failure(provider: string, error: unknown) -> ai.errors.Failure { - 923 0 load_var 2 (error) - 1 store_var 5 (_5) - 2 load_var 5 (_5) - 3 narrow_bind 0 5 - 4 pop_jump_if_false +2 (to 6) - 5 jump +6 (to 11) - - 925 6 load_type 1 - 7 load_var 2 (error) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 4 (_4) - 10 jump +6 (to 16) - - 923 11 load_var 5 (_5) - 12 store_var 6 (io) - - 924 13 load_var 6 (io) - 14 load_field 0 (message) - 15 store_var 4 (_4) - - 923 16 load_var 4 (_4) - 17 call 929 ntypeargs=0 (ai.wire.redact_url_secrets) - 18 store_var 3 (text) - - 927 19 load_const 2 ("failed with status ") - 20 store_var 7 (marker) - - 928 21 load_var2 3 7 - 22 call 155 ntypeargs=0 (baml.String.index_of) - 23 store_var 8 (_11) - 24 load_var 8 (_11) - 25 narrow_bind 3 8 - 26 pop_jump_if_false +47 (to 73) - 27 load_var 8 (_11) - 28 store_var 9 (start) - - 929 29 load_var 9 (start) - 30 store_var 12 (_15) - 31 load_var 7 (marker) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 load_var 12 (_15) - 34 add_int - 35 store_var 11 (_14) - 36 load_var 3 (text) - 37 call 139 ntypeargs=0 (baml.String.length) - 38 store_var 13 (_17) - 39 load_var2 3 11 - 40 load_var 13 (_17) - 41 call 153 ntypeargs=0 (baml.String.slice) - 42 store_var 10 (rest) - - 930 43 load_var 10 (rest) - 44 load_const 4 (":") - 45 call 150 ntypeargs=0 (baml.String.split) - 46 store_var 16 (_21) - 47 load_type 5 - 48 load_var 16 (_21) - 49 load_const 3 (0) - 50 call 3 ntypeargs=1 (baml.Array.at) - 51 store_var_load_var 15 (_19) - 52 load_const 6 (null) - 53 cmp_op == - 54 pop_jump_if_false +3 (to 57) - 55 load_const 7 ("") - 56 store_var 15 (_19) - 57 load_var 15 (_19) - 58 store_var 14 (head) - - 931 59 load_var 14 (head) - 60 call 144 ntypeargs=0 (baml.String.trim) - 61 call 81 ntypeargs=0 (baml.Int.parse) - 62 store_var 17 (status) - 63 jump +5 (to 68) - 64 load_var 18 (e) - 65 throw_if_panic - - 932 66 load_const 3 (0) - 67 store_var 17 (status) - - 934 68 load_var 17 (status) - 69 load_const 3 (0) - 70 cmp_int_op > - 71 pop_jump_if_false +2 (to 73) - 72 jump +12 (to 84) - - 945 73 load_type 5 - 74 load_var 3 (text) - 75 call 138 ntypeargs=1 (baml.String.from) - 76 store_var 24 (_40) - - 943 77 load_var 1 (provider) - - 945 78 load_const 8 ("transport failed before a response arrived: ") - 79 load_var 24 (_40) - 80 bin_op + - 81 load_const 6 (null) - 82 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 83 jump +29 (to 112) - - 935 84 load_var 10 (rest) - 85 load_const 9 (":") - 86 call 155 ntypeargs=0 (baml.String.index_of) - 87 store_var 20 (_31) - 88 load_var 20 (_31) - 89 narrow_bind 3 20 - 90 pop_jump_if_false +2 (to 92) - 91 jump +4 (to 95) - - 938 92 load_const 10 ("") - 93 store_var 19 (body) - - 935 94 jump +14 (to 108) - 95 load_var 20 (_31) - 96 store_var_load_var 21 (colon) - - 936 97 load_const 11 (1) - 98 add_int - 99 store_var 22 (_34) - 100 load_var 10 (rest) - 101 call 139 ntypeargs=0 (baml.String.length) - 102 store_var 23 (_36) - 103 load_var2 10 22 - 104 load_var 23 (_36) - 105 call 153 ntypeargs=0 (baml.String.slice) - 106 call 144 ntypeargs=0 (baml.String.trim) - 107 store_var 19 (body) - - 940 108 load_var2 1 17 - 109 load_var 19 (body) - 110 load_const 12 () - 111 call 977 ntypeargs=0 (ai.errors.classify_http) - 112 return -} - -function google.internal._gm_strip_nulls(value: baml.json.json, opaque: bool) -> baml.json.json { - 271 0 load_var 2 (opaque) - 1 pop_jump_if_false +2 (to 3) - 2 jump +74 (to 76) - - 274 3 load_var 1 (value) - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 narrow_bind 0 3 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - 9 load_var 1 (value) - 10 store_var 12 (_27) - 11 load_var 12 (_27) - 12 narrow_bind 1 12 - 13 pop_jump_if_false +2 (to 15) - 14 jump +3 (to 17) - - 290 15 load_var 1 (value) - - 274 16 jump +61 (to 77) - 17 load_var 12 (_27) - 18 store_var 13 (items) - - 289 19 load_type 2 - 20 load_type 2 - 21 load_type 3 - 22 load_var 13 (items) - 23 make_closure 3391 0 - 24 call 16 ntypeargs=3 (baml.Array.map) - 25 jump +52 (to 77) - - 274 26 load_var 3 (_3) - 27 store_var 4 (object) - - 276 28 load_type 4 - 29 load_type 2 - 30 alloc_map 0 - 31 store_var 5 (out) - - 277 32 load_type 4 - 33 load_type 2 - 34 load_var 4 (object) - 35 call 35 ntypeargs=2 (baml.Map.keys) - 36 load_type 5 - 37 load_const 6 ("iter") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 6 (_9) - 40 load_var 6 (_9) - 41 load_type 7 - 42 load_const 8 ("next") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 7 (_10) - 45 load_var 7 (_10) - 46 is_type 9 - 47 pop_jump_if_false +2 (to 49) - 48 jump +26 (to 74) - 49 load_var 7 (_10) - 50 store_var 8 (key) - - 278 51 load_type 4 - 52 load_type 2 - 53 load_var2 4 8 - 54 call 38 ntypeargs=2 (baml.Map.get) - 55 store_var 9 (entry) - - 279 56 load_var 9 (entry) - 57 load_const 10 (null) - 58 cmp_op == - 59 pop_jump_if_false +2 (to 61) - 60 jump -20 (to 40) - - 282 61 load_var 8 (key) - 62 call 1218 ntypeargs=0 (google.internal._gm_is_opaque_key) - 63 store_var 11 (_23) - 64 load_var2 9 11 - 65 call 1219 ntypeargs=0 (google.internal._gm_strip_nulls) - 66 store_var 10 (_21) - 67 load_type 4 - 68 load_type 2 - 69 load_var2 5 8 - 70 load_var 10 (_21) - 71 call 37 ntypeargs=2 (baml.Map.set) - 72 pop 1 - 73 jump -33 (to 40) - - 287 74 load_var 5 (out) - - 274 75 jump +2 (to 77) - - 272 76 load_var 1 (value) - 77 return -} - -function google.internal._gm_tool_name_for(j: ai.Journal, id: string) -> string { - 560 0 load_const 0 ("") - 1 store_var 3 (name) - - 561 2 load_var 1 (j) - 3 call 905 ntypeargs=0 (ai.Journal.entries) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_5) - 8 load_var 4 (_5) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_6) - 13 load_var 5 (_6) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +41 (to 57) - 17 load_var 5 (_6) - 18 store_var 6 (e) - - 562 19 load_var 6 (e) - 20 store_var 7 (_10) - 21 load_var 7 (_10) - 22 narrow_bind 6 7 - 23 pop_jump_if_false -15 (to 8) - 24 load_var 7 (_10) - 25 store_var_load_var 8 (a) - - 564 26 load_field 0 (content) - 27 load_type 7 - 28 load_const 8 ("iter") - 29 virtual_call nargs=1 ntypeargs=0 - 30 store_var 9 (_13) - 31 load_var 9 (_13) - 32 load_type 9 - 33 load_const 10 ("next") - 34 virtual_call nargs=1 ntypeargs=0 - 35 store_var 10 (_14) - 36 load_var 10 (_14) - 37 is_type 5 - 38 pop_jump_if_false +2 (to 40) - 39 jump -31 (to 8) - 40 load_var 10 (_14) - 41 store_var 11 (b) - - 565 42 load_var 11 (b) - 43 store_var 12 (_18) - 44 load_var 12 (_18) - 45 narrow_bind 11 12 - 46 pop_jump_if_false -15 (to 31) - 47 load_var 12 (_18) - 48 store_var_load_var 13 (u) - - 567 49 load_field 0 (id) - 50 load_var 2 (id) - 51 cmp_op == - 52 pop_jump_if_false -21 (to 31) - - 568 53 load_var 13 (u) - 54 load_field 1 (name) - 55 store_var 3 (name) - - 567 56 jump -25 (to 31) - - 582 57 load_var 3 (name) - 58 return -} - -function google.internal._gm_usage(usage: google.internal.GmUsageMetadata | null) -> ai.events.Usage | null { - 810 0 load_var 1 (usage) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 821 6 load_const 1 (null) - - 810 7 jump +26 (to 33) - 8 load_var 2 (_2) - 9 store_var_load_var 3 (um) - - 812 10 load_field 0 (promptTokenCount) - 11 store_var_load_var 5 (_5) - 12 load_const 1 (null) - 13 cmp_op == - 14 pop_jump_if_false +3 (to 17) - 15 load_const 2 (0) - 16 store_var 5 (_5) - 17 load_var 5 (_5) - 18 store_var 4 (_4) - - 816 19 load_var 3 (um) - 20 load_field 1 (candidatesTokenCount) - 21 store_var_load_var 6 (_9) - 22 load_const 1 (null) - 23 cmp_op == - 24 pop_jump_if_false +3 (to 27) - 25 load_const 2 (0) - 26 store_var 6 (_9) - - 811 27 load_var2 4 6 - - 817 28 load_var 3 (um) - 29 load_field 2 (cachedContentTokenCount) - - 818 30 load_var 3 (um) - 31 load_field 3 (thoughtsTokenCount) - 32 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 33 return -} - -function google.internal._google_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1097 0 load_var 1 (batch) - 1 load_const 0 ("google") - 2 call 1243 ntypeargs=0 (google.internal._gm_decode_batch) - 3 return -} - -function google.internal._google_request(c: google.GoogleClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 1062 0 load_var 1 (c) - 1 load_type 0 - 2 load_const 1 ("id") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 6 (_5) - - 1064 5 load_var 1 (c) - 6 load_field 6 (temperature) - - 1065 7 load_var 1 (c) - 8 load_field 7 (max_output_tokens) - - 1066 9 load_var 1 (c) - 10 load_field 8 (top_p) - - 1067 11 load_var 1 (c) - 12 load_field 9 (top_k) - - 1068 13 load_var 1 (c) - 14 load_field 10 (stop_sequences) - - 1069 15 load_var 1 (c) - 16 load_field 11 (response_modalities) - - 1063 17 call 1223 ntypeargs=0 (google.internal._gm_generation_config) - 18 store_var 7 (_6) - - 1060 19 load_var2 2 6 - 20 load_var2 7 1 - - 1071 21 load_field 12 (safety_settings) - - 1072 22 load_var 1 (c) - 23 load_field 3 (request_body) - 24 load_const 2 () - - 1060 25 call 1235 ntypeargs=0 (google.internal.gemini_build_body) - 26 store_var 5 (body) - - 1074 27 load_var 1 (c) - 28 call 1203 ntypeargs=0 (google.GoogleClient.resolved_base_url) - 29 store_var_load_var 9 (_16) - 30 load_const 3 (null) - 31 cmp_op == - 32 pop_jump_if_false +3 (to 35) - 33 load_const 4 ("https://generativelanguage.googleapis.com/v1beta") - 34 store_var 9 (_16) - 35 load_var 9 (_16) - 36 store_var 8 (base) - - 1076 37 load_type 5 - 38 load_var 8 (base) - 39 call 138 ntypeargs=1 (baml.String.from) - 40 store_var 11 (_23) - 41 load_type 5 - 42 load_var 1 (c) - 43 load_field 0 (model) - 44 call 138 ntypeargs=1 (baml.String.from) - 45 store_var 12 (_26) - 46 load_var 3 (stream) - 47 call 1236 ntypeargs=0 (google.internal.gemini_method) - 48 store_var 14 (_30) - 49 load_type 5 - 50 load_var 14 (_30) - 51 call 138 ntypeargs=1 (baml.String.from) - 52 store_var 13 (_29) - 53 load_var 11 (_23) - 54 load_const 6 ("/models/") - 55 bin_op + - 56 load_var 12 (_26) - 57 bin_op + - 58 load_var 13 (_29) - 59 bin_op + - - 1077 60 load_var 1 (c) - 61 load_field 5 (query_params) - - 1075 62 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 63 store_var 10 (url) - - 1079 64 load_const 7 ("application/json") - 65 load_const 8 ("content-type") - 66 load_type 5 - 67 load_type 5 - 68 alloc_map 1 - 69 store_var_load_var 15 (headers) - - 1080 70 load_var 1 (c) - 71 load_field 4 (headers) - 72 call 1222 ntypeargs=0 (google.internal._gm_apply_headers) - 73 store_var 16 (with_user) - - 1081 74 load_var 1 (c) - 75 call 1202 ntypeargs=0 (google.GoogleClient.resolved_api_key) - 76 store_var 17 (_38) - 77 load_type 5 - 78 load_type 5 - 79 load_var 16 (with_user) - 80 load_const 9 ("x-goog-api-key") - 81 load_var 17 (_38) - 82 call 37 ntypeargs=2 (baml.Map.set) - 83 pop 1 - - 1082 84 load_const 10 ("POST") - 85 load_var2 10 16 - 86 load_var 5 (body) - 87 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 88 store_var 4 (_0) - 89 load_var 4 (_0) - 90 return -} - -function google.internal._vertex_anthropic_body(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> string { - 241 0 load_const 0 ("vertex-2023-10-16") - 1 load_const 1 (null) - 2 load_const 2 ("anthropic_version") - 3 load_const 3 ("model") - 4 load_type 4 - 5 load_type 5 - 6 alloc_map 2 - 7 store_var 4 (vertex_fields) - - 246 8 load_var 1 (c) - 9 load_field 0 (model) - 10 store_var 6 (_6) - - 247 11 load_var 1 (c) - 12 load_field 11 (max_output_tokens) - 13 store_var_load_var 8 (_8) - 14 load_const 1 (null) - 15 cmp_op == - 16 pop_jump_if_false +3 (to 19) - 17 load_const 6 (8192) - 18 store_var 8 (_8) - 19 load_var 8 (_8) - 20 store_var 7 (_7) - - 248 21 load_var 1 (c) - 22 load_field 10 (temperature) - 23 store_var 9 (_11) - - 249 24 load_var 1 (c) - 25 load_field 12 (top_p) - 26 store_var 10 (_12) - - 250 27 load_var 1 (c) - 28 load_field 13 (top_k) - 29 store_var 11 (_13) - - 251 30 load_var 1 (c) - 31 load_field 14 (stop_sequences) - 32 store_var 12 (_14) - - 256 33 load_var2 4 1 - 34 load_field 7 (request_body) - 35 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 36 store_var 13 (_15) - - 257 37 load_var 1 (c) - 38 load_type 7 - 39 load_const 8 ("id") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 14 (_18) - - 245 42 load_var2 6 7 - 43 load_var2 9 10 - 44 load_var2 11 12 - 45 load_const 1 (null) - 46 load_const 1 (null) - 47 load_var2 13 14 - 48 init_instance 0 (anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id) - 49 store_var_load_var 5 (params) - - 259 50 load_var2 2 3 - 51 call 1185 ntypeargs=0 (anthropic.internal.anthropic_messages_body) - 52 return -} - -function google.internal._vertex_credentials(c: google.VertexClient) -> string | null { - 49 0 load_var 1 (c) - 1 load_field 3 (credentials_json) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +59 (to 65) - - 52 7 load_var 1 (c) - 8 load_field 4 (credentials_file) - 9 store_var 4 (_7) - 10 load_var 4 (_7) - 11 narrow_bind 0 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +20 (to 33) - - 65 14 load_const 1 ("GOOGLE_APPLICATION_CREDENTIALS_CONTENT") - 15 sys_op 226 (baml.env.get) - 16 store_var 10 (_25) - 17 load_var 10 (_25) - 18 narrow_bind 0 10 - 19 pop_jump_if_false +9 (to 28) - 20 load_var 10 (_25) - 21 store_var 11 (from_env) - - 66 22 load_var 11 (from_env) - 23 call 144 ntypeargs=0 (baml.String.trim) - 24 load_const 2 ("") - 25 cmp_op != - 26 pop_jump_if_false +2 (to 28) - 27 jump +3 (to 30) - - 70 28 load_const 3 (null) - 29 jump +39 (to 68) - - 67 30 load_var 11 (from_env) - 31 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 32 jump +36 (to 68) - - 52 33 load_var 4 (_7) - 34 store_var_load_var 5 (path) - - 53 35 sys_op 293 (baml.fs.read) - 36 jump +27 (to 63) - 37 load_var 6 (e) - 38 throw_if_panic - - 58 39 load_type 4 - 40 load_var 5 (path) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 7 (_16) - 43 load_type 5 - 44 load_var 6 (e) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 9 (_20) - 47 load_type 4 - 48 load_var 9 (_20) - 49 call 138 ntypeargs=1 (baml.String.from) - 50 store_var 8 (_19) - - 55 51 load_const 6 ("vertex") - 52 load_const 3 (null) - - 58 53 load_const 7 ("Vertex AI credentials file ") - 54 load_var 7 (_16) - 55 bin_op + - 56 load_const 8 (" could not be read: ") - 57 bin_op + - 58 load_var 8 (_19) - 59 bin_op + - 60 load_const 3 (null) - 61 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 62 throw - - 63 63 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 64 jump +4 (to 68) - - 49 65 load_var 2 (_3) - 66 store_var_load_var 3 (inline) - - 50 67 call 1250 ntypeargs=0 (google.internal._vertex_unwrap_json) - 68 return -} - -function google.internal._vertex_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 342 0 load_var 1 (batch) - 1 load_const 0 ("vertex") - 2 call 1243 ntypeargs=0 (google.internal._gm_decode_batch) - 3 return -} - -function google.internal._vertex_express_key(c: google.VertexClient) -> string | null { - 77 0 load_var 1 (c) - 1 call 1208 ntypeargs=0 (google.VertexClient.resolved_api_key) - 2 return -} - -function google.internal._vertex_is_express(c: google.VertexClient) -> bool { - 87 0 load_var 1 (c) - 1 call 1252 ntypeargs=0 (google.internal._vertex_express_key) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 unary_op ! - 5 jump_if_false +2 (to 7) - 6 jump +4 (to 10) - 7 pop 1 - 8 load_var 1 (c) - 9 call 1253 ntypeargs=0 (google.internal._vertex_key_in_query) - 10 return -} - -function google.internal._vertex_is_multi_region(location: string) -> bool { - 160 0 load_var 1 (location) - 1 load_const 0 ("us") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - 6 load_var 1 (location) - 7 load_const 1 ("eu") - 8 cmp_op == - 9 return -} - -function google.internal._vertex_key_in_query(c: google.VertexClient) -> bool { - 83 0 load_var 1 (c) - 1 load_field 9 (query_params) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +8 (to 13) - 6 load_const 1 ("key") - 7 load_var 1 (c) - 8 load_field 9 (query_params) - 9 make_bound_method 38 - 10 call_indirect - 11 store_var 3 (_2) - 12 jump +3 (to 15) - 13 load_const 0 (null) - 14 store_var 3 (_2) - 15 load_var 3 (_2) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 unary_op ! - 19 store_var 2 (_0) - 20 load_var 2 (_0) - 21 return -} - -function google.internal._vertex_method(c: google.VertexClient, stream: bool) -> string { - 202 0 load_var 1 (c) - 1 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 2 load_const 0 ("anthropic") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +4 (to 9) - - 209 6 load_var 2 (stream) - 7 call 1236 ntypeargs=0 (google.internal.gemini_method) - 8 jump +7 (to 15) - - 203 9 load_var 2 (stream) - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 206 12 load_const 1 (":rawPredict") - - 203 13 jump +2 (to 15) - - 204 14 load_const 2 (":streamRawPredict") - 15 return -} - -function google.internal._vertex_models_base(c: google.VertexClient) -> string { - 168 0 load_var 1 (c) - 1 call 1209 ntypeargs=0 (google.VertexClient.resolved_base_url) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +99 (to 105) - - 171 7 load_var 1 (c) - 8 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 9 store_var 4 (publisher) - - 172 10 load_var 1 (c) - 11 call 1255 ntypeargs=0 (google.internal.vertex_location) - 12 store_var 5 (location) - - 173 13 load_var 5 (location) - 14 load_const 1 ("global") - 15 cmp_op == - 16 pop_jump_if_false +2 (to 18) - 17 jump +23 (to 40) - - 175 18 load_var 5 (location) - 19 call 1258 ntypeargs=0 (google.internal._vertex_is_multi_region) - 20 pop_jump_if_false +2 (to 22) - 21 jump +8 (to 29) - - 180 22 load_type 2 - 23 load_var 5 (location) - 24 call 138 ntypeargs=1 (baml.String.from) - 25 load_const 3 ("-aiplatform.googleapis.com") - 26 bin_op + - 27 store_var 6 (host) - - 175 28 jump +14 (to 42) - - 178 29 load_type 2 - 30 load_var 5 (location) - 31 call 138 ntypeargs=1 (baml.String.from) - 32 store_var 7 (_13) - 33 load_const 4 ("aiplatform.") - 34 load_var 7 (_13) - 35 bin_op + - 36 load_const 5 (".rep.googleapis.com") - 37 bin_op + - 38 store_var 6 (host) - - 175 39 jump +3 (to 42) - - 174 40 load_const 6 ("aiplatform.googleapis.com") - 41 store_var 6 (host) - - 182 42 load_var 1 (c) - 43 call 1256 ntypeargs=0 (google.internal.vertex_project_id) - - 183 44 store_var 8 (_20) - 45 load_var 8 (_20) - 46 narrow_bind 0 8 - 47 pop_jump_if_false +2 (to 49) - 48 jump +21 (to 69) - - 185 49 load_var 1 (c) - 50 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 51 pop_jump_if_false +2 (to 53) - 52 jump +7 (to 59) - - 190 53 load_const 7 ("vertex") - 54 load_const 8 (null) - 55 load_const 9 ("Could not resolve project_id for Vertex AI. Set the client's project_id option, the GOOGLE_CLOUD_PROJECT env var, or supply credentials that carry a project_id.") - 56 load_const 8 (null) - 57 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 58 throw - - 188 59 load_type 2 - 60 load_var 4 (publisher) - 61 call 138 ntypeargs=1 (baml.String.from) - 62 store_var 14 (_43) - 63 load_const 10 ("https://aiplatform.googleapis.com/v1/publishers/") - 64 load_var 14 (_43) - 65 bin_op + - 66 load_const 11 ("/models") - 67 bin_op + - - 185 68 jump +40 (to 108) - - 183 69 load_var 8 (_20) - 70 store_var 9 (resolved) - - 184 71 load_type 2 - 72 load_var 6 (host) - 73 call 138 ntypeargs=1 (baml.String.from) - 74 store_var 10 (_29) - 75 load_type 2 - 76 load_var 9 (resolved) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 11 (_32) - 79 load_type 2 - 80 load_var 5 (location) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 12 (_35) - 83 load_type 2 - 84 load_var 4 (publisher) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 13 (_38) - 87 load_const 12 ("https://") - 88 load_var 10 (_29) - 89 bin_op + - 90 load_const 13 ("/v1/projects/") - 91 bin_op + - 92 load_var 11 (_32) - 93 bin_op + - 94 load_const 14 ("/locations/") - 95 bin_op + - 96 load_var 12 (_35) - 97 bin_op + - 98 load_const 15 ("/publishers/") - 99 bin_op + - 100 load_var 13 (_38) - 101 bin_op + - 102 load_const 16 ("/models") - 103 bin_op + - - 183 104 jump +4 (to 108) - - 168 105 load_var 2 (_3) - 106 store_var 3 (explicit) - - 169 107 load_var 3 (explicit) - 108 return -} - -function google.internal._vertex_publisher(c: google.VertexClient) -> string { - 149 0 load_var 1 (c) - 1 load_field 0 (model) - 2 load_const 0 ("claude") - 3 call 148 ntypeargs=0 (baml.String.starts_with) - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 152 6 load_const 1 ("google") - - 149 7 jump +2 (to 9) - - 150 8 load_const 2 ("anthropic") - 9 return -} - -function google.internal._vertex_request(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 274 0 load_var 1 (c) - 1 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 2 load_const 0 ("anthropic") - 3 cmp_op == - 4 pop_jump_if_false +2 (to 6) - 5 jump +29 (to 34) - - 279 6 load_var 1 (c) - 7 load_type 1 - 8 load_const 2 ("id") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 5 (_7) - - 281 11 load_var 1 (c) - 12 load_field 10 (temperature) - - 282 13 load_var 1 (c) - 14 load_field 11 (max_output_tokens) - - 283 15 load_var 1 (c) - 16 load_field 12 (top_p) - - 284 17 load_var 1 (c) - 18 load_field 13 (top_k) - - 285 19 load_var 1 (c) - 20 load_field 14 (stop_sequences) - - 286 21 load_var 1 (c) - 22 load_field 15 (response_modalities) - - 280 23 call 1223 ntypeargs=0 (google.internal._gm_generation_config) - 24 store_var 6 (_8) - - 277 25 load_var2 2 5 - 26 load_var2 6 1 - - 288 27 load_field 16 (safety_settings) - - 289 28 load_var 1 (c) - 29 load_field 7 (request_body) - 30 load_const 3 (false) - - 277 31 call 1235 ntypeargs=0 (google.internal.gemini_build_body) - 32 store_var 4 (body) - 33 jump +5 (to 38) - - 275 34 load_var2 1 2 - 35 load_var 3 (stream) - 36 call 1262 ntypeargs=0 (google.internal._vertex_anthropic_body) - 37 store_var 4 (body) - - 297 38 load_var2 1 3 - 39 call 1261 ntypeargs=0 (google.internal.vertex_url) - 40 store_var 7 (url) - - 298 41 load_const 4 ("application/json") - 42 load_const 5 ("content-type") - 43 load_type 6 - 44 load_type 6 - 45 alloc_map 1 - 46 store_var_load_var 8 (headers) - - 299 47 load_var 1 (c) - 48 load_field 8 (headers) - 49 call 1222 ntypeargs=0 (google.internal._gm_apply_headers) - 50 store_var 9 (with_user) - - 300 51 load_var 1 (c) - 52 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 53 pop_jump_if_false +2 (to 55) - 54 jump +64 (to 118) - - 304 55 load_var 1 (c) - 56 call 1251 ntypeargs=0 (google.internal._vertex_credentials) - 57 store_var 10 (credentials) - - 305 58 call 1249 ntypeargs=0 (google.internal._vertex_scope) - 59 store_var 13 (_27) - 60 load_var2 10 13 - 61 call 1268 ntypeargs=0 (google.internal.gcp_access_token) - 62 store_var 11 (token) - 63 jump +19 (to 82) - 64 load_var 12 (e) - 65 throw_if_panic - - 310 66 load_type 7 - 67 load_var 12 (e) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 15 (_31) - 70 load_type 6 - 71 load_var 15 (_31) - 72 call 138 ntypeargs=1 (baml.String.from) - 73 store_var 14 (_30) - - 307 74 load_const 8 ("vertex") - 75 load_const 9 (null) - - 310 76 load_const 10 ("Vertex AI authentication failed: ") - 77 load_var 14 (_30) - 78 bin_op + - 79 load_const 9 (null) - 80 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 81 throw - - 315 82 load_type 6 - 83 load_var 11 (token) - 84 call 138 ntypeargs=1 (baml.String.from) - 85 store_var 16 (_36) - 86 load_type 6 - 87 load_type 6 - 88 load_var 9 (with_user) - 89 load_const 11 ("authorization") - 90 load_const 12 ("Bearer ") - 91 load_var 16 (_36) - 92 bin_op + - 93 call 37 ntypeargs=2 (baml.Map.set) - 94 pop 1 - - 318 95 load_type 6 - 96 load_type 6 - 97 load_var 9 (with_user) - 98 load_const 13 ("x-goog-user-project") - 99 call 38 ntypeargs=2 (baml.Map.get) - 100 load_const 9 (null) - 101 call 672 ntypeargs=0 (baml.ops.equals_equals) - 102 pop_jump_if_false +16 (to 118) - - 319 103 load_var 10 (credentials) - 104 call 1270 ntypeargs=0 (google.internal.gcp_quota_project_id) - 105 store_var 17 (_47) - 106 load_var 17 (_47) - 107 narrow_bind 14 17 - 108 pop_jump_if_false +10 (to 118) - 109 load_var 17 (_47) - 110 store_var 18 (quota) - - 320 111 load_type 6 - 112 load_type 6 - 113 load_var 9 (with_user) - 114 load_const 15 ("x-goog-user-project") - 115 load_var 18 (quota) - 116 call 37 ntypeargs=2 (baml.Map.set) - 117 pop 1 - - 325 118 load_const 16 ("POST") - 119 load_var2 7 9 - 120 load_var 4 (body) - 121 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 122 return -} - -function google.internal._vertex_scope() -> string { - 25 0 load_const 0 ("https://www.googleapis.com/auth/cloud-platform") - 1 store_var 1 (_0) - 2 load_var 1 (_0) - 3 return -} - -function google.internal._vertex_unwrap_json(document: string) -> string { - 32 0 load_var 1 (document) - 1 call 144 ntypeargs=0 (baml.String.trim) - 2 store_var 2 (trimmed) - - 33 3 load_var 2 (trimmed) - 4 load_const 0 ("\"") - 5 call 148 ntypeargs=0 (baml.String.starts_with) - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - - 38 8 load_var 1 (document) - - 33 9 jump +8 (to 17) - - 34 10 load_type 1 - 11 load_var 2 (trimmed) - 12 call 357 ntypeargs=1 (baml.json.from_string) - 13 jump +4 (to 17) - 14 load_var 3 (e) - 15 throw_if_panic - - 35 16 load_var 1 (document) - 17 return -} - -function google.internal.gcp_access_token(credentials_json: string | null, scope: string) -> string { - 25 0 load_var2 1 2 - 1 sys_op 980 (ai.internal._gcp_access_token) - 2 return -} - -function google.internal.gcp_project_id(credentials_json: string | null) -> string | null { - 33 0 load_var 1 (credentials_json) - 1 sys_op 981 (ai.internal._gcp_project_id) - 2 return -} - -function google.internal.gcp_quota_project_id(credentials_json: string | null) -> string | null { - 40 0 load_var 1 (credentials_json) - 1 sys_op 982 (ai.internal._gcp_quota_project_id) - 2 return -} - -function google.internal.gemini_build_body(input: ai.ModelTurnInput, client_id: string, generation_config: google.internal.GmGenerationConfig | null, safety_settings: google.SafetySetting[] | null, request_body: baml.json.json | null, fetch_url: bool) -> string { - 0 load_var 6 (fetch_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 696 4 load_const 1 (true) - 5 store_var 6 (fetch_url) - - 698 6 load_var 1 (input) - 7 load_field 0 (prompt) - 8 store_var 7 (_9) - 9 load_var 1 (input) - 10 load_field 3 (output_type) - 11 call 932 ntypeargs=0 (ai.wire.render_output_format) - 12 load_var 7 (_9) - 13 call_indirect - - 699 14 load_var 6 (fetch_url) - 15 call 1229 ntypeargs=0 (google.internal.google_lower_prompt) - 16 store_var 8 (lowered) - - 700 17 load_var 8 (lowered) - 18 load_field 1 (contents) - 19 store_var 9 (contents) - - 701 20 load_var 1 (input) - 21 load_field 1 (journal) - 22 load_var 2 (client_id) - 23 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 702 24 call 1234 ntypeargs=0 (google.internal.google_lower_journal) - 25 load_type 2 - 26 load_const 3 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 10 (_19) - 29 load_var 10 (_19) - 30 load_type 4 - 31 load_const 5 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 11 (_20) - 34 load_var 11 (_20) - 35 is_type 6 - 36 pop_jump_if_false +2 (to 38) - 37 jump +8 (to 45) - 38 load_var 11 (_20) - 39 store_var 12 (item) - - 703 40 load_type 7 - 41 load_var2 9 12 - 42 call 4 ntypeargs=1 (baml.Array.push) - 43 pop 1 - 44 jump -15 (to 29) - - 710 45 load_const 8 (null) - 46 store_var 13 (system) - - 711 47 load_type 7 - 48 load_var 9 (contents) - 49 load_const 9 (0) - 50 call 3 ntypeargs=1 (baml.Array.at) - 51 load_const 8 (null) - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +7 (to 61) - 55 load_type 7 - 56 load_var 9 (contents) - 57 load_const 9 (0) - 58 call 3 ntypeargs=1 (baml.Array.at) - 59 load_field 0 (0) - 60 jump +2 (to 62) - 61 load_const 8 (null) - 62 store_var_load_var 15 (_29) - 63 load_const 8 (null) - 64 cmp_op == - 65 pop_jump_if_false +3 (to 68) - 66 load_const 10 ("") - 67 store_var 15 (_29) - 68 load_var 15 (_29) - 69 store_var_load_var 14 (first_role) - - 712 70 load_const 11 ("user") - 71 cmp_op != - 72 jump_if_false +9 (to 81) - 73 pop 1 - 74 load_var 8 (lowered) - 75 load_field 0 (system_parts) - 76 container_len - 77 store_var 16 (_40) - 78 load_var 16 (_40) - 79 load_const 9 (0) - 80 cmp_int_op > - 81 pop_jump_if_false +2 (to 83) - 82 jump +15 (to 97) - - 715 83 load_var 8 (lowered) - 84 load_field 0 (system_parts) - 85 container_len - 86 store_var 17 (_48) - 87 load_var 17 (_48) - 88 load_const 9 (0) - 89 cmp_int_op > - 90 pop_jump_if_false +17 (to 107) - - 716 91 load_const 8 (null) - 92 load_var 8 (lowered) - 93 load_field 0 (system_parts) - 94 init_instance 0 (google.internal.GmContent .role, .parts) - 95 store_var 13 (system) - - 715 96 jump +11 (to 107) - - 713 97 load_type 7 - 98 load_const 12 ("user") - 99 load_var 8 (lowered) - 100 load_field 0 (system_parts) - 101 init_instance 1 (google.internal.GmContent .role, .parts) - 102 load_type 7 - 103 alloc_array 1 - 104 load_var 9 (contents) - 105 call 7 ntypeargs=1 (baml.Array.concat) - 106 store_var 9 (contents) - - 725 107 load_var 9 (contents) - 108 container_len - 109 store_var 18 (_52) - 110 load_var 18 (_52) - 111 load_const 9 (0) - 112 cmp_int_op == - 113 pop_jump_if_false +2 (to 115) - 114 jump +65 (to 179) - - 734 115 load_const 8 (null) - 116 store_var 19 (tools) - - 735 117 load_const 8 (null) - 118 store_var 20 (tool_config) - - 736 119 load_var 1 (input) - 120 load_field 2 (toolbox) - 121 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 122 unary_op ! - 123 pop_jump_if_false +42 (to 165) - - 737 124 load_type 13 - 125 alloc_array 0 - 126 store_var 21 (declarations) - - 738 127 load_var 1 (input) - 128 load_field 2 (toolbox) - 129 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 130 load_type 14 - 131 load_const 15 ("iter") - 132 virtual_call nargs=1 ntypeargs=0 - 133 store_var 22 (_62) - 134 load_var 22 (_62) - 135 load_type 16 - 136 load_const 17 ("next") - 137 virtual_call nargs=1 ntypeargs=0 - 138 store_var 23 (_63) - 139 load_var 23 (_63) - 140 is_type 6 - 141 pop_jump_if_false +2 (to 143) - 142 jump +14 (to 156) - 143 load_var 23 (_63) - 144 store_var 24 (t) - - 739 145 load_type 13 - 146 load_var2 21 24 - - 741 147 load_field 0 (name) - - 742 148 load_var 24 (t) - 149 load_field 1 (description) - - 743 150 load_var 24 (t) - 151 load_field 2 (input_schema) - 152 init_instance 2 (google.internal.GmFunctionDeclaration .name, .description, .parametersJsonSchema) - - 739 153 call 4 ntypeargs=1 (baml.Array.push) - 154 pop 1 - 155 jump -21 (to 134) - - 747 156 load_var 21 (declarations) - 157 init_instance 3 (google.internal.GmTool .functionDeclarations) - 158 load_type 18 - 159 alloc_array 1 - 160 store_var 19 (tools) - - 749 161 load_const 19 ("AUTO") - 162 init_instance 4 (google.internal.GmFunctionCallingConfig .mode) - 163 init_instance 5 (google.internal.GmToolConfig .functionCallingConfig) - 164 store_var 20 (tool_config) - - 757 165 load_var2 9 13 - - 759 166 load_var2 19 20 - - 760 167 load_var2 3 4 - 168 init_instance 6 (google.internal.GmGenerateContentRequest .contents, .systemInstruction, .tools, .toolConfig, .generationConfig, .safetySettings) - 169 store_var 25 (request) - - 764 170 load_type 20 - 171 load_var 25 (request) - 172 call 355 ntypeargs=1 (baml.json.to_json) - 173 load_const 21 (false) - 174 call 1219 ntypeargs=0 (google.internal._gm_strip_nulls) - - 765 175 load_var 5 (request_body) - 176 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 177 call 351 ntypeargs=0 (baml.json.stringify) - 178 return - - 726 179 load_const 22 ("google") - 180 load_const 8 (null) - 181 load_const 23 ("the rendered prompt and journal produced no message content") - 182 load_const 8 (null) - 183 init_instance 7 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 184 throw -} - -function google.internal.gemini_invoke(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1090 0 load_var 2 (input) - 1 load_field 1 (journal) - 2 call 905 ntypeargs=0 (ai.Journal.entries) - 3 container_len - 4 store_var 3 (seq) - - 1091 5 load_var2 1 2 - 6 call 1244 ntypeargs=0 (google.internal.google_render) - 7 store_var 4 (req) - - 1092 8 load_type 0 - 9 load_var 4 (req) - 10 load_const 1 ("google") - 11 call 931 ntypeargs=1 (ai.wire.send_as) - - 1093 12 load_var 3 (seq) - 13 load_const 2 () - 14 call 1240 ntypeargs=0 (google.internal.google_parse) - 15 return -} - -function google.internal.gemini_invoke_stream(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 1106 0 load_var2 1 2 - 1 load_const 0 (true) - 2 call 1245 ntypeargs=0 (google.internal._google_request) - - 1110 3 load_const 1 ("google") - 4 call 1242 ntypeargs=0 (google.internal._gm_open_sse) - - 1109 5 load_const 2 (google.internal._google_decode_batch) - 6 load_const 3 ("google") - 7 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 8 return -} - -function google.internal.gemini_method(stream: bool) -> string { - 770 0 load_var 1 (stream) - 1 pop_jump_if_false +2 (to 3) - 2 jump +3 (to 5) - - 773 3 load_const 0 (":generateContent") - - 770 4 jump +2 (to 6) - - 771 5 load_const 1 (":streamGenerateContent?alt=sse") - 6 return -} - -function google.internal.google_lower_journal(j: ai.Journal) -> google.internal.GmContent[] { - 590 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (contents) - - 591 3 load_type 1 - 4 alloc_array 0 - 5 store_var 4 (pending) - - 592 6 load_var 1 (j) - 7 call 905 ntypeargs=0 (ai.Journal.entries) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 5 (_5) - 12 load_var 5 (_5) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 6 (_6) - 17 load_var 6 (_6) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +205 (to 225) - 21 load_var 6 (_6) - 22 store_var 7 (e) - - 593 23 load_var 7 (e) - 24 store_var 8 (_10) - 25 load_var 8 (_10) - 26 narrow_bind 7 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +164 (to 192) - 29 load_var 7 (e) - 30 store_var 12 (_24) - 31 load_var 12 (_24) - 32 narrow_bind 8 12 - 33 pop_jump_if_false +2 (to 35) - 34 jump +64 (to 98) - 35 load_var 7 (e) - 36 store_var 28 (_61) - 37 load_var 28 (_61) - 38 narrow_bind 9 28 - 39 pop_jump_if_false +2 (to 41) - 40 jump +32 (to 72) - 41 load_var 7 (e) - 42 store_var 32 (_75) - 43 load_var 32 (_75) - 44 narrow_bind 10 32 - 45 pop_jump_if_false -33 (to 12) - 46 load_var 32 (_75) - 47 store_var 33 (f) - - 658 48 load_type 11 - 49 load_type 12 - 50 alloc_map 0 - 51 store_var 34 (response) - - 659 52 load_type 11 - 53 load_type 12 - 54 load_var 34 (response) - 55 load_const 13 ("error") - 56 load_var 33 (f) - 57 load_field 1 (message) - 58 call 37 ntypeargs=2 (baml.Map.set) - 59 pop 1 - - 662 60 load_var2 1 33 - 61 load_field 0 (id) - 62 call 1233 ntypeargs=0 (google.internal._gm_tool_name_for) - 63 load_var 34 (response) - 64 init_instance 0 (google.internal.GmFunctionResponse .name, .response) - - 661 65 call 1217 ntypeargs=0 (google.internal.GmPart.of_function_response) - 66 store_var 35 (_83) - - 660 67 load_type 1 - 68 load_var2 4 35 - 69 call 4 ntypeargs=1 (baml.Array.push) - 70 pop 1 - 71 jump -59 (to 12) - - 593 72 load_var 28 (_61) - 73 store_var 29 (c) - - 648 74 load_type 11 - 75 load_type 12 - 76 alloc_map 0 - 77 store_var 30 (response) - - 649 78 load_type 11 - 79 load_type 12 - 80 load_var 30 (response) - 81 load_const 14 ("result") - 82 load_var 29 (c) - 83 load_field 1 (output) - 84 call 37 ntypeargs=2 (baml.Map.set) - 85 pop 1 - - 652 86 load_var2 1 29 - 87 load_field 0 (id) - 88 call 1233 ntypeargs=0 (google.internal._gm_tool_name_for) - 89 load_var 30 (response) - 90 init_instance 1 (google.internal.GmFunctionResponse .name, .response) - - 651 91 call 1217 ntypeargs=0 (google.internal.GmPart.of_function_response) - 92 store_var 31 (_69) - - 650 93 load_type 1 - 94 load_var2 4 31 - 95 call 4 ntypeargs=1 (baml.Array.push) - 96 pop 1 - 97 jump -85 (to 12) - - 593 98 load_var 12 (_24) - 99 store_var 13 (a) - - 606 100 load_var 4 (pending) - 101 container_len - 102 store_var 14 (_27) - 103 load_var 14 (_27) - 104 load_const 15 (0) - 105 cmp_int_op > - 106 pop_jump_if_false +11 (to 117) - - 607 107 load_type 0 - 108 load_var 3 (contents) - 109 load_const 16 ("user") - 110 load_var 4 (pending) - 111 init_instance 2 (google.internal.GmContent .role, .parts) - 112 call 4 ntypeargs=1 (baml.Array.push) - 113 pop 1 - - 608 114 load_type 1 - 115 alloc_array 0 - 116 store_var 4 (pending) - - 613 117 load_type 1 - 118 alloc_array 0 - 119 store_var 15 (parts) - - 614 120 load_var 13 (a) - 121 load_field 0 (content) - 122 load_type 17 - 123 load_const 18 ("iter") - 124 virtual_call nargs=1 ntypeargs=0 - 125 store_var 16 (_34) - 126 load_var 16 (_34) - 127 load_type 19 - 128 load_const 20 ("next") - 129 virtual_call nargs=1 ntypeargs=0 - 130 store_var 17 (_35) - 131 load_var 17 (_35) - 132 is_type 6 - 133 pop_jump_if_false +2 (to 135) - 134 jump +43 (to 177) - 135 load_var 17 (_35) - 136 store_var 18 (b) - - 615 137 load_var 18 (b) - 138 store_var 19 (_39) - 139 load_var 19 (_39) - 140 narrow_bind 21 19 - 141 pop_jump_if_false +2 (to 143) - 142 jump +25 (to 167) - 143 load_var 18 (b) - 144 store_var 22 (_45) - 145 load_var 22 (_45) - 146 narrow_bind 22 22 - 147 pop_jump_if_false -21 (to 126) - 148 load_var 22 (_45) - 149 store_var_load_var 23 (use) - - 626 150 load_field 1 (name) - 151 load_var 23 (use) - 152 load_field 2 (args) - 153 init_instance 3 (google.internal.GmFunctionCall .name, .args) - 154 store_var 25 (_49) - - 627 155 load_var 23 (use) - 156 load_field 0 (id) - 157 call 1232 ntypeargs=0 (google.internal._gm_call_id_signature) - 158 store_var 26 (_52) - - 625 159 load_var2 25 26 - 160 call 1216 ntypeargs=0 (google.internal.GmPart.of_function_call) - 161 store_var 24 (_48) - - 624 162 load_type 1 - 163 load_var2 15 24 - 164 call 4 ntypeargs=1 (baml.Array.push) - 165 pop 1 - 166 jump -40 (to 126) - - 615 167 load_var 19 (_39) - 168 store_var_load_var 20 (t) - - 617 169 load_field 0 (text) - 170 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 171 store_var 21 (_42) - 172 load_type 1 - 173 load_var2 15 21 - 174 call 4 ntypeargs=1 (baml.Array.push) - 175 pop 1 - 176 jump -50 (to 126) - - 639 177 load_var 15 (parts) - 178 container_len - 179 store_var 27 (_56) - 180 load_var 27 (_56) - 181 load_const 15 (0) - 182 cmp_int_op > - 183 pop_jump_if_false -171 (to 12) - - 640 184 load_type 0 - 185 load_var 3 (contents) - 186 load_const 23 ("model") - 187 load_var 15 (parts) - 188 init_instance 4 (google.internal.GmContent .role, .parts) - 189 call 4 ntypeargs=1 (baml.Array.push) - 190 pop 1 - 191 jump -179 (to 12) - - 593 192 load_var 8 (_10) - 193 store_var 9 (u) - - 595 194 load_var 4 (pending) - 195 container_len - 196 store_var 10 (_13) - 197 load_var 10 (_13) - 198 load_const 15 (0) - 199 cmp_int_op > - 200 pop_jump_if_false +11 (to 211) - - 596 201 load_type 0 - 202 load_var 3 (contents) - 203 load_const 24 ("user") - 204 load_var 4 (pending) - 205 init_instance 5 (google.internal.GmContent .role, .parts) - 206 call 4 ntypeargs=1 (baml.Array.push) - 207 pop 1 - - 597 208 load_type 1 - 209 alloc_array 0 - 210 store_var 4 (pending) - - 602 211 load_var 9 (u) - 212 load_field 0 (content) - 213 call 1213 ntypeargs=0 (google.internal.GmPart.of_text) - 214 store_var 11 (_21) - 215 load_type 0 - 216 load_var 3 (contents) - 217 load_const 25 ("user") - 218 load_var 11 (_21) - 219 load_type 1 - 220 alloc_array 1 - 221 init_instance 6 (google.internal.GmContent .role, .parts) - 222 call 4 ntypeargs=1 (baml.Array.push) - 223 pop 1 - 224 jump -212 (to 12) - - 670 225 load_var 4 (pending) - 226 container_len - 227 store_var 36 (_90) - 228 load_var 36 (_90) - 229 load_const 15 (0) - 230 cmp_int_op > - 231 pop_jump_if_false +8 (to 239) - - 671 232 load_type 0 - 233 load_var 3 (contents) - 234 load_const 26 ("user") - 235 load_var 4 (pending) - 236 init_instance 7 (google.internal.GmContent .role, .parts) - 237 call 4 ntypeargs=1 (baml.Array.push) - 238 pop 1 - - 676 239 load_var 3 (contents) - 240 store_var 2 (_0) - 241 load_var 2 (_0) - 242 return -} - -function google.internal.google_lower_prompt(prompt: ai.Prompt, fetch_url: bool) -> google.internal.GooglePrompt { - 0 load_var 2 (fetch_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 489 4 load_const 1 (true) - 5 store_var 2 (fetch_url) - - 490 6 load_type 2 - 7 alloc_array 0 - 8 store_var 4 (system_parts) - - 491 9 load_type 3 - 10 alloc_array 0 - 11 store_var 5 (contents) - - 492 12 load_var 1 (prompt) - 13 call 910 ntypeargs=0 (ai.Prompt.messages) - 14 load_type 4 - 15 load_const 5 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_7) - 18 load_var 6 (_7) - 19 load_type 6 - 20 load_const 7 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_8) - 23 load_var 7 (_8) - 24 is_type 8 - 25 pop_jump_if_false +2 (to 27) - 26 jump +51 (to 77) - 27 load_var 7 (_8) - 28 store_var_load_var 8 (message) - - 493 29 load_var 2 (fetch_url) - 30 call 1228 ntypeargs=0 (google.internal._gm_prompt_parts) - 31 store_var 9 (parts) - - 494 32 load_var 8 (message) - 33 load_field 0 (role) - 34 load_const 9 ("system") - 35 cmp_op == - 36 pop_jump_if_false +2 (to 38) - 37 jump +19 (to 56) - - 500 38 load_var 8 (message) - 39 load_field 0 (role) - 40 load_const 10 ("assistant") - 41 cmp_op == - 42 pop_jump_if_false +2 (to 44) - 43 jump +4 (to 47) - - 503 44 load_const 11 ("user") - 45 store_var 13 (role) - - 500 46 jump +3 (to 49) - - 501 47 load_const 12 ("model") - 48 store_var 13 (role) - - 505 49 load_type 3 - 50 load_var2 5 13 - 51 load_var 9 (parts) - 52 init_instance 0 (google.internal.GmContent .role, .parts) - 53 call 4 ntypeargs=1 (baml.Array.push) - 54 pop 1 - 55 jump -37 (to 18) - - 495 56 load_var 9 (parts) - 57 load_type 13 - 58 load_const 14 ("iter") - 59 virtual_call nargs=1 ntypeargs=0 - 60 store_var 10 (_17) - 61 load_var 10 (_17) - 62 load_type 15 - 63 load_const 16 ("next") - 64 virtual_call nargs=1 ntypeargs=0 - 65 store_var 11 (_18) - 66 load_var 11 (_18) - 67 is_type 8 - 68 pop_jump_if_false +2 (to 70) - 69 jump -51 (to 18) - 70 load_var 11 (_18) - 71 store_var 12 (part) - - 496 72 load_type 2 - 73 load_var2 4 12 - 74 call 4 ntypeargs=1 (baml.Array.push) - 75 pop 1 - 76 jump -15 (to 61) - - 509 77 load_var2 4 5 - 78 init_instance 1 (google.internal.GooglePrompt .system_parts, .contents) - 79 store_var 3 (_0) - 80 load_var 3 (_0) - 81 return -} - -function google.internal.google_parse(resp: google.internal.GmResponse, seq: int, provider: string) -> ai.ModelTurn { - 0 load_var 3 (provider) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 834 4 load_const 1 ("google") - 5 store_var 3 (provider) - - 838 6 load_var 1 (resp) - 7 load_field 5 (error) - 8 store_var 5 (_6) - 9 load_var 5 (_6) - 10 narrow_bind 2 5 - 11 pop_jump_if_false +2 (to 13) - 12 jump +284 (to 296) - - 845 13 load_type 3 - 14 alloc_array 0 - 15 store_var 10 (content) - - 846 16 load_const 4 (false) - 17 store_var 11 (has_call) - - 847 18 load_const 5 (0) - 19 store_var 12 (call_index) - - 848 20 load_var 1 (resp) - 21 load_field 0 (candidates) - 22 load_const 6 (null) - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +8 (to 33) - 26 load_const 5 (0) - 27 load_var 1 (resp) - 28 load_field 0 (candidates) - 29 make_bound_method 3 - 30 call_indirect - 31 store_var 13 (cand) - 32 jump +3 (to 35) - 33 load_const 6 (null) - 34 store_var 13 (cand) - - 849 35 load_var 13 (cand) - 36 load_const 6 (null) - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +4 (to 43) - 40 load_var 13 (cand) - 41 load_field 1 (1) - 42 jump +2 (to 44) - 43 load_const 6 (null) - 44 store_var_load_var 15 (_28) - 45 load_const 6 (null) - 46 cmp_op == - 47 pop_jump_if_false +3 (to 50) - 48 load_const 7 ("") - 49 store_var 15 (_28) - 50 load_var 15 (_28) - 51 store_var 14 (finish) - - 850 52 load_var 13 (cand) - 53 load_const 6 (null) - 54 cmp_op == - 55 pop_jump_if_false +2 (to 57) - 56 jump +16 (to 72) - 57 load_var 13 (cand) - 58 load_field 0 (0) - 59 load_const 6 (null) - 60 cmp_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +10 (to 72) - 63 load_var 13 (cand) - 64 load_const 6 (null) - 65 cmp_op == - 66 pop_jump_if_false +2 (to 68) - 67 jump +5 (to 72) - 68 load_var 13 (cand) - 69 load_field 0 (0) - 70 load_field 1 (1) - 71 jump +2 (to 73) - 72 load_const 6 (null) - 73 store_var_load_var 17 (_35) - 74 load_const 6 (null) - 75 cmp_op == - 76 pop_jump_if_false +4 (to 80) - 77 load_type 8 - 78 alloc_array 0 - 79 store_var 17 (_35) - 80 load_var 17 (_35) - 81 store_var_load_var 16 (parts) - - 851 82 load_type 9 - 83 load_const 10 ("iter") - 84 virtual_call nargs=1 ntypeargs=0 - 85 store_var 18 (_48) - 86 load_var 18 (_48) - 87 load_type 11 - 88 load_const 12 ("next") - 89 virtual_call nargs=1 ntypeargs=0 - 90 store_var 19 (_49) - 91 load_var 19 (_49) - 92 is_type 13 - 93 pop_jump_if_false +2 (to 95) - 94 jump +124 (to 218) - 95 load_var 19 (_49) - 96 store_var_load_var 20 (p) - - 852 97 load_field 3 (functionCall) - 98 store_var 21 (_54) - 99 load_var 21 (_54) - 100 narrow_bind 14 21 - 101 pop_jump_if_false +2 (to 103) - 102 jump +66 (to 168) - - 867 103 load_var 20 (p) - 104 load_field 4 (inlineData) - 105 store_var 29 (_76) - 106 load_var 29 (_76) - 107 narrow_bind 15 29 - 108 pop_jump_if_false +2 (to 110) - 109 jump +32 (to 141) - - 874 110 load_var 20 (p) - 111 load_field 0 (text) - 112 store_var 35 (_90) - 113 load_var 35 (_90) - 114 narrow_bind 16 35 - 115 pop_jump_if_false -29 (to 86) - 116 load_var 35 (_90) - 117 store_var 36 (t) - - 875 118 load_var 20 (p) - 119 load_field 1 (thought) - 120 store_var_load_var 37 (_93) - 121 load_const 6 (null) - 122 cmp_op == - 123 pop_jump_if_false +3 (to 126) - 124 load_const 4 (false) - 125 store_var 37 (_93) - 126 load_var 37 (_93) - 127 pop_jump_if_false +2 (to 129) - 128 jump +7 (to 135) - - 879 129 load_type 3 - 130 load_var2 10 36 - 131 init_instance 0 (ai.content.Text .text) - 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - 134 jump -48 (to 86) - - 876 135 load_type 3 - 136 load_var2 10 36 - 137 init_instance 1 (ai.content.Reasoning .summary) - 138 call 4 ntypeargs=1 (baml.Array.push) - 139 pop 1 - 140 jump -54 (to 86) - - 867 141 load_var 29 (_76) - 142 store_var_load_var 30 (inline) - - 870 143 load_field 0 (mimeType) - 144 store_var_load_var 33 (_81) - 145 load_const 6 (null) - 146 cmp_op == - 147 pop_jump_if_false +3 (to 150) - 148 load_const 17 ("image/png") - 149 store_var 33 (_81) - 150 load_var 33 (_81) - 151 store_var 32 (_80) - 152 load_var 30 (inline) - 153 load_field 1 (data) - 154 store_var_load_var 34 (_85) - 155 load_const 6 (null) - 156 cmp_op == - 157 pop_jump_if_false +3 (to 160) - 158 load_const 18 ("") - 159 store_var 34 (_85) - 160 load_var2 32 34 - 161 call 1237 ntypeargs=0 (google.internal._gm_output_media) - 162 store_var 31 (_79) - - 869 163 load_type 3 - 164 load_var2 10 31 - 165 call 4 ntypeargs=1 (baml.Array.push) - 166 pop 1 - 167 jump -81 (to 86) - - 852 168 load_var 21 (_54) - 169 store_var 22 (fc) - - 853 170 load_type 19 - 171 load_type 20 - 172 alloc_map 0 - 173 store_var 23 (args) - - 854 174 load_var 22 (fc) - 175 load_field 1 (args) - 176 store_var 24 (_58) - 177 load_var 24 (_58) - 178 narrow_bind 21 24 - 179 pop_jump_if_false +5 (to 184) - 180 load_var 24 (_58) - 181 store_var 25 (a) - - 855 182 load_var 25 (a) - 183 store_var 23 (args) - - 859 184 load_type 22 - 185 load_var 2 (seq) - 186 call 138 ntypeargs=1 (baml.String.from) - 187 store_var 27 (_66) - 188 load_type 22 - 189 load_var 12 (call_index) - 190 call 138 ntypeargs=1 (baml.String.from) - 191 store_var 28 (_68) - 192 load_const 23 ("call_") - 193 load_var 27 (_66) - 194 bin_op + - 195 load_const 24 ("_") - 196 bin_op + - 197 load_var 28 (_68) - 198 bin_op + - 199 load_var 20 (p) - 200 load_field 2 (thoughtSignature) - 201 call 1231 ntypeargs=0 (google.internal._gm_encode_call_id) - 202 store_var 26 (_62) - - 857 203 load_type 3 - 204 load_var2 10 26 - - 860 205 load_var 22 (fc) - 206 load_field 0 (name) - - 861 207 load_var 23 (args) - 208 init_instance 2 (ai.content.ToolUse .id, .name, .args) - - 857 209 call 4 ntypeargs=1 (baml.Array.push) - 210 pop 1 - - 864 211 load_var 12 (call_index) - 212 load_const 16 (1) - 213 add_int - 214 store_var 12 (call_index) - - 865 215 load_const 25 (true) - 216 store_var 11 (has_call) - - 852 217 jump -131 (to 86) - - 887 218 load_var 1 (resp) - 219 load_field 2 (promptFeedback) - 220 load_const 6 (null) - 221 cmp_op == - 222 pop_jump_if_false +2 (to 224) - 223 jump +5 (to 228) - 224 load_var 1 (resp) - 225 load_field 2 (promptFeedback) - 226 load_field 0 (0) - 227 jump +2 (to 229) - 228 load_const 6 (null) - 229 load_const 6 (null) - 230 call 672 ntypeargs=0 (baml.ops.equals_equals) - 231 unary_op ! - 232 store_var 38 (blocked) - - 893 233 load_var 10 (content) - 234 container_len - 235 store_var 39 (_113) - 236 load_var 39 (_113) - 237 load_const 5 (0) - 238 cmp_int_op == - 239 jump_if_false +5 (to 244) - 240 pop 1 - 241 load_var 14 (finish) - 242 load_const 26 ("") - 243 cmp_op == - 244 jump_if_false +4 (to 248) - 245 pop 1 - 246 load_var 38 (blocked) - 247 unary_op ! - 248 pop_jump_if_false +2 (to 250) - 249 jump +39 (to 288) - - 899 250 load_var 11 (has_call) - 251 pop_jump_if_false +2 (to 253) - 252 jump +23 (to 275) - - 901 253 load_var 14 (finish) - 254 load_const 27 ("MAX_TOKENS") - 255 cmp_op == - 256 pop_jump_if_false +2 (to 258) - 257 jump +15 (to 272) - - 903 258 load_var 38 (blocked) - 259 jump_if_false +2 (to 261) - 260 jump +4 (to 264) - 261 pop 1 - 262 load_var 14 (finish) - 263 call 1238 ntypeargs=0 (google.internal._gm_is_blocked) - 264 pop_jump_if_false +2 (to 266) - 265 jump +4 (to 269) - - 906 266 load_const 5 (ai.content.StopReason.Complete) - 267 alloc_variant 774 (ai.content.StopReason) - - 903 268 jump +9 (to 277) - - 904 269 load_const 28 (ai.content.StopReason.Refused) - 270 alloc_variant 774 (ai.content.StopReason) - - 903 271 jump +6 (to 277) - - 902 272 load_const 29 (ai.content.StopReason.MaxTokens) - 273 alloc_variant 774 (ai.content.StopReason) - - 901 274 jump +3 (to 277) - - 900 275 load_const 16 (ai.content.StopReason.ToolUse) - 276 alloc_variant 774 (ai.content.StopReason) - - 908 277 store_var 41 (_128) - 278 load_var 1 (resp) - 279 load_field 1 (usageMetadata) - 280 call 1239 ntypeargs=0 (google.internal._gm_usage) - 281 store_var 42 (_129) - 282 load_var2 10 41 - 283 load_var 42 (_129) - 284 init_instance 3 (ai.ModelTurn .content, .stop_reason, .usage) - 285 store_var 4 (_0) - 286 load_var 4 (_0) - 287 return - - 896 288 load_type 30 - 289 load_var 1 (resp) - 290 call 355 ntypeargs=1 (baml.json.to_json) - 291 call 351 ntypeargs=0 (baml.json.stringify) - 292 store_var 40 (_117) - - 894 293 load_var2 3 40 - 294 init_instance 4 (ai.errors.ParseFailed .provider, .raw_output) - 295 throw - - 838 296 load_var 5 (_6) - 297 store_var_load_var 6 (err) - - 841 298 load_field 0 (code) - 299 store_var_load_var 8 (_10) - 300 load_const 6 (null) - 301 cmp_op == - 302 pop_jump_if_false +3 (to 305) - 303 load_const 5 (0) - 304 store_var 8 (_10) - 305 load_var 8 (_10) - 306 store_var 7 (_9) - - 842 307 load_var 6 (err) - 308 load_field 1 (message) - 309 store_var_load_var 9 (_14) - 310 load_const 6 (null) - 311 cmp_op == - 312 pop_jump_if_false +6 (to 318) - 313 load_type 30 - 314 load_var 1 (resp) - 315 call 355 ntypeargs=1 (baml.json.to_json) - 316 call 351 ntypeargs=0 (baml.json.stringify) - 317 store_var 9 (_14) - - 839 318 load_var2 3 7 - - 842 319 load_var 9 (_14) - 320 load_const 0 () - - 839 321 call 977 ntypeargs=0 (ai.errors.classify_http) - 322 throw -} - -function google.internal.google_render(c: google.GoogleClient, input: ai.ModelTurnInput) -> baml.http.Request { - 1050 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1245 ntypeargs=0 (google.internal._google_request) - 3 return -} - -function google.internal.vertex_invoke(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 331 0 load_var2 1 2 - 1 call 1263 ntypeargs=0 (google.internal.vertex_render) - 2 store_var 3 (req) - - 332 3 load_var 1 (c) - 4 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 5 load_const 0 ("anthropic") - 6 cmp_op == - 7 pop_jump_if_false +2 (to 9) - 8 jump +14 (to 22) - - 336 9 load_var 2 (input) - 10 load_field 1 (journal) - 11 call 905 ntypeargs=0 (ai.Journal.entries) - 12 container_len - 13 store_var 4 (seq) - - 337 14 load_type 1 - 15 load_var 3 (req) - 16 load_const 2 ("vertex") - 17 call 931 ntypeargs=1 (ai.wire.send_as) - - 338 18 load_var 4 (seq) - 19 load_const 3 ("vertex") - 20 call 1240 ntypeargs=0 (google.internal.google_parse) - 21 jump +6 (to 27) - - 333 22 load_type 4 - 23 load_var 3 (req) - 24 load_const 5 ("vertex") - 25 call 931 ntypeargs=1 (ai.wire.send_as) - - 334 26 call 1191 ntypeargs=0 (anthropic.internal.anthropic_parse) - 27 return -} - -function google.internal.vertex_invoke_stream(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 4 - 1 make_cell - 2 store_var 4 - - 353 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1264 ntypeargs=0 (google.internal._vertex_request) - - 354 6 load_const 1 ("vertex") - 7 call 1242 ntypeargs=0 (google.internal._gm_open_sse) - 8 store_var 3 (sse) - - 359 9 load_var 1 (c) - 10 call 1257 ntypeargs=0 (google.internal._vertex_publisher) - 11 load_const 2 ("anthropic") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +6 (to 20) - - 369 15 load_var 3 (sse) - 16 load_const 3 (google.internal._vertex_decode_batch) - 17 load_const 4 ("vertex") - 18 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 19 jump +7 (to 26) - - 360 20 call 1193 ntypeargs=0 (anthropic.internal.AnthStreamState.new) - 21 store_deref 4 - - 362 22 load_var2 3 4 - - 363 23 make_closure 3630 1 - 24 load_const 5 ("vertex") - - 361 25 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 26 return -} - -function google.internal.vertex_location(c: google.VertexClient) -> string { - 98 0 load_var 1 (c) - 1 load_field 2 (location) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +37 (to 43) - - 101 7 load_const 1 ("GOOGLE_CLOUD_LOCATION") - 8 sys_op 226 (baml.env.get) - 9 store_var 4 (_6) - 10 load_var 4 (_6) - 11 narrow_bind 0 4 - 12 pop_jump_if_false +9 (to 21) - 13 load_var 4 (_6) - 14 store_var 5 (from_env) - - 102 15 load_var 5 (from_env) - 16 call 144 ntypeargs=0 (baml.String.trim) - 17 load_const 2 ("") - 18 cmp_op != - 19 pop_jump_if_false +2 (to 21) - 20 jump +20 (to 40) - - 106 21 load_const 3 ("GOOGLE_CLOUD_REGION") - 22 sys_op 226 (baml.env.get) - 23 store_var 6 (_11) - 24 load_var 6 (_11) - 25 narrow_bind 0 6 - 26 pop_jump_if_false +9 (to 35) - 27 load_var 6 (_11) - 28 store_var 7 (from_region) - - 107 29 load_var 7 (from_region) - 30 call 144 ntypeargs=0 (baml.String.trim) - 31 load_const 4 ("") - 32 cmp_op != - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - - 111 35 load_const 5 ("global") - 36 jump +10 (to 46) - - 108 37 load_var 7 (from_region) - 38 call 144 ntypeargs=0 (baml.String.trim) - 39 jump +7 (to 46) - - 103 40 load_var 5 (from_env) - 41 call 144 ntypeargs=0 (baml.String.trim) - 42 jump +4 (to 46) - - 98 43 load_var 2 (_3) - 44 store_var 3 (explicit) - - 99 45 load_var 3 (explicit) - 46 return -} - -function google.internal.vertex_project_id(c: google.VertexClient) -> string | null { - 127 0 load_var 1 (c) - 1 load_field 1 (project_id) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +45 (to 51) - - 130 7 load_var 1 (c) - 8 call 1254 ntypeargs=0 (google.internal._vertex_is_express) - 9 pop_jump_if_false +2 (to 11) - 10 jump +39 (to 49) - - 133 11 load_const 1 ("GOOGLE_CLOUD_PROJECT") - 12 sys_op 226 (baml.env.get) - 13 store_var 4 (_7) - 14 load_var 4 (_7) - 15 narrow_bind 0 4 - 16 pop_jump_if_false +9 (to 25) - 17 load_var 4 (_7) - 18 store_var 5 (from_env) - - 134 19 load_var 5 (from_env) - 20 call 144 ntypeargs=0 (baml.String.trim) - 21 load_const 2 ("") - 22 cmp_op != - 23 pop_jump_if_false +2 (to 25) - 24 jump +22 (to 46) - - 138 25 load_const 3 ("GCLOUD_PROJECT") - 26 sys_op 226 (baml.env.get) - 27 store_var 6 (_12) - 28 load_var 6 (_12) - 29 narrow_bind 0 6 - 30 pop_jump_if_false +9 (to 39) - 31 load_var 6 (_12) - 32 store_var 7 (legacy) - - 139 33 load_var 7 (legacy) - 34 call 144 ntypeargs=0 (baml.String.trim) - 35 load_const 4 ("") - 36 cmp_op != - 37 pop_jump_if_false +2 (to 39) - 38 jump +5 (to 43) - - 143 39 load_var 1 (c) - 40 call 1251 ntypeargs=0 (google.internal._vertex_credentials) - 41 call 1269 ntypeargs=0 (google.internal.gcp_project_id) - 42 jump +12 (to 54) - - 140 43 load_var 7 (legacy) - 44 call 144 ntypeargs=0 (baml.String.trim) - 45 jump +9 (to 54) - - 135 46 load_var 5 (from_env) - 47 call 144 ntypeargs=0 (baml.String.trim) - 48 jump +6 (to 54) - - 131 49 load_const 5 (null) - 50 jump +4 (to 54) - - 127 51 load_var 2 (_3) - 52 store_var 3 (explicit) - - 128 53 load_var 3 (explicit) - 54 return -} - -function google.internal.vertex_render(c: google.VertexClient, input: ai.ModelTurnInput) -> baml.http.Request { - 264 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1264 ntypeargs=0 (google.internal._vertex_request) - 3 return -} - -function google.internal.vertex_url(c: google.VertexClient, stream: bool) -> string { - 216 0 load_var 1 (c) - 1 call 1259 ntypeargs=0 (google.internal._vertex_models_base) - 2 store_var 5 (_8) - 3 load_type 0 - 4 load_var 5 (_8) - 5 call 138 ntypeargs=1 (baml.String.from) - 6 store_var 4 (_7) - 7 load_type 0 - 8 load_var 1 (c) - 9 load_field 0 (model) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 6 (_10) - 12 load_var2 1 2 - 13 call 1260 ntypeargs=0 (google.internal._vertex_method) - 14 store_var 8 (_14) - 15 load_type 0 - 16 load_var 8 (_14) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 7 (_13) - 19 load_var 4 (_7) - 20 load_const 1 ("/") - 21 bin_op + - 22 load_var 6 (_10) - 23 bin_op + - 24 load_var 7 (_13) - 25 bin_op + - - 217 26 load_var 1 (c) - 27 load_field 9 (query_params) - - 215 28 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 29 store_var 3 (with_params) - - 219 30 load_var 1 (c) - 31 call 1252 ntypeargs=0 (google.internal._vertex_express_key) - 32 store_var 9 (_18) - 33 load_var 9 (_18) - 34 narrow_bind 2 9 - 35 pop_jump_if_false +2 (to 37) - 36 jump +3 (to 39) - - 223 37 load_var 3 (with_params) - - 219 38 jump +10 (to 48) - 39 load_var 9 (_18) - 40 store_var_load_var 10 (key) - - 220 41 load_const 3 ("key") - 42 load_type 0 - 43 load_type 0 - 44 alloc_map 1 - 45 store_var 11 (params) - - 221 46 load_var2 3 11 - 47 call 1221 ntypeargs=0 (google.internal._gm_apply_query) - 48 return -} - -function openai.AzureClient.ai.Client.id(self: openai.AzureClient) -> string { - 187 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("azure/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.AzureClient.ai.Client.invoke(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 191 0 load_var 1 (self) - 1 call 1071 ntypeargs=0 (openai.AzureClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1072 ntypeargs=0 (openai.AzureClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 192 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.AzureClient.ai.stream.StreamingClient.invoke_stream(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 199 0 load_var 1 (self) - 1 call 1071 ntypeargs=0 (openai.AzureClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1072 ntypeargs=0 (openai.AzureClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 200 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.AzureClient.compat(self: openai.AzureClient) -> openai.internal.ChatCompat { - 154 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 2 (query) - - 155 4 load_var 1 (self) - 5 load_field 3 (api_version) - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +10 (to 19) - 10 load_var 3 (_4) - 11 store_var 4 (version) - - 156 12 load_type 0 - 13 load_type 0 - 14 load_var 2 (query) - 15 load_const 2 ("api-version") - 16 load_var 4 (version) - 17 call 37 ntypeargs=2 (baml.Map.set) - 18 pop 1 - - 160 19 load_var 1 (self) - 20 call 1070 ntypeargs=0 (openai.AzureClient.resolved_base_url) - 21 store_var 5 (_10) - - 158 22 load_const 3 ("azure") - 23 load_var 5 (_10) - 24 load_const 4 () - 25 load_const 1 (openai.internal.ChatAuth.ApiKeyHeader) - 26 alloc_variant 777 (openai.internal.ChatAuth) - 27 load_const 5 ("AZURE_OPENAI_API_KEY") - 28 load_const 6 (true) - 29 load_const 4 () - 30 load_const 4 () - 31 load_const 4 () - 32 load_const 4 () - 33 load_const 7 (4096) - 34 load_const 4 () - - 165 35 load_var 2 (query) - - 158 36 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 37 return -} - -function openai.AzureClient.new(model: string, resource_name: string | null, deployment_id: string | null, api_version: string | null, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.AzureClient { - 0 load_var 2 (resource_name) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 60 4 load_const 1 (null) - 5 store_var 2 (resource_name) - 6 load_var 3 (deployment_id) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 61 10 load_const 1 (null) - 11 store_var 3 (deployment_id) - 12 load_var 4 (api_version) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 62 16 load_const 2 ("2024-10-21") - 17 store_var 4 (api_version) - 18 load_var 5 (base_url) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 63 22 load_const 1 (null) - 23 store_var 5 (base_url) - 24 load_var 6 (api_key) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 64 28 load_const 1 (null) - 29 store_var 6 (api_key) - 30 load_var 7 (request_body) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 65 34 load_const 1 (null) - 35 store_var 7 (request_body) - 36 load_var 8 (headers) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 66 40 load_const 1 (null) - 41 store_var 8 (headers) - 42 load_var 9 (query_params) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 67 46 load_const 1 (null) - 47 store_var 9 (query_params) - 48 load_var 10 (temperature) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 68 52 load_const 1 (null) - 53 store_var 10 (temperature) - 54 load_var 11 (max_tokens) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 69 58 load_const 1 (null) - 59 store_var 11 (max_tokens) - 60 load_var 12 (max_completion_tokens) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 70 64 load_const 1 (null) - 65 store_var 12 (max_completion_tokens) - 66 load_var 13 (top_p) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 71 70 load_const 1 (null) - 71 store_var 13 (top_p) - 72 load_var 14 (stop) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 72 76 load_const 1 (null) - 77 store_var 14 (stop) - 78 load_var 15 (seed) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 73 82 load_const 1 (null) - 83 store_var 15 (seed) - - 75 84 load_var2 1 2 - 85 load_var2 3 4 - 86 load_var2 5 6 - 87 load_var2 7 8 - 88 load_var2 9 10 - 89 load_var2 11 12 - 90 load_var2 13 14 - 91 load_var 15 (seed) - 92 init_instance 0 (openai.AzureClient .model, .resource_name, .deployment_id, .api_version, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed) - 93 return -} - -function openai.AzureClient.params(self: openai.AzureClient) -> openai.internal.ChatParams { - 171 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 172 3 load_var 1 (self) - 4 call 1068 ntypeargs=0 (openai.AzureClient.resolved_api_key) - 5 store_var 3 (_3) - - 170 6 load_var2 2 3 - - 173 7 load_var 1 (self) - 8 load_field 9 (temperature) - - 174 9 load_var 1 (self) - 10 load_field 10 (max_tokens) - - 175 11 load_var 1 (self) - 12 load_field 11 (max_completion_tokens) - - 176 13 load_var 1 (self) - 14 load_field 12 (top_p) - - 177 15 load_var 1 (self) - 16 load_field 13 (stop) - - 178 17 load_var 1 (self) - 18 load_field 14 (seed) - - 179 19 load_var 1 (self) - 20 load_field 7 (headers) - - 180 21 load_var 1 (self) - 22 load_field 8 (query_params) - - 181 23 load_var 1 (self) - 24 load_field 6 (request_body) - - 170 25 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 26 return -} - -function openai.AzureClient.resolved_api_key(self: openai.AzureClient) -> string | null { - 95 0 load_var 1 (self) - 1 load_field 5 (api_key) - 2 load_const 0 ("AZURE_OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.AzureClient.resolved_base_url(self: openai.AzureClient) -> string { - 126 0 load_var 1 (self) - 1 load_field 4 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +74 (to 82) - - 134 9 load_var 1 (self) - 10 call 1069 ntypeargs=0 (openai.AzureClient.resolved_deployment_id) - 11 store_var 4 (deployment) - - 135 12 load_var 1 (self) - 13 load_field 1 (resource_name) - 14 store_var 5 (_15) - 15 load_var 5 (_15) - 16 narrow_bind 1 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +46 (to 64) - - 140 19 load_const 0 (null) - 20 load_const 2 ("AZURE_OPENAI_ENDPOINT") - 21 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 22 store_var 9 (_26) - 23 load_var 9 (_26) - 24 narrow_bind 1 9 - 25 pop_jump_if_false +2 (to 27) - 26 jump +4 (to 30) - - 148 27 load_const 3 ("openai.AzureClient needs a deployment endpoint: set base_url, or resource_name, or the AZURE_OPENAI_ENDPOINT environment variable") - 28 call 1098 ntypeargs=0 (openai.internal._azure_reject) - 29 throw - - 140 30 load_var 9 (_26) - 31 store_var 10 (endpoint) - - 141 32 load_var 10 (endpoint) - 33 load_const 4 ("/") - 34 call 149 ntypeargs=0 (baml.String.ends_with) - 35 pop_jump_if_false +2 (to 37) - 36 jump +4 (to 40) - - 144 37 load_var 10 (endpoint) - 38 store_var 11 (origin) - - 141 39 jump +11 (to 50) - - 142 40 load_var 10 (endpoint) - 41 call 139 ntypeargs=0 (baml.String.length) - 42 store_var 12 (_31) - 43 load_var 10 (endpoint) - 44 load_const 5 (0) - 45 load_var 12 (_31) - 46 load_const 1 (1) - 47 sub_int - 48 call 153 ntypeargs=0 (baml.String.slice) - 49 store_var 11 (origin) - - 146 50 load_type 6 - 51 load_var 11 (origin) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 13 (_33) - 54 load_type 6 - 55 load_var 4 (deployment) - 56 call 138 ntypeargs=1 (baml.String.from) - 57 store_var 14 (_36) - 58 load_var 13 (_33) - 59 load_const 7 ("/openai/deployments/") - 60 bin_op + - 61 load_var 14 (_36) - 62 bin_op + - 63 jump +37 (to 100) - - 135 64 load_var 5 (_15) - 65 store_var 6 (resource_name) - - 136 66 load_type 6 - 67 load_var 6 (resource_name) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 7 (_19) - 70 load_type 6 - 71 load_var 4 (deployment) - 72 call 138 ntypeargs=1 (baml.String.from) - 73 store_var 8 (_22) - 74 load_const 8 ("https://") - 75 load_var 7 (_19) - 76 bin_op + - 77 load_const 9 (".openai.azure.com/openai/deployments/") - 78 bin_op + - 79 load_var 8 (_22) - 80 bin_op + - 81 jump +19 (to 100) - - 126 82 load_var 2 (_4) - 83 store_var 3 (explicit) - - 127 84 load_var 1 (self) - 85 load_field 1 (resource_name) - 86 load_const 0 (null) - 87 call 672 ntypeargs=0 (baml.ops.equals_equals) - 88 unary_op ! - 89 jump_if_false +2 (to 91) - 90 jump +7 (to 97) - 91 pop 1 - 92 load_var 1 (self) - 93 load_field 2 (deployment_id) - 94 load_const 0 (null) - 95 call 672 ntypeargs=0 (baml.ops.equals_equals) - 96 unary_op ! - 97 pop_jump_if_false +2 (to 99) - 98 jump +3 (to 101) - - 132 99 load_var 3 (explicit) - 100 return - - 128 101 load_const 10 ("openai.AzureClient takes base_url OR resource_name/deployment_id, not both") - 102 call 1098 ntypeargs=0 (openai.internal._azure_reject) - 103 throw -} - -function openai.AzureClient.resolved_deployment_id(self: openai.AzureClient) -> string { - 100 0 load_var 1 (self) - 1 load_field 2 (deployment_id) - 2 store_var_load_var 2 (_2) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (self) - 7 load_field 0 (model) - 8 store_var 2 (_2) - 9 load_var 2 (_2) - 10 return -} - -function openai.ChatClient.ai.Client.id(self: openai.ChatClient) -> string { - 111 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("openai-chat/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.ChatClient.ai.Client.invoke(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 115 0 load_var 1 (self) - 1 call 1054 ntypeargs=0 (openai.ChatClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1055 ntypeargs=0 (openai.ChatClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 116 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.ChatClient.ai.stream.StreamingClient.invoke_stream(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 123 0 load_var 1 (self) - 1 call 1054 ntypeargs=0 (openai.ChatClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1055 ntypeargs=0 (openai.ChatClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 124 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.ChatClient.compat(self: openai.ChatClient) -> openai.internal.ChatCompat { - 86 0 load_var 1 (self) - 1 call 1053 ntypeargs=0 (openai.ChatClient.resolved_base_url) - 2 store_var 2 (_2) - - 84 3 load_const 0 ("openai-chat") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 2 ("OPENAI_API_KEY") - 8 load_const 3 (true) - 9 load_const 1 () - 10 load_const 1 () - 11 load_const 3 (true) - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.ChatClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.ChatClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 38 4 load_const 1 ("gpt-4o-mini") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 39 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 40 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (request_body) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 41 22 load_const 2 (null) - 23 store_var 4 (request_body) - 24 load_var 5 (headers) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 42 28 load_const 2 (null) - 29 store_var 5 (headers) - 30 load_var 6 (query_params) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 43 34 load_const 2 (null) - 35 store_var 6 (query_params) - 36 load_var 7 (temperature) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 44 40 load_const 2 (null) - 41 store_var 7 (temperature) - 42 load_var 8 (max_tokens) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 45 46 load_const 2 (null) - 47 store_var 8 (max_tokens) - 48 load_var 9 (max_completion_tokens) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 46 52 load_const 2 (null) - 53 store_var 9 (max_completion_tokens) - 54 load_var 10 (top_p) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 47 58 load_const 2 (null) - 59 store_var 10 (top_p) - 60 load_var 11 (stop) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 48 64 load_const 2 (null) - 65 store_var 11 (stop) - 66 load_var 12 (seed) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 49 70 load_const 2 (null) - 71 store_var 12 (seed) - - 51 72 load_var2 1 2 - 73 load_var2 3 4 - 74 load_var2 5 6 - 75 load_var2 7 8 - 76 load_var2 9 10 - 77 load_var2 11 12 - 78 init_instance 0 (openai.ChatClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed) - 79 return -} - -function openai.ChatClient.params(self: openai.ChatClient) -> openai.internal.ChatParams { - 95 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 96 3 load_var 1 (self) - 4 call 1052 ntypeargs=0 (openai.ChatClient.resolved_api_key) - 5 store_var 3 (_3) - - 94 6 load_var2 2 3 - - 97 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 98 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - - 99 11 load_var 1 (self) - 12 load_field 8 (max_completion_tokens) - - 100 13 load_var 1 (self) - 14 load_field 9 (top_p) - - 101 15 load_var 1 (self) - 16 load_field 10 (stop) - - 102 17 load_var 1 (self) - 18 load_field 11 (seed) - - 103 19 load_var 1 (self) - 20 load_field 4 (headers) - - 104 21 load_var 1 (self) - 22 load_field 5 (query_params) - - 105 23 load_var 1 (self) - 24 load_field 3 (request_body) - - 94 25 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 26 return -} - -function openai.ChatClient.resolved_api_key(self: openai.ChatClient) -> string | null { - 72 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.ChatClient.resolved_base_url(self: openai.ChatClient) -> string { - 77 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("https://api.openai.com/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.GenericClient.ai.Client.id(self: openai.GenericClient) -> string { - 110 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("openai-generic/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.GenericClient.ai.Client.invoke(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 114 0 load_var 1 (self) - 1 call 1062 ntypeargs=0 (openai.GenericClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1063 ntypeargs=0 (openai.GenericClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 115 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.GenericClient.ai.stream.StreamingClient.invoke_stream(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 122 0 load_var 1 (self) - 1 call 1062 ntypeargs=0 (openai.GenericClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1063 ntypeargs=0 (openai.GenericClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 123 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.GenericClient.compat(self: openai.GenericClient) -> openai.internal.ChatCompat { - 88 0 load_var 1 (self) - 1 call 1061 ntypeargs=0 (openai.GenericClient.resolved_base_url) - 2 store_var 2 (_2) - - 86 3 load_const 0 ("openai-generic") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 1 () - 8 load_const 1 () - 9 load_const 2 (true) - 10 load_const 1 () - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.GenericClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.GenericClient { - 0 load_var 2 (base_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 35 4 load_const 1 (null) - 5 store_var 2 (base_url) - 6 load_var 3 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 36 10 load_const 1 (null) - 11 store_var 3 (api_key) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 37 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 38 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 39 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 40 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 41 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 42 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 43 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 44 58 load_const 1 (null) - 59 store_var 11 (seed) - - 46 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.GenericClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.GenericClient.params(self: openai.GenericClient) -> openai.internal.ChatParams { - 95 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 96 3 load_var 1 (self) - 4 call 1060 ntypeargs=0 (openai.GenericClient.resolved_api_key) - 5 store_var 3 (_3) - - 94 6 load_var2 2 3 - - 97 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 98 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 99 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 100 14 load_var 1 (self) - 15 load_field 9 (stop) - - 101 16 load_var 1 (self) - 17 load_field 10 (seed) - - 102 18 load_var 1 (self) - 19 load_field 4 (headers) - - 103 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 104 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 94 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.GenericClient.resolved_api_key(self: openai.GenericClient) -> string | null { - 64 0 load_var 1 (self) - 1 load_field 2 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.GenericClient.resolved_base_url(self: openai.GenericClient) -> string { - 72 0 load_var 1 (self) - 1 load_field 1 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +16 (to 24) - - 81 9 load_var 1 (self) - 10 load_field 1 (base_url) - 11 load_const 0 (null) - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 2 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - - 79 18 load_const 3 ("openai-generic") - - 81 19 load_const 4 ("openai.GenericClient requires base_url (a literal or env.NAME naming a set variable): the endpoint of the OpenAI-compatible server, e.g. \"http://localhost:8000/v1\". Checked: ") - 20 load_var 4 (_8) - 21 bin_op + - - 79 22 call 1097 ntypeargs=0 (openai.internal._reject) - 23 throw - - 72 24 load_var 2 (_4) - 25 store_var 3 (explicit) - - 73 26 load_var 3 (explicit) - 27 return -} - -function openai.ImageClient.ai.Client.id(self: openai.ImageClient) -> string { - 133 0 load_var 1 (self) - 1 call 1141 ntypeargs=0 (openai.internal._oai_images_client_id) - 2 return -} - -function openai.ImageClient.ai.Client.invoke(self: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 137 0 load_var2 1 2 - 1 call 1155 ntypeargs=0 (openai.internal.images_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 138 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, quality: string | null, background: string | null, output_format: string | null, output_compression: int | null, moderation: string | null, style: string | null, user: string | null, response_format: string | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ImageClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 73 4 load_const 1 ("gpt-image-1") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 74 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 75 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (n) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 76 22 load_const 2 (null) - 23 store_var 4 (n) - 24 load_var 5 (size) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 77 28 load_const 2 (null) - 29 store_var 5 (size) - 30 load_var 6 (quality) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 78 34 load_const 2 (null) - 35 store_var 6 (quality) - 36 load_var 7 (background) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 79 40 load_const 2 (null) - 41 store_var 7 (background) - 42 load_var 8 (output_format) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 80 46 load_const 2 (null) - 47 store_var 8 (output_format) - 48 load_var 9 (output_compression) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 81 52 load_const 2 (null) - 53 store_var 9 (output_compression) - 54 load_var 10 (moderation) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 82 58 load_const 2 (null) - 59 store_var 10 (moderation) - 60 load_var 11 (style) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 83 64 load_const 2 (null) - 65 store_var 11 (style) - 66 load_var 12 (user) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 84 70 load_const 2 (null) - 71 store_var 12 (user) - 72 load_var 13 (response_format) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 85 76 load_const 2 (null) - 77 store_var 13 (response_format) - 78 load_var 14 (request_body) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 86 82 load_const 2 (null) - 83 store_var 14 (request_body) - 84 load_var 15 (headers) - 85 load_const 0 () - 86 cmp_op == - 87 pop_jump_if_false +3 (to 90) - - 87 88 load_const 2 (null) - 89 store_var 15 (headers) - 90 load_var 16 (query_params) - 91 load_const 0 () - 92 cmp_op == - 93 pop_jump_if_false +3 (to 96) - - 88 94 load_const 2 (null) - 95 store_var 16 (query_params) - - 90 96 load_var2 1 2 - 97 load_var2 3 4 - 98 load_var2 5 6 - 99 load_var2 7 8 - 100 load_var2 9 10 - 101 load_var2 11 12 - 102 load_var2 13 14 - 103 load_var2 15 16 - 104 init_instance 0 (openai.ImageClient .model, .api_key, .base_url, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format, .request_body, .headers, .query_params) - 105 return -} - -function openai.ImageClient.resolved_api_key(self: openai.ImageClient) -> string { - 115 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 121 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("OPENAI_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 3 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - - 118 18 load_const 4 ("openai-images") - 19 load_const 5 (null) - - 121 20 load_const 6 ("no OpenAI API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — ") - 21 load_var 4 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 115 26 load_var 2 (_4) - 27 store_var 3 (key) - - 116 28 load_var 3 (key) - 29 return -} - -function openai.ImageClient.resolved_base_url(self: openai.ImageClient) -> string | null { - 128 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OllamaClient.ai.Client.id(self: openai.OllamaClient) -> string { - 93 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("ollama/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.OllamaClient.ai.Client.invoke(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 97 0 load_var 1 (self) - 1 call 1079 ntypeargs=0 (openai.OllamaClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1080 ntypeargs=0 (openai.OllamaClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 98 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OllamaClient.ai.stream.StreamingClient.invoke_stream(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 105 0 load_var 1 (self) - 1 call 1079 ntypeargs=0 (openai.OllamaClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1080 ntypeargs=0 (openai.OllamaClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 106 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OllamaClient.compat(self: openai.OllamaClient) -> openai.internal.ChatCompat { - 70 0 load_var 1 (self) - 1 call 1078 ntypeargs=0 (openai.OllamaClient.resolved_base_url) - 2 store_var 2 (_2) - - 68 3 load_const 0 ("ollama") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 1 () - 8 load_const 1 () - 9 load_const 2 (true) - 10 load_const 2 (true) - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.OllamaClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OllamaClient { - 0 load_var 2 (base_url) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 33 4 load_const 1 (null) - 5 store_var 2 (base_url) - 6 load_var 3 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 34 10 load_const 1 (null) - 11 store_var 3 (api_key) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 35 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 36 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 37 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 38 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 39 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 40 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 41 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 42 58 load_const 1 (null) - 59 store_var 11 (seed) - - 44 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.OllamaClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.OllamaClient.params(self: openai.OllamaClient) -> openai.internal.ChatParams { - 78 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 79 3 load_var 1 (self) - 4 call 1077 ntypeargs=0 (openai.OllamaClient.resolved_api_key) - 5 store_var 3 (_3) - - 77 6 load_var2 2 3 - - 80 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 81 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 82 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 83 14 load_var 1 (self) - 15 load_field 9 (stop) - - 84 16 load_var 1 (self) - 17 load_field 10 (seed) - - 85 18 load_var 1 (self) - 19 load_field 4 (headers) - - 86 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 87 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 77 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.OllamaClient.resolved_api_key(self: openai.OllamaClient) -> string | null { - 60 0 load_var 1 (self) - 1 load_field 2 (api_key) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OllamaClient.resolved_base_url(self: openai.OllamaClient) -> string { - 64 0 load_var 1 (self) - 1 load_field 1 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("http://localhost:11434/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.OpenRouterClient.ai.Client.id(self: openai.OpenRouterClient) -> string { - 91 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("openrouter/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.OpenRouterClient.ai.Client.invoke(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 95 0 load_var 1 (self) - 1 call 1087 ntypeargs=0 (openai.OpenRouterClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1088 ntypeargs=0 (openai.OpenRouterClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1134 ntypeargs=0 (openai.internal.chat_invoke) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 96 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OpenRouterClient.ai.stream.StreamingClient.invoke_stream(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 103 0 load_var 1 (self) - 1 call 1087 ntypeargs=0 (openai.OpenRouterClient.compat) - 2 store_var 4 (_4) - 3 load_var 1 (self) - 4 call 1088 ntypeargs=0 (openai.OpenRouterClient.params) - 5 store_var 5 (_5) - 6 load_var2 4 5 - 7 load_var 2 (input) - 8 call 1140 ntypeargs=0 (openai.internal.chat_invoke_stream) - 9 jump +6 (to 15) - 10 load_var 3 (e) - 11 throw_if_panic - - 104 12 load_var 3 (e) - 13 call 968 ntypeargs=0 (ai.errors.normalize) - 14 throw - 15 return -} - -function openai.OpenRouterClient.compat(self: openai.OpenRouterClient) -> openai.internal.ChatCompat { - 68 0 load_var 1 (self) - 1 call 1086 ntypeargs=0 (openai.OpenRouterClient.resolved_base_url) - 2 store_var 2 (_2) - - 66 3 load_const 0 ("openrouter") - 4 load_var 2 (_2) - 5 load_const 1 () - 6 load_const 1 () - 7 load_const 2 ("OPENROUTER_API_KEY") - 8 load_const 3 (true) - 9 load_const 1 () - 10 load_const 1 () - 11 load_const 1 () - 12 load_const 1 () - 13 load_const 1 () - 14 load_const 1 () - 15 load_const 1 () - 16 call 1099 ntypeargs=0 (openai.internal.ChatCompat.new) - 17 return -} - -function openai.OpenRouterClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OpenRouterClient { - 0 load_var 2 (api_key) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 31 4 load_const 1 (null) - 5 store_var 2 (api_key) - 6 load_var 3 (base_url) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 32 10 load_const 1 (null) - 11 store_var 3 (base_url) - 12 load_var 4 (request_body) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 33 16 load_const 1 (null) - 17 store_var 4 (request_body) - 18 load_var 5 (headers) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 34 22 load_const 1 (null) - 23 store_var 5 (headers) - 24 load_var 6 (query_params) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 35 28 load_const 1 (null) - 29 store_var 6 (query_params) - 30 load_var 7 (temperature) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 36 34 load_const 1 (null) - 35 store_var 7 (temperature) - 36 load_var 8 (max_tokens) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 37 40 load_const 1 (null) - 41 store_var 8 (max_tokens) - 42 load_var 9 (top_p) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 38 46 load_const 1 (null) - 47 store_var 9 (top_p) - 48 load_var 10 (stop) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 39 52 load_const 1 (null) - 53 store_var 10 (stop) - 54 load_var 11 (seed) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 40 58 load_const 1 (null) - 59 store_var 11 (seed) - - 42 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (seed) - 66 init_instance 0 (openai.OpenRouterClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed) - 67 return -} - -function openai.OpenRouterClient.params(self: openai.OpenRouterClient) -> openai.internal.ChatParams { - 76 0 load_var 1 (self) - 1 load_field 0 (model) - 2 store_var 2 (_2) - - 77 3 load_var 1 (self) - 4 call 1085 ntypeargs=0 (openai.OpenRouterClient.resolved_api_key) - 5 store_var 3 (_3) - - 75 6 load_var2 2 3 - - 78 7 load_var 1 (self) - 8 load_field 6 (temperature) - - 79 9 load_var 1 (self) - 10 load_field 7 (max_tokens) - 11 load_const 0 () - - 80 12 load_var 1 (self) - 13 load_field 8 (top_p) - - 81 14 load_var 1 (self) - 15 load_field 9 (stop) - - 82 16 load_var 1 (self) - 17 load_field 10 (seed) - - 83 18 load_var 1 (self) - 19 load_field 4 (headers) - - 84 20 load_var 1 (self) - 21 load_field 5 (query_params) - - 85 22 load_var 1 (self) - 23 load_field 3 (request_body) - - 75 24 call 1100 ntypeargs=0 (openai.internal.ChatParams.new) - 25 return -} - -function openai.OpenRouterClient.resolved_api_key(self: openai.OpenRouterClient) -> string | null { - 58 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENROUTER_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.OpenRouterClient.resolved_base_url(self: openai.OpenRouterClient) -> string { - 62 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var_load_var 2 (_2) - 5 load_const 0 (null) - 6 cmp_op == - 7 pop_jump_if_false +3 (to 10) - 8 load_const 1 ("https://openrouter.ai/api/v1") - 9 store_var 2 (_2) - 10 load_var 2 (_2) - 11 return -} - -function openai.ResponsesClient.ai.Client.id(self: openai.ResponsesClient) -> string { - 123 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 3 (_2) - 5 load_const 1 ("openai/") - 6 load_var 3 (_2) - 7 bin_op + - 8 store_var 2 (_0) - 9 load_var 2 (_0) - 10 return -} - -function openai.ResponsesClient.ai.Client.invoke(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 127 0 load_var2 1 2 - 1 call 1043 ntypeargs=0 (openai.internal.invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 128 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ResponsesClient.ai.stream.StreamingClient.invoke_stream(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 135 0 load_var2 1 2 - 1 call 1050 ntypeargs=0 (openai.internal.invoke_stream) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 136 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function openai.ResponsesClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, temperature: float | null, top_p: float | null, max_output_tokens: int | null, reasoning_effort: string | null, reasoning_summary: string | null, verbosity: string | null, parallel_tool_calls: bool | null, store: bool, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ResponsesClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 63 4 load_const 1 ("gpt-4o-mini") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 64 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 65 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (temperature) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 66 22 load_const 2 (null) - 23 store_var 4 (temperature) - 24 load_var 5 (top_p) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 67 28 load_const 2 (null) - 29 store_var 5 (top_p) - 30 load_var 6 (max_output_tokens) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 68 34 load_const 2 (null) - 35 store_var 6 (max_output_tokens) - 36 load_var 7 (reasoning_effort) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 69 40 load_const 2 (null) - 41 store_var 7 (reasoning_effort) - 42 load_var 8 (reasoning_summary) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 70 46 load_const 2 (null) - 47 store_var 8 (reasoning_summary) - 48 load_var 9 (verbosity) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 71 52 load_const 2 (null) - 53 store_var 9 (verbosity) - 54 load_var 10 (parallel_tool_calls) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 72 58 load_const 2 (null) - 59 store_var 10 (parallel_tool_calls) - 60 load_var 11 (store) - 61 load_const 0 () - 62 cmp_op == - 63 pop_jump_if_false +3 (to 66) - - 73 64 load_const 3 (false) - 65 store_var 11 (store) - 66 load_var 12 (request_body) - 67 load_const 0 () - 68 cmp_op == - 69 pop_jump_if_false +3 (to 72) - - 74 70 load_const 2 (null) - 71 store_var 12 (request_body) - 72 load_var 13 (headers) - 73 load_const 0 () - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - - 75 76 load_const 2 (null) - 77 store_var 13 (headers) - 78 load_var 14 (query_params) - 79 load_const 0 () - 80 cmp_op == - 81 pop_jump_if_false +3 (to 84) - - 76 82 load_const 2 (null) - 83 store_var 14 (query_params) - - 78 84 load_var2 1 2 - 85 load_var2 3 4 - 86 load_var2 5 6 - 87 load_var2 7 8 - 88 load_var2 9 10 - 89 load_var2 11 12 - 90 load_var2 13 14 - 91 init_instance 0 (openai.ResponsesClient .model, .api_key, .base_url, .temperature, .top_p, .max_output_tokens, .reasoning_effort, .reasoning_summary, .verbosity, .parallel_tool_calls, .store, .request_body, .headers, .query_params) - 92 return -} - -function openai.ResponsesClient.resolved_api_key(self: openai.ResponsesClient) -> string { - 105 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("OPENAI_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 111 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("OPENAI_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 3 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - - 108 18 load_const 4 ("openai") - 19 load_const 5 (null) - - 111 20 load_const 6 ("openai needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — ") - 21 load_var 4 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 105 26 load_var 2 (_4) - 27 store_var 3 (k) - - 106 28 load_var 3 (k) - 29 return -} - -function openai.ResponsesClient.resolved_base_url(self: openai.ResponsesClient) -> string | null { - 118 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function openai.internal.CcToolCall.baml.FromJson.from_json(j: baml.json.json) -> openai.internal.CcToolCall { - 389 0 load_var 1 (j) - 1 load_const 0 ("id") - 2 call 360 ntypeargs=0 (baml.json.field) - 3 store_var 3 (_3) - 4 load_type 1 - 5 load_var 3 (_3) - 6 call 359 ntypeargs=1 (baml.json.to) - - 390 7 load_var 1 (j) - 8 load_const 2 ("type") - 9 call 360 ntypeargs=0 (baml.json.field) - 10 store_var 4 (_6) - 11 load_type 1 - 12 load_var 4 (_6) - 13 call 359 ntypeargs=1 (baml.json.to) - - 391 14 load_var 1 (j) - 15 load_const 3 ("index") - 16 call 360 ntypeargs=0 (baml.json.field) - 17 store_var 5 (_9) - 18 load_type 4 - 19 load_var 5 (_9) - 20 call 359 ntypeargs=1 (baml.json.to) - - 392 21 load_var 1 (j) - 22 load_const 5 ("function") - 23 call 360 ntypeargs=0 (baml.json.field) - 24 store_var 6 (_12) - 25 load_type 6 - 26 load_var 6 (_12) - 27 call 359 ntypeargs=1 (baml.json.to) - - 388 28 init_instance 0 (openai.internal.CcToolCall .id, .type, .index, .fn) - 29 store_var 2 (_0) - 30 load_var 2 (_0) - 31 return -} - -function openai.internal.ChatCompat.new(provider: string, base_url: string, path: string, auth: openai.internal.ChatAuth, api_key_env: string | null, api_key_required: bool, collapse_text_content: bool, inline_image_urls: bool, send_stream_options: bool, max_tokens_key: string, default_max_tokens: int | null, default_role: string, compat_query: map | null) -> openai.internal.ChatCompat { - 0 load_var 3 (path) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 116 4 load_const 1 ("/chat/completions") - 5 store_var 3 (path) - 6 load_var 4 (auth) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +4 (to 13) - - 117 10 load_const 2 (openai.internal.ChatAuth.Bearer) - 11 alloc_variant 777 (openai.internal.ChatAuth) - 12 store_var 4 (auth) - 13 load_var 5 (api_key_env) - 14 load_const 0 () - 15 cmp_op == - 16 pop_jump_if_false +3 (to 19) - - 118 17 load_const 3 (null) - 18 store_var 5 (api_key_env) - 19 load_var 6 (api_key_required) - 20 load_const 0 () - 21 cmp_op == - 22 pop_jump_if_false +3 (to 25) - - 119 23 load_const 4 (false) - 24 store_var 6 (api_key_required) - 25 load_var 7 (collapse_text_content) - 26 load_const 0 () - 27 cmp_op == - 28 pop_jump_if_false +3 (to 31) - - 120 29 load_const 4 (false) - 30 store_var 7 (collapse_text_content) - 31 load_var 8 (inline_image_urls) - 32 load_const 0 () - 33 cmp_op == - 34 pop_jump_if_false +3 (to 37) - - 121 35 load_const 4 (false) - 36 store_var 8 (inline_image_urls) - 37 load_var 9 (send_stream_options) - 38 load_const 0 () - 39 cmp_op == - 40 pop_jump_if_false +3 (to 43) - - 122 41 load_const 4 (false) - 42 store_var 9 (send_stream_options) - 43 load_var 10 (max_tokens_key) - 44 load_const 0 () - 45 cmp_op == - 46 pop_jump_if_false +3 (to 49) - - 123 47 load_const 5 ("max_tokens") - 48 store_var 10 (max_tokens_key) - 49 load_var 11 (default_max_tokens) - 50 load_const 0 () - 51 cmp_op == - 52 pop_jump_if_false +3 (to 55) - - 124 53 load_const 3 (null) - 54 store_var 11 (default_max_tokens) - 55 load_var 12 (default_role) - 56 load_const 0 () - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - - 125 59 load_const 6 ("user") - 60 store_var 12 (default_role) - 61 load_var 13 (compat_query) - 62 load_const 0 () - 63 cmp_op == - 64 pop_jump_if_false +3 (to 67) - - 126 65 load_const 3 (null) - 66 store_var 13 (compat_query) - - 128 67 load_type 7 - 68 load_type 7 - 69 alloc_map 0 - 70 store_var 14 (empty) - - 142 71 load_var 13 (compat_query) - 72 store_var_load_var 15 (_27) - 73 load_const 3 (null) - 74 cmp_op == - 75 pop_jump_if_false +3 (to 78) - 76 load_var 14 (empty) - 77 store_var 15 (_27) - - 129 78 load_var2 1 2 - 79 load_var2 3 4 - 80 load_var2 5 6 - 81 load_var2 7 8 - 82 load_var2 9 10 - 83 load_var2 11 12 - - 142 84 load_var 15 (_27) - 85 init_instance 0 (openai.internal.ChatCompat .provider, .base_url, .path, .auth, .api_key_env, .api_key_required, .collapse_text_content, .inline_image_urls, .send_stream_options, .max_tokens_key, .default_max_tokens, .default_role, .compat_query) - 86 return -} - -function openai.internal.ChatExtraPart.baml.ToJson.to_json(self: openai.internal.ChatExtraPart) -> baml.json.json { - 263 0 load_type 0 - 1 load_var 1 (self) - 2 load_field 0 (part) - 3 call 355 ntypeargs=1 (baml.json.to_json) - 4 store_var 2 (base) - - 264 5 load_var 2 (base) - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +3 (to 13) - - 275 11 load_var 2 (base) - - 264 12 jump +63 (to 75) - 13 load_var 3 (_5) - 14 store_var 4 (object) - - 266 15 load_type 2 - 16 load_type 3 - 17 alloc_map 0 - 18 store_var 5 (out) - - 267 19 load_type 2 - 20 load_type 3 - 21 load_var 4 (object) - 22 call 35 ntypeargs=2 (baml.Map.keys) - 23 load_type 4 - 24 load_const 5 ("iter") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 6 (_11) - 27 load_var 6 (_11) - 28 load_type 6 - 29 load_const 7 ("next") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 7 (_12) - 32 load_var 7 (_12) - 33 is_type 8 - 34 pop_jump_if_false +2 (to 36) - 35 jump +15 (to 50) - 36 load_var 7 (_12) - 37 store_var 8 (key) - - 268 38 load_type 2 - 39 load_type 3 - 40 load_var2 4 8 - 41 call 38 ntypeargs=2 (baml.Map.get) - 42 store_var 9 (_18) - 43 load_type 2 - 44 load_type 3 - 45 load_var2 5 8 - 46 load_var 9 (_18) - 47 call 37 ntypeargs=2 (baml.Map.set) - 48 pop 1 - 49 jump -22 (to 27) - - 270 50 load_type 2 - 51 load_type 3 - 52 load_var 1 (self) - 53 load_field 1 (extra) - 54 call 35 ntypeargs=2 (baml.Map.keys) - 55 container_len - 56 store_var 10 (_25) - 57 load_var 10 (_25) - 58 load_const 9 (0) - 59 cmp_int_op > - 60 pop_jump_if_false +14 (to 74) - - 271 61 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 62 store_var 11 (_31) - 63 load_type 1 - 64 load_var 1 (self) - 65 load_field 1 (extra) - 66 call 355 ntypeargs=1 (baml.json.to_json) - 67 store_var 12 (_32) - 68 load_type 2 - 69 load_type 3 - 70 load_var2 5 11 - 71 load_var 12 (_32) - 72 call 37 ntypeargs=2 (baml.Map.set) - 73 pop 1 - - 273 74 load_var 5 (out) - 75 return -} - -function openai.internal.ChatParams.new(model: string, api_key: string | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null, headers: map | null, query_params: map | null, request_body: baml.json.json | null) -> openai.internal.ChatParams { - 0 load_var 2 (api_key) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 166 4 load_const 1 (null) - 5 store_var 2 (api_key) - 6 load_var 3 (temperature) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 167 10 load_const 1 (null) - 11 store_var 3 (temperature) - 12 load_var 4 (max_tokens) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 168 16 load_const 1 (null) - 17 store_var 4 (max_tokens) - 18 load_var 5 (max_completion_tokens) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 169 22 load_const 1 (null) - 23 store_var 5 (max_completion_tokens) - 24 load_var 6 (top_p) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 170 28 load_const 1 (null) - 29 store_var 6 (top_p) - 30 load_var 7 (stop) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 171 34 load_const 1 (null) - 35 store_var 7 (stop) - 36 load_var 8 (seed) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 172 40 load_const 1 (null) - 41 store_var 8 (seed) - 42 load_var 9 (headers) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 173 46 load_const 1 (null) - 47 store_var 9 (headers) - 48 load_var 10 (query_params) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 174 52 load_const 1 (null) - 53 store_var 10 (query_params) - 54 load_var 11 (request_body) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 175 58 load_const 1 (null) - 59 store_var 11 (request_body) - - 177 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 load_var 11 (request_body) - 66 init_instance 0 (openai.internal.ChatParams .model, .api_key, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .headers, .query_params, .request_body) - 67 return -} - -function openai.internal.ChatStreamDecoder._absorb_call(self: openai.internal.ChatStreamDecoder, delta: openai.internal.CcToolCall, position: int) -> void { - 0 load_var 4 - 1 make_cell - 2 store_var 4 - - 1396 3 load_var 2 (delta) - 4 load_field 2 (index) - 5 store_var_load_var 5 (_5) - 6 load_const 0 (null) - 7 cmp_op == - 8 pop_jump_if_false +3 (to 11) - 9 load_var 3 (position) - 10 store_var 5 (_5) - 11 load_var 5 (_5) - 12 store_deref 4 - - 1397 13 load_type 1 - 14 load_type 2 - 15 load_var 1 (self) - 16 load_field 1 (calls) - - 1398 17 load_var 4 (index) - 18 make_closure 3022 1 - - 1397 19 call 19 ntypeargs=2 (baml.Array.find) - - 1402 20 store_var 7 (_14) - 21 load_var 7 (_14) - 22 narrow_bind 3 7 - 23 pop_jump_if_false +2 (to 25) - 24 jump +16 (to 40) - - 1405 25 load_deref 4 - 26 load_const 4 ("") - 27 load_const 5 ("") - 28 load_const 6 ("") - 29 init_instance 0 (openai.internal.ChatToolCallBuffer .index, .id, .name, .arguments) - 30 store_var 9 (fresh) - - 1406 31 load_type 1 - 32 load_var 1 (self) - 33 load_field 1 (calls) - 34 load_var 9 (fresh) - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - - 1407 37 load_var 9 (fresh) - 38 store_var 6 (buffer) - - 1402 39 jump +5 (to 44) - 40 load_var 7 (_14) - 41 store_var 8 (found) - - 1403 42 load_var 8 (found) - 43 store_var 6 (buffer) - - 1410 44 load_var 2 (delta) - 45 load_field 0 (id) - 46 store_var 10 (_23) - 47 load_var 10 (_23) - 48 narrow_bind 7 10 - 49 pop_jump_if_false +5 (to 54) - 50 load_var 10 (_23) - 51 store_var 11 (id) - - 1411 52 load_var2 6 11 - 53 store_field 1 (id) - - 1413 54 load_var 2 (delta) - 55 load_field 3 (fn) - 56 load_const 0 (null) - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +5 (to 64) - 60 load_var 2 (delta) - 61 load_field 3 (fn) - 62 load_field 0 (0) - 63 jump +2 (to 65) - 64 load_const 0 (null) - 65 store_var 12 (_29) - 66 load_var 12 (_29) - 67 narrow_bind 7 12 - 68 pop_jump_if_false +16 (to 84) - 69 load_var 12 (_29) - 70 store_var 13 (name) - - 1414 71 load_type 8 - 72 load_var 6 (buffer) - 73 load_field 2 (name) - 74 call 138 ntypeargs=1 (baml.String.from) - 75 store_var 14 (_31) - 76 load_type 8 - 77 load_var 13 (name) - 78 call 138 ntypeargs=1 (baml.String.from) - 79 store_var 15 (_34) - 80 load_var2 6 14 - 81 load_var 15 (_34) - 82 bin_op + - 83 store_field 2 (name) - - 1416 84 load_var 2 (delta) - 85 load_field 3 (fn) - 86 load_const 0 (null) - 87 cmp_op == - 88 pop_jump_if_false +2 (to 90) - 89 jump +5 (to 94) - 90 load_var 2 (delta) - 91 load_field 3 (fn) - 92 load_field 1 (1) - 93 jump +2 (to 95) - 94 load_const 0 (null) - 95 store_var 16 (_41) - 96 load_var 16 (_41) - 97 narrow_bind 7 16 - 98 pop_jump_if_false +2 (to 100) - 99 jump +3 (to 102) - 100 load_const 0 (null) - 101 jump +17 (to 118) - 102 load_var 16 (_41) - 103 store_var 17 (fragment) - - 1417 104 load_type 8 - 105 load_var 6 (buffer) - 106 load_field 3 (arguments) - 107 call 138 ntypeargs=1 (baml.String.from) - 108 store_var 18 (_43) - 109 load_type 8 - 110 load_var 17 (fragment) - 111 call 138 ntypeargs=1 (baml.String.from) - 112 store_var 19 (_46) - 113 load_var2 6 18 - 114 load_var 19 (_46) - 115 bin_op + - 116 store_field 3 (arguments) - - 1416 117 load_const 0 (null) - 118 return -} - -function openai.internal.ChatStreamDecoder.decode(self: openai.internal.ChatStreamDecoder, batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1423 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 1424 3 load_var 2 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +209 (to 226) - 18 load_var 6 (_6) - 19 store_var_load_var 7 (raw) - - 1425 20 load_field 1 (data) - 21 store_var 8 (_11) - 22 load_var 8 (_11) - 23 narrow_bind 6 8 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 8 (_11) - 26 store_var 9 (data) - - 1426 27 load_var 9 (data) - 28 call 144 ntypeargs=0 (baml.String.trim) - 29 load_const 7 ("[DONE]") - 30 cmp_op == - 31 pop_jump_if_false +2 (to 33) - 32 jump +188 (to 220) - - 1430 33 load_var 9 (data) - 34 call 350 ntypeargs=0 (baml.json.parse) - 35 store_var 12 (_20) - - 1429 36 load_type 8 - 37 load_var 12 (_20) - 38 call 359 ntypeargs=1 (baml.json.to) - 39 store_var 10 (parsed) - 40 jump +5 (to 45) - 41 load_var 11 (e) - 42 throw_if_panic - - 1432 43 load_const 9 (null) - 44 store_var 10 (parsed) - - 1439 45 load_var 10 (parsed) - 46 load_const 9 (null) - 47 call 672 ntypeargs=0 (baml.ops.equals_equals) - 48 jump_if_false +6 (to 54) - 49 pop 1 - 50 load_var 9 (data) - 51 call 144 ntypeargs=0 (baml.String.trim) - 52 load_const 10 ("{") - 53 call 148 ntypeargs=0 (baml.String.starts_with) - 54 pop_jump_if_false +2 (to 56) - 55 jump +160 (to 215) - - 1442 56 load_var 10 (parsed) - 57 store_var 13 (_30) - 58 load_var 13 (_30) - 59 narrow_bind 11 13 - 60 pop_jump_if_false -51 (to 9) - 61 load_var 13 (_30) - 62 store_var_load_var 14 (chunk) - - 1443 63 load_field 2 (choices) - 64 store_var_load_var 16 (_33) - 65 load_const 9 (null) - 66 cmp_op == - 67 pop_jump_if_false +4 (to 71) - 68 load_type 12 - 69 alloc_array 0 - 70 store_var 16 (_33) - 71 load_var 16 (_33) - 72 store_var 15 (choices) - - 1444 73 load_type 12 - 74 load_var 15 (choices) - 75 load_const 13 (0) - 76 call 3 ntypeargs=1 (baml.Array.at) - 77 store_var 17 (_38) - 78 load_var 17 (_38) - 79 narrow_bind 14 17 - 80 pop_jump_if_false +116 (to 196) - 81 load_var 17 (_38) - 82 store_var_load_var 18 (choice) - - 1445 83 load_field 1 (delta) - 84 load_const 9 (null) - 85 cmp_op == - 86 pop_jump_if_false +2 (to 88) - 87 jump +5 (to 92) - 88 load_var 18 (choice) - 89 load_field 1 (delta) - 90 load_field 1 (1) - 91 jump +2 (to 93) - 92 load_const 9 (null) - 93 store_var 19 (_44) - 94 load_var 19 (_44) - 95 narrow_bind 6 19 - 96 pop_jump_if_false +11 (to 107) - 97 load_var 19 (_44) - 98 store_var_load_var 20 (text) - - 1446 99 load_const 15 ("") - 100 cmp_op != - 101 pop_jump_if_false +6 (to 107) - - 1447 102 load_type 0 - 103 load_var2 4 20 - 104 init_instance 0 (ai.stream.TextDelta .text) - 105 call 4 ntypeargs=1 (baml.Array.push) - 106 pop 1 - - 1450 107 load_var 18 (choice) - 108 load_field 1 (delta) - 109 load_const 9 (null) - 110 cmp_op == - 111 pop_jump_if_false +2 (to 113) - 112 jump +5 (to 117) - 113 load_var 18 (choice) - 114 load_field 1 (delta) - 115 load_field 2 (2) - 116 jump +2 (to 118) - 117 load_const 9 (null) - 118 store_var 21 (_56) - 119 load_var 21 (_56) - 120 narrow_bind 6 21 - 121 pop_jump_if_false +11 (to 132) - 122 load_var 21 (_56) - 123 store_var_load_var 22 (refusal) - - 1451 124 load_const 16 ("") - 125 cmp_op != - 126 pop_jump_if_false +6 (to 132) - - 1452 127 load_type 0 - 128 load_var2 4 22 - 129 init_instance 1 (ai.stream.TextDelta .text) - 130 call 4 ntypeargs=1 (baml.Array.push) - 131 pop 1 - - 1455 132 load_var 18 (choice) - 133 load_field 1 (delta) - 134 load_const 9 (null) - 135 cmp_op == - 136 pop_jump_if_false +2 (to 138) - 137 jump +5 (to 142) - 138 load_var 18 (choice) - 139 load_field 1 (delta) - 140 load_field 4 (4) - 141 jump +2 (to 143) - 142 load_const 9 (null) - 143 store_var_load_var 24 (_65) - 144 load_const 9 (null) - 145 cmp_op == - 146 pop_jump_if_false +4 (to 150) - 147 load_type 17 - 148 alloc_array 0 - 149 store_var 24 (_65) - 150 load_var 24 (_65) - 151 store_var 23 (deltas) - - 1456 152 load_const 13 (0) - 153 store_var 25 (position) - - 1457 154 load_var 23 (deltas) - 155 load_type 18 - 156 load_const 19 ("iter") - 157 virtual_call nargs=1 ntypeargs=0 - 158 store_var 26 (_73) - 159 load_var 26 (_73) - 160 load_type 20 - 161 load_const 21 ("next") - 162 virtual_call nargs=1 ntypeargs=0 - 163 store_var 27 (_74) - 164 load_var 27 (_74) - 165 is_type 5 - 166 pop_jump_if_false +2 (to 168) - 167 jump +12 (to 179) - 168 load_var 27 (_74) - 169 store_var 28 (call) - - 1458 170 load_var2 1 28 - 171 load_var 25 (position) - 172 call 1136 ntypeargs=0 (openai.internal.ChatStreamDecoder._absorb_call) - 173 pop 1 - - 1459 174 load_var 25 (position) - 175 load_const 6 (1) - 176 add_int - 177 store_var 25 (position) - - 1457 178 jump -19 (to 159) - - 1461 179 load_var 18 (choice) - 180 load_field 2 (finish_reason) - 181 store_var 29 (_82) - 182 load_var 29 (_82) - 183 narrow_bind 6 29 - 184 pop_jump_if_false +12 (to 196) - 185 load_var 29 (_82) - 186 store_var_load_var 30 (reason) - - 1464 187 call 1128 ntypeargs=0 (openai.internal.chat_stop_reason) - 188 store_var 31 (_86) - - 1462 189 load_type 0 - 190 load_var2 4 31 - - 1463 191 load_const 9 (null) - 192 load_const 9 (null) - 193 init_instance 2 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1462 194 call 4 ntypeargs=1 (baml.Array.push) - 195 pop 1 - - 1471 196 load_var 14 (chunk) - 197 load_field 3 (usage) - 198 store_var 32 (_90) - 199 load_var 32 (_90) - 200 narrow_bind 22 32 - 201 pop_jump_if_false -192 (to 9) - 202 load_var 32 (_90) - 203 store_var 33 (usage) - - 1472 204 load_type 0 - 205 load_var 4 (out) - - 1473 206 load_const 9 (null) - - 1475 207 load_var 33 (usage) - 208 load_field 0 (prompt_tokens) - - 1476 209 load_var 33 (usage) - 210 load_field 1 (completion_tokens) - 211 init_instance 3 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1472 212 call 4 ntypeargs=1 (baml.Array.push) - 213 pop 1 - 214 jump -205 (to 9) - - 1440 215 load_var 1 (self) - 216 load_field 0 (provider) - 217 load_var 9 (data) - 218 init_instance 4 (ai.errors.ParseFailed .provider, .raw_output) - 219 throw - - 1427 220 load_type 0 - 221 load_var 4 (out) - 222 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 223 call 4 ntypeargs=1 (baml.Array.push) - 224 pop 1 - 225 jump -216 (to 9) - - 1484 226 load_var 4 (out) - 227 store_var 3 (_0) - 228 load_var 3 (_0) - 229 return -} - -function openai.internal.ChatStreamDecoder.new(provider: string) -> openai.internal.ChatStreamDecoder { - 1391 0 load_var 1 (provider) - 1 load_type 0 - 2 alloc_array 0 - 3 init_instance 0 (openai.internal.ChatStreamDecoder .provider, .calls) - 4 store_var 2 (_0) - 5 load_var 2 (_0) - 6 return -} - -function openai.internal.ChatStreamDecoder.tool_uses(self: openai.internal.ChatStreamDecoder) -> ai.content.ToolUse[] { - 1489 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 1490 3 load_var 1 (self) - 4 load_field 1 (calls) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +33 (to 50) - 18 load_var 5 (_5) - 19 store_var 6 (buffer) - - 1491 20 load_type 6 - 21 load_type 7 - 22 alloc_map 0 - 23 store_var 7 (empty) - - 1492 24 load_var 6 (buffer) - 25 load_field 3 (arguments) - 26 call 144 ntypeargs=0 (baml.String.trim) - 27 load_const 8 ("") - 28 cmp_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +8 (to 38) - - 1495 31 load_var 6 (buffer) - 32 load_field 3 (arguments) - 33 load_var 1 (self) - 34 load_field 0 (provider) - 35 call 1130 ntypeargs=0 (openai.internal._chat_tool_args) - 36 store_var 8 (args) - 37 jump +3 (to 40) - - 1493 38 load_var 7 (empty) - 39 store_var 8 (args) - - 1497 40 load_type 0 - 41 load_var2 3 6 - 42 load_field 1 (id) - 43 load_var 6 (buffer) - 44 load_field 2 (name) - 45 load_var 8 (args) - 46 init_instance 0 (ai.content.ToolUse .id, .name, .args) - 47 call 4 ntypeargs=1 (baml.Array.push) - 48 pop 1 - 49 jump -40 (to 9) - - 1499 50 load_var 3 (out) - 51 store_var 2 (_0) - 52 load_var 2 (_0) - 53 return -} - -function openai.internal.ChatTool.baml.ToJson.to_json(self: openai.internal.ChatTool) -> baml.json.json { - 340 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 3 (out) - - 341 4 load_type 0 - 5 load_type 1 - 6 load_var 3 (out) - 7 load_const 2 ("type") - 8 load_var 1 (self) - 9 load_field 0 (type) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 342 12 load_type 3 - 13 load_var 1 (self) - 14 load_field 1 (fn) - 15 call 355 ntypeargs=1 (baml.json.to_json) - 16 store_var 4 (_8) - 17 load_type 0 - 18 load_type 1 - 19 load_var 3 (out) - 20 load_const 4 ("function") - 21 load_var 4 (_8) - 22 call 37 ntypeargs=2 (baml.Map.set) - 23 pop 1 - - 343 24 load_var 3 (out) - 25 store_var 2 (_0) - 26 load_var 2 (_0) - 27 return -} - -function openai.internal.ChatToolCall.baml.ToJson.to_json(self: openai.internal.ChatToolCall) -> baml.json.json { - 310 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 3 (out) - - 311 4 load_type 0 - 5 load_type 1 - 6 load_var 3 (out) - 7 load_const 2 ("id") - 8 load_var 1 (self) - 9 load_field 0 (id) - 10 call 37 ntypeargs=2 (baml.Map.set) - 11 pop 1 - - 312 12 load_type 0 - 13 load_type 1 - 14 load_var 3 (out) - 15 load_const 3 ("type") - 16 load_var 1 (self) - 17 load_field 1 (type) - 18 call 37 ntypeargs=2 (baml.Map.set) - 19 pop 1 - - 313 20 load_type 4 - 21 load_var 1 (self) - 22 load_field 2 (fn) - 23 call 355 ntypeargs=1 (baml.json.to_json) - 24 store_var 4 (_12) - 25 load_type 0 - 26 load_type 1 - 27 load_var 3 (out) - 28 load_const 5 ("function") - 29 load_var 4 (_12) - 30 call 37 ntypeargs=2 (baml.Map.set) - 31 pop 1 - - 314 32 load_var 3 (out) - 33 store_var 2 (_0) - 34 load_var 2 (_0) - 35 return -} - -function openai.internal.OaStreamState.new() -> openai.internal.OaStreamState { - 975 0 load_type 0 - 1 load_type 1 - 2 alloc_map 0 - 3 store_var 2 (started) - - 976 4 load_type 0 - 5 load_type 0 - 6 alloc_map 0 - 7 store_var 3 (buffered) - - 977 8 load_const 2 (null) - 9 load_var2 2 3 - 10 init_instance 0 (openai.internal.OaStreamState .model, .text_started, .call_arguments) - 11 store_var 1 (_0) - 12 load_var 1 (_0) - 13 return -} - -function openai.internal._azure_reject(detail: string) -> ai.errors.InvalidRequest { - 49 0 load_const 0 ("azure") - 1 load_var 1 (detail) - 2 call 1097 ntypeargs=0 (openai.internal._reject) - 3 return -} - -function openai.internal._chat_all_text(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[]) -> bool { - 632 0 load_const 0 (true) - 1 store_var 2 (all) - - 633 2 load_var 1 (parts) - 3 load_type 1 - 4 load_const 2 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_3) - 7 load_var 3 (_3) - 8 load_type 3 - 9 load_const 4 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_4) - 12 load_var 4 (_4) - 13 is_type 5 - 14 pop_jump_if_false +2 (to 16) - 15 jump +12 (to 27) - 16 load_var 4 (_4) - 17 store_var 5 (part) - - 634 18 load_var 5 (part) - 19 store_var 6 (_8) - 20 load_var 6 (_8) - 21 narrow_bind 6 6 - 22 pop_jump_if_false +2 (to 24) - 23 jump -16 (to 7) - - 637 24 load_const 7 (false) - 25 store_var 2 (all) - - 634 26 jump -19 (to 7) - - 642 27 load_var 2 (all) - 28 return -} - -function openai.internal._chat_apply_directives(j: baml.json.json) -> baml.json.json { - 835 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +18 (to 23) - 6 load_var 1 (j) - 7 store_var 17 (_47) - 8 load_var 17 (_47) - 9 narrow_bind 1 17 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 855 12 load_var 1 (j) - - 835 13 jump +97 (to 110) - 14 load_var 17 (_47) - 15 store_var 18 (items) - - 854 16 load_type 2 - 17 load_type 2 - 18 load_type 3 - 19 load_var 18 (items) - 20 make_closure 2932 0 - 21 call 16 ntypeargs=3 (baml.Array.map) - 22 jump +88 (to 110) - - 835 23 load_var 2 (_2) - 24 store_var 3 (object) - - 837 25 load_type 4 - 26 load_type 2 - 27 alloc_map 0 - 28 store_var 4 (out) - - 838 29 load_type 4 - 30 load_type 2 - 31 load_var 3 (object) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 5 - 34 load_const 6 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 5 (_8) - 37 load_var 5 (_8) - 38 load_type 7 - 39 load_const 8 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 6 (_9) - 42 load_var 6 (_9) - 43 is_type 9 - 44 pop_jump_if_false +2 (to 46) - 45 jump +21 (to 66) - 46 load_var 6 (_9) - 47 store_var 7 (key) - - 839 48 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 49 store_var 8 (_15) - 50 load_var2 7 8 - 51 cmp_op != - 52 pop_jump_if_false -15 (to 37) - - 840 53 load_type 4 - 54 load_type 2 - 55 load_var2 3 7 - 56 call 38 ntypeargs=2 (baml.Map.get) - 57 call 1118 ntypeargs=0 (openai.internal._chat_apply_directives) - 58 store_var 9 (_18) - 59 load_type 4 - 60 load_type 2 - 61 load_var2 4 7 - 62 load_var 9 (_18) - 63 call 37 ntypeargs=2 (baml.Map.set) - 64 pop 1 - 65 jump -28 (to 37) - - 843 66 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 67 store_var 10 (_26) - 68 load_type 4 - 69 load_type 2 - 70 load_var2 3 10 - 71 call 38 ntypeargs=2 (baml.Map.get) - 72 store_var 11 (_29) - 73 load_var 11 (_29) - 74 narrow_bind 0 11 - 75 pop_jump_if_false +34 (to 109) - 76 load_var 11 (_29) - 77 store_var 12 (directives) - - 845 78 load_type 4 - 79 load_type 2 - 80 load_var 12 (directives) - 81 call 35 ntypeargs=2 (baml.Map.keys) - 82 load_type 5 - 83 load_const 10 ("iter") - 84 virtual_call nargs=1 ntypeargs=0 - 85 store_var 13 (_34) - 86 load_var 13 (_34) - 87 load_type 7 - 88 load_const 11 ("next") - 89 virtual_call nargs=1 ntypeargs=0 - 90 store_var 14 (_35) - 91 load_var 14 (_35) - 92 is_type 9 - 93 pop_jump_if_false +2 (to 95) - 94 jump +15 (to 109) - 95 load_var 14 (_35) - 96 store_var 15 (key) - - 846 97 load_type 4 - 98 load_type 2 - 99 load_var2 12 15 - 100 call 38 ntypeargs=2 (baml.Map.get) - 101 store_var 16 (_41) - 102 load_type 4 - 103 load_type 2 - 104 load_var2 4 15 - 105 load_var 16 (_41) - 106 call 37 ntypeargs=2 (baml.Map.set) - 107 pop 1 - 108 jump -22 (to 86) - - 852 109 load_var 4 (out) - 110 return -} - -function openai.internal._chat_apply_metadata(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], metadata: map) -> void { - 620 0 load_type 0 - 1 load_type 1 - 2 load_var 2 (metadata) - 3 call 35 ntypeargs=2 (baml.Map.keys) - 4 container_len - 5 store_var 3 (_4) - 6 load_var 3 (_4) - 7 load_const 2 (0) - 8 cmp_int_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +36 (to 46) - - 623 11 load_type 3 - 12 load_var 1 (parts) - 13 call 5 ntypeargs=1 (baml.Array.pop) - 14 store_var 4 (_10) - 15 load_var 4 (_10) - 16 narrow_bind 4 4 - 17 pop_jump_if_false +2 (to 19) - 18 jump +19 (to 37) - 19 load_var 4 (_10) - 20 narrow_bind 5 4 - 21 pop_jump_if_false +2 (to 23) - 22 jump +15 (to 37) - 23 load_var 4 (_10) - 24 narrow_bind 6 4 - 25 pop_jump_if_false +2 (to 27) - 26 jump +11 (to 37) - 27 load_var 4 (_10) - 28 narrow_bind 7 4 - 29 pop_jump_if_false +2 (to 31) - 30 jump +7 (to 37) - 31 load_var 4 (_10) - 32 narrow_bind 8 4 - 33 pop_jump_if_false +2 (to 35) - 34 jump +3 (to 37) - 35 load_const 9 (null) - 36 jump +10 (to 46) - 37 load_var 4 (_10) - 38 store_var 5 (last) - - 624 39 load_type 3 - 40 load_var2 1 5 - 41 load_var 2 (metadata) - 42 init_instance 0 (openai.internal.ChatExtraPart .part, .extra) - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - - 623 45 load_const 9 (null) - 46 return -} - -function openai.internal._chat_audio_format(mime_type: string) -> string { - 493 0 load_var 1 (mime_type) - 1 load_const 0 ("audio/") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 496 5 load_var 1 (mime_type) - 6 store_var 2 (subtype) - - 493 7 jump +9 (to 16) - - 494 8 load_var 1 (mime_type) - 9 call 139 ntypeargs=0 (baml.String.length) - 10 store_var 3 (_4) - 11 load_var 1 (mime_type) - 12 load_const 1 (6) - 13 load_var 3 (_4) - 14 call 153 ntypeargs=0 (baml.String.slice) - 15 store_var 2 (subtype) - - 498 16 load_var 2 (subtype) - 17 load_const 2 ("mpeg") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +17 (to 37) - 21 load_var 2 (subtype) - 22 load_const 3 ("mp3") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +10 (to 35) - 26 load_var 2 (subtype) - 27 load_const 4 ("x-wav") - 28 cmp_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +3 (to 33) - - 501 31 load_var 2 (subtype) - - 498 32 jump +6 (to 38) - - 500 33 load_const 5 ("wav") - - 498 34 jump +4 (to 38) - - 499 35 load_const 6 ("mp3") - - 498 36 jump +2 (to 38) - - 499 37 load_const 7 ("mp3") - 38 return -} - -function openai.internal._chat_audio_output_mime(request_body: baml.json.json | null) -> string { - 512 0 load_type 0 - 1 load_var 1 (request_body) - 2 load_const 1 (".audio.format") - 3 load_const 2 ("wav") - 4 call 364 ntypeargs=1 (baml.json.path_or) - 5 store_var 2 (format) - - 513 6 load_var 2 (format) - 7 load_const 3 ("mp3") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +16 (to 26) - 11 load_var 2 (format) - 12 load_const 4 ("pcm16") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +9 (to 24) - - 516 16 load_type 0 - 17 load_var 2 (format) - 18 call 138 ntypeargs=1 (baml.String.from) - 19 store_var 3 (_6) - 20 load_const 5 ("audio/") - 21 load_var 3 (_6) - 22 bin_op + - - 513 23 jump +4 (to 27) - - 515 24 load_const 6 ("audio/pcm") - - 513 25 jump +2 (to 27) - - 514 26 load_const 7 ("audio/mpeg") - 27 return -} - -function openai.internal._chat_body_mentions(overrides: baml.json.json | null, key: string) -> bool { - 894 0 load_var 1 (overrides) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 896 6 load_const 1 (false) - - 894 7 jump +7 (to 14) - 8 load_var 3 (_3) - 9 store_var 4 (object) - - 895 10 load_type 2 - 11 load_type 3 - 12 load_var2 4 2 - 13 call 34 ntypeargs=2 (baml.Map.has) - 14 return -} - -function openai.internal._chat_content(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], collapse: bool) -> string | (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - 647 0 load_var 2 (collapse) - 1 jump_if_false +4 (to 5) - 2 pop 1 - 3 load_var 1 (parts) - 4 call 1113 ntypeargs=0 (openai.internal._chat_all_text) - 5 pop_jump_if_false +2 (to 7) - 6 jump +3 (to 9) - - 660 7 load_var 1 (parts) - 8 jump +40 (to 48) - - 648 9 load_const 0 ("") - 10 store_var 3 (text) - - 649 11 load_var 1 (parts) - 12 load_type 1 - 13 load_const 2 ("iter") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 4 (_5) - 16 load_var 4 (_5) - 17 load_type 3 - 18 load_const 4 ("next") - 19 virtual_call nargs=1 ntypeargs=0 - 20 store_var 5 (_6) - 21 load_var 5 (_6) - 22 is_type 5 - 23 pop_jump_if_false +2 (to 25) - 24 jump +23 (to 47) - 25 load_var 5 (_6) - 26 store_var 6 (part) - - 650 27 load_var 6 (part) - 28 store_var 7 (_10) - 29 load_var 7 (_10) - 30 narrow_bind 6 7 - 31 pop_jump_if_false -15 (to 16) - 32 load_var 7 (_10) - 33 store_var 8 (t) - - 652 34 load_type 7 - 35 load_var 3 (text) - 36 call 138 ntypeargs=1 (baml.String.from) - 37 store_var 9 (_12) - 38 load_type 7 - 39 load_var 8 (t) - 40 load_field 1 (text) - 41 call 138 ntypeargs=1 (baml.String.from) - 42 store_var 10 (_15) - 43 load_var2 9 10 - 44 bin_op + - 45 store_var 3 (text) - - 650 46 jump -30 (to 16) - - 658 47 load_var 3 (text) - 48 return -} - -function openai.internal._chat_directives_key() -> string { - 285 0 load_const 0 ("__baml_directives") - 1 store_var 1 (_0) - 2 load_var 1 (_0) - 3 return -} - -function openai.internal._chat_headers(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> map { - 947 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 4 (headers) - - 948 6 load_var 2 (params) - 7 load_field 8 (headers) - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 narrow_bind 3 5 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 5 (_5) - 13 store_var 6 (user_headers) - - 949 14 load_type 2 - 15 load_type 2 - 16 load_var 6 (user_headers) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 7 (_10) - 22 load_var 7 (_10) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 8 (_11) - 27 load_var 8 (_11) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 8 (_11) - 32 store_var 9 (name) - - 950 33 load_var 9 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 10 (_16) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 6 9 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 11 (_18) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 11 (_18) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 4 10 - 49 load_var 11 (_18) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 953 53 load_var 2 (params) - 54 load_field 1 (api_key) - 55 store_var_load_var 12 (key) - - 954 56 load_const 9 (null) - 57 call 672 ntypeargs=0 (baml.ops.equals_equals) - 58 jump_if_false +4 (to 62) - 59 pop 1 - 60 load_var 1 (compat) - 61 load_field 5 (api_key_required) - 62 pop_jump_if_false +2 (to 64) - 63 jump +48 (to 111) - - 960 64 load_var 12 (key) - 65 store_var 17 (_43) - 66 load_var 17 (_43) - 67 narrow_bind 11 17 - 68 pop_jump_if_false +39 (to 107) - 69 load_var 17 (_43) - 70 store_var 18 (credential) - - 961 71 load_var 1 (compat) - 72 load_field 3 (auth) - 73 discriminant - 74 load_const 12 (ChatAuth.Bearer) - 75 cmp_int_op == - 76 pop_jump_if_false +2 (to 78) - 77 jump +17 (to 94) - 78 load_var 1 (compat) - 79 load_field 3 (auth) - 80 discriminant - 81 load_const 11 (ChatAuth.ApiKeyHeader) - 82 cmp_int_op == - 83 pop_jump_if_false +2 (to 85) - 84 jump +2 (to 86) - 85 jump +22 (to 107) - - 967 86 load_type 2 - 87 load_type 2 - 88 load_var 4 (headers) - 89 load_const 13 ("api-key") - 90 load_var 18 (credential) - 91 call 37 ntypeargs=2 (baml.Map.set) - 92 pop 1 - 93 jump +14 (to 107) - - 963 94 load_type 2 - 95 load_var 18 (credential) - 96 call 138 ntypeargs=1 (baml.String.from) - 97 store_var 19 (_49) - 98 load_type 2 - 99 load_type 2 - 100 load_var 4 (headers) - 101 load_const 14 ("authorization") - 102 load_const 15 ("Bearer ") - 103 load_var 19 (_49) - 104 bin_op + - 105 call 37 ntypeargs=2 (baml.Map.set) - 106 pop 1 - - 973 107 load_var 4 (headers) - 108 store_var 3 (_0) - 109 load_var 3 (_0) - 110 return - - 956 111 load_var 1 (compat) - 112 load_field 0 (provider) - 113 store_var 13 (_31) - - 957 114 load_type 2 - 115 load_var 1 (compat) - 116 load_field 0 (provider) - 117 call 138 ntypeargs=1 (baml.String.from) - 118 store_var 14 (_34) - 119 load_var 1 (compat) - 120 load_field 4 (api_key_env) - 121 store_var_load_var 16 (_39) - 122 load_const 9 (null) - 123 cmp_op == - 124 pop_jump_if_false +3 (to 127) - 125 load_const 16 ("the provider's environment variable") - 126 store_var 16 (_39) - 127 load_type 2 - 128 load_var 16 (_39) - 129 call 138 ntypeargs=1 (baml.String.from) - 130 store_var 15 (_37) - - 955 131 load_var2 13 14 - - 957 132 load_const 17 (" needs an API key: pass api_key, or set ") - 133 bin_op + - 134 load_var 15 (_37) - 135 bin_op + - - 955 136 call 1097 ntypeargs=0 (openai.internal._reject) - 137 throw -} - -function openai.internal._chat_is_opaque_key(key: string) -> bool { - 827 0 load_var 1 (key) - 1 load_const 0 ("parameters") - 2 cmp_op == - 3 jump_if_false +2 (to 5) - 4 jump +6 (to 10) - 5 pop 1 - 6 call 1103 ntypeargs=0 (openai.internal._chat_directives_key) - 7 store_var 2 (_3) - 8 load_var2 1 2 - 9 cmp_op == - 10 return -} - -function openai.internal._chat_media_block(url: string) -> ai.content.Media { - 1116 0 load_var 1 (url) - 1 load_const 0 ("data:") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +9 (to 12) - - 1117 4 load_var 1 (url) - 5 load_const 1 (";base64,") - 6 call 155 ntypeargs=0 (baml.String.index_of) - 7 store_var 2 (_4) - 8 load_var 2 (_4) - 9 narrow_bind 2 2 - 10 pop_jump_if_false +2 (to 12) - 11 jump +8 (to 19) - - 1126 12 load_var 1 (url) - 13 load_const 3 (null) - 14 call 347 ntypeargs=0 (baml.media.Image.from_url) - 15 load_const 4 () - 16 load_const 4 () - 17 call 904 ntypeargs=0 (ai.content.Media.new) - 18 jump +23 (to 41) - - 1117 19 load_var 2 (_4) - 20 store_var_load_var 3 (separator) - - 1120 21 load_const 5 (8) - 22 add_int - 23 store_var 5 (_8) - 24 load_var 1 (url) - 25 call 139 ntypeargs=0 (baml.String.length) - 26 store_var 6 (_10) - 27 load_var2 1 5 - 28 load_var 6 (_10) - 29 call 153 ntypeargs=0 (baml.String.slice) - 30 store_var 4 (_7) - - 1121 31 load_var 1 (url) - 32 load_const 6 (5) - 33 load_var 3 (separator) - 34 call 153 ntypeargs=0 (baml.String.slice) - 35 store_var 7 (_11) - - 1119 36 load_var2 4 7 - 37 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 1118 38 load_const 4 () - 39 load_const 4 () - 40 call 904 ntypeargs=0 (ai.content.Media.new) - 41 return -} - -function openai.internal._chat_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, compat: openai.internal.ChatCompat) -> openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart { - 524 0 load_var 1 (media) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +114 (to 119) - 6 load_var 1 (media) - 7 store_var 6 (_11) - 8 load_var 6 (_11) - 9 narrow_bind 1 6 - 10 pop_jump_if_false +2 (to 12) - 11 jump +84 (to 95) - 12 load_var 1 (media) - 13 store_var 12 (_22) - 14 load_var 12 (_22) - 15 narrow_bind 2 12 - 16 pop_jump_if_false +2 (to 18) - 17 jump +6 (to 23) - - 577 18 load_var 2 (compat) - 19 load_field 0 (provider) - 20 load_const 3 ("OpenAI Chat Completions has no video input part; extract frames as images, or use the Realtime API") - - 576 21 call 1097 ntypeargs=0 (openai.internal._reject) - 22 throw - - 524 23 load_var 12 (_22) - 24 store_var_load_var 13 (pdf) - - 552 25 load_const 4 (true) - 26 call 933 ntypeargs=0 (ai.wire.resolve_media) - 27 store_var 14 (resolved) - - 556 28 load_var 14 (resolved) - 29 load_field 1 (base64) - 30 store_var 16 (_28) - 31 load_var 16 (_28) - 32 narrow_bind 5 16 - 33 pop_jump_if_false +2 (to 35) - 34 jump +24 (to 58) - - 559 35 load_var 2 (compat) - 36 load_field 0 (provider) - 37 store_var 18 (_31) - - 560 38 load_var 14 (resolved) - 39 load_field 0 (url) - 40 store_var_load_var 20 (_36) - 41 load_const 6 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 7 ("this document") - 45 store_var 20 (_36) - 46 load_type 8 - 47 load_var 20 (_36) - 48 call 138 ntypeargs=1 (baml.String.from) - 49 store_var 19 (_34) - - 558 50 load_var 18 (_31) - - 560 51 load_const 9 ("OpenAI Chat Completions has no document-by-URL content part, so a PDF must be inlined, and ") - 52 load_var 19 (_34) - 53 bin_op + - 54 load_const 10 (" is not a URL this client can fetch (gs:// and other non-HTTP schemes are not supported here). Pass the PDF as base64 or a local file.") - 55 bin_op + - - 558 56 call 1097 ntypeargs=0 (openai.internal._reject) - 57 throw - - 556 58 load_var 16 (_28) - 59 store_var 17 (inline) - - 557 60 load_var 17 (inline) - 61 store_var 15 (data) - - 570 62 load_var 13 (pdf) - 63 call 323 ntypeargs=0 (baml.media.Pdf.file) - 64 store_var_load_var 22 (_43) - 65 load_const 6 (null) - 66 cmp_op == - 67 pop_jump_if_false +4 (to 71) - 68 load_var 13 (pdf) - 69 call 322 ntypeargs=0 (baml.media.Pdf.url) - 70 store_var 22 (_43) - 71 load_var 22 (_43) - 72 call 1020 ntypeargs=0 (openai.internal._openai_file_name) - 73 store_var 21 (_41) - - 571 74 load_type 8 - 75 load_var 14 (resolved) - 76 load_field 2 (mime_type) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 23 (_49) - 79 load_type 8 - 80 load_var 15 (data) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 24 (_52) - - 563 83 load_const 11 ("file") - - 565 84 load_var 21 (_41) - - 571 85 load_const 12 ("data:") - 86 load_var 23 (_49) - 87 bin_op + - 88 load_const 13 (";base64,") - 89 bin_op + - 90 load_var 24 (_52) - 91 bin_op + - 92 init_instance 0 (openai.internal.ChatFileData .filename, .file_data) - 93 init_instance 1 (openai.internal.ChatFilePart .type, .file) - - 524 94 jump +36 (to 130) - 95 load_var 6 (_11) - 96 store_var_load_var 7 (audio) - - 535 97 load_const 4 (true) - 98 call 933 ntypeargs=0 (ai.wire.resolve_media) - 99 store_var 8 (resolved) - - 539 100 load_var 8 (resolved) - 101 load_field 1 (base64) - 102 store_var_load_var 10 (_17) - 103 load_const 6 (null) - 104 cmp_op == - 105 pop_jump_if_false +3 (to 108) - 106 load_const 14 ("") - 107 store_var 10 (_17) - 108 load_var 10 (_17) - 109 store_var 9 (_16) - - 540 110 load_var 8 (resolved) - 111 load_field 2 (mime_type) - 112 call 1108 ntypeargs=0 (openai.internal._chat_audio_format) - 113 store_var 11 (_20) - - 536 114 load_const 15 ("input_audio") - - 538 115 load_var2 9 11 - 116 init_instance 2 (openai.internal.ChatInputAudio .data, .format) - 117 init_instance 3 (openai.internal.ChatAudioPart .type, .input_audio) - - 524 118 jump +12 (to 130) - 119 load_var 3 (_3) - 120 store_var_load_var 4 (image) - - 526 121 load_var 2 (compat) - 122 load_field 7 (inline_image_urls) - 123 call 933 ntypeargs=0 (ai.wire.resolve_media) - - 529 124 call 1107 ntypeargs=0 (openai.internal._chat_media_url) - 125 store_var 5 (_9) - - 527 126 load_const 16 ("image_url") - - 529 127 load_var 5 (_9) - 128 init_instance 4 (openai.internal.ChatImageUrl .url) - 129 init_instance 5 (openai.internal.ChatImagePart .type, .image_url) - 130 return -} - -function openai.internal._chat_media_url(resolved: ai.wire.ResolvedMedia) -> string { - 482 0 load_var 1 (resolved) - 1 load_field 0 (url) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +26 (to 32) - - 485 7 load_type 1 - 8 load_var 1 (resolved) - 9 load_field 2 (mime_type) - 10 call 138 ntypeargs=1 (baml.String.from) - 11 store_var 4 (_7) - 12 load_var 1 (resolved) - 13 load_field 1 (base64) - 14 store_var_load_var 6 (_12) - 15 load_const 2 (null) - 16 cmp_op == - 17 pop_jump_if_false +3 (to 20) - 18 load_const 3 ("") - 19 store_var 6 (_12) - 20 load_type 1 - 21 load_var 6 (_12) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 5 (_10) - 24 load_const 4 ("data:") - 25 load_var 4 (_7) - 26 bin_op + - 27 load_const 5 (";base64,") - 28 bin_op + - 29 load_var 5 (_10) - 30 bin_op + - 31 jump +4 (to 35) - - 482 32 load_var 2 (_3) - 33 store_var 3 (url) - - 483 34 load_var 3 (url) - 35 return -} - -function openai.internal._chat_percent_encode(value: string) -> string { - 905 0 load_const 0 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~") - 1 store_var 2 (unreserved) - - 906 2 load_const 1 ("") - 3 store_var 3 (out) - - 907 4 load_var 1 (value) - 5 call 151 ntypeargs=0 (baml.String.chars) - 6 load_type 2 - 7 load_const 3 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_5) - 10 load_var 4 (_5) - 11 load_type 4 - 12 load_const 5 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_6) - 15 load_var 5 (_6) - 16 is_type 6 - 17 pop_jump_if_false +2 (to 19) - 18 jump +59 (to 77) - 19 load_var 5 (_6) - 20 store_var 6 (character) - - 908 21 load_var2 2 6 - 22 call 147 ntypeargs=0 (baml.String.includes) - 23 pop_jump_if_false +2 (to 25) - 24 jump +41 (to 65) - - 911 25 load_var 6 (character) - 26 call 179 ntypeargs=0 (baml.String.to_utf8) - 27 call 196 ntypeargs=0 (baml.Uint8Array.to_hex) - 28 call 143 ntypeargs=0 (baml.String.to_upper_case) - 29 store_var 9 (hex) - - 912 30 load_const 7 (0) - 31 store_var 10 (i) - - 913 32 load_var 10 (i) - 33 store_var 11 (_23) - 34 load_var 9 (hex) - 35 call 139 ntypeargs=0 (baml.String.length) - 36 store_var 12 (_24) - 37 load_var2 11 12 - 38 cmp_int_op < - 39 pop_jump_if_false -29 (to 10) - - 914 40 load_type 8 - 41 load_var 3 (out) - 42 call 138 ntypeargs=1 (baml.String.from) - 43 store_var 13 (_26) - 44 load_var2 9 10 - 45 load_var 10 (i) - 46 load_const 9 (2) - 47 add_int - 48 call 153 ntypeargs=0 (baml.String.slice) - 49 store_var 15 (_30) - 50 load_type 8 - 51 load_var 15 (_30) - 52 call 138 ntypeargs=1 (baml.String.from) - 53 store_var 14 (_29) - 54 load_var 13 (_26) - 55 load_const 10 ("%") - 56 bin_op + - 57 load_var 14 (_29) - 58 bin_op + - 59 store_var 3 (out) - - 915 60 load_var 10 (i) - 61 load_const 9 (2) - 62 add_int - 63 store_var 10 (i) - - 913 64 jump -32 (to 32) - - 909 65 load_type 8 - 66 load_var 3 (out) - 67 call 138 ntypeargs=1 (baml.String.from) - 68 store_var 7 (_12) - 69 load_type 8 - 70 load_var 6 (character) - 71 call 138 ntypeargs=1 (baml.String.from) - 72 store_var 8 (_15) - 73 load_var2 7 8 - 74 bin_op + - 75 store_var 3 (out) - - 908 76 jump -66 (to 10) - - 919 77 load_var 3 (out) - 78 return -} - -function openai.internal._chat_prompt_parts(message: ai.PromptMessage, compat: openai.internal.ChatCompat) -> (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - 585 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (parts) - - 586 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +77 (to 94) - 18 load_var 6 (_6) - 19 store_var 7 (part) - - 587 20 load_var 7 (part) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +59 (to 84) - 26 load_var 7 (part) - 27 store_var 10 (_16) - 28 load_var 10 (_16) - 29 narrow_bind 7 10 - 30 pop_jump_if_false +2 (to 32) - 31 jump +43 (to 74) - 32 load_var 7 (part) - 33 store_var 13 (_22) - 34 load_var 13 (_22) - 35 narrow_bind 8 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +27 (to 64) - 38 load_var 7 (part) - 39 store_var 16 (_28) - 40 load_var 16 (_28) - 41 narrow_bind 9 16 - 42 pop_jump_if_false +2 (to 44) - 43 jump +11 (to 54) - 44 load_var 7 (part) - 45 store_var_load_var 19 (video) - - 605 46 load_var 2 (compat) - 47 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 48 store_var 20 (_36) - 49 load_type 0 - 50 load_var2 4 20 - 51 call 4 ntypeargs=1 (baml.Array.push) - 52 pop 1 - 53 jump -44 (to 9) - - 587 54 load_var 16 (_28) - 55 store_var_load_var 17 (pdf) - - 601 56 load_var 2 (compat) - 57 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 58 store_var 18 (_31) - 59 load_type 0 - 60 load_var2 4 18 - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -54 (to 9) - - 587 64 load_var 13 (_22) - 65 store_var_load_var 14 (audio) - - 597 66 load_var 2 (compat) - 67 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 68 store_var 15 (_25) - 69 load_type 0 - 70 load_var2 4 15 - 71 call 4 ntypeargs=1 (baml.Array.push) - 72 pop 1 - 73 jump -64 (to 9) - - 587 74 load_var 10 (_16) - 75 store_var_load_var 11 (image) - - 593 76 load_var 2 (compat) - 77 call 1110 ntypeargs=0 (openai.internal._chat_media_part) - 78 store_var 12 (_19) - 79 load_type 0 - 80 load_var2 4 12 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -74 (to 9) - - 587 84 load_var 8 (_10) - 85 store_var 9 (text) - - 589 86 load_type 0 - 87 load_var 4 (parts) - 88 load_const 10 ("text") - 89 load_var 9 (text) - 90 init_instance 0 (openai.internal.ChatTextPart .type, .text) - 91 call 4 ntypeargs=1 (baml.Array.push) - 92 pop 1 - 93 jump -84 (to 9) - - 610 94 load_var 4 (parts) - 95 store_var 3 (_0) - 96 load_var 3 (_0) - 97 return -} - -function openai.internal._chat_prune_nulls(j: baml.json.json) -> baml.json.json { - 865 0 load_var 1 (j) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +18 (to 23) - 6 load_var 1 (j) - 7 store_var 10 (_31) - 8 load_var 10 (_31) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 886 12 load_var 1 (j) - - 865 13 jump +67 (to 80) - 14 load_var 10 (_31) - 15 store_var 11 (items) - - 885 16 load_type 2 - 17 load_type 2 - 18 load_type 3 - 19 load_var 11 (items) - 20 make_closure 2938 0 - 21 call 16 ntypeargs=3 (baml.Array.map) - 22 jump +58 (to 80) - - 865 23 load_var 2 (_2) - 24 store_var 3 (object) - - 867 25 load_type 4 - 26 load_type 2 - 27 alloc_map 0 - 28 store_var 4 (out) - - 868 29 load_type 4 - 30 load_type 2 - 31 load_var 3 (object) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 5 - 34 load_const 6 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 5 (_8) - 37 load_var 5 (_8) - 38 load_type 7 - 39 load_const 8 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 6 (_9) - 42 load_var 6 (_9) - 43 is_type 9 - 44 pop_jump_if_false +2 (to 46) - 45 jump +34 (to 79) - 46 load_var 6 (_9) - 47 store_var 7 (key) - - 869 48 load_type 4 - 49 load_type 2 - 50 load_var2 3 7 - 51 call 38 ntypeargs=2 (baml.Map.get) - 52 store_var 8 (value) - - 870 53 load_var 8 (value) - 54 load_const 10 (null) - 55 cmp_op == - 56 pop_jump_if_false +2 (to 58) - 57 jump -20 (to 37) - - 873 58 load_var 7 (key) - 59 call 1117 ntypeargs=0 (openai.internal._chat_is_opaque_key) - 60 pop_jump_if_false +2 (to 62) - 61 jump +11 (to 72) - - 877 62 load_var 8 (value) - 63 call 1119 ntypeargs=0 (openai.internal._chat_prune_nulls) - 64 store_var 9 (_27) - 65 load_type 4 - 66 load_type 2 - 67 load_var2 4 7 - 68 load_var 9 (_27) - 69 call 37 ntypeargs=2 (baml.Map.set) - 70 pop 1 - 71 jump -34 (to 37) - - 874 72 load_type 4 - 73 load_type 2 - 74 load_var2 4 7 - 75 load_var 8 (value) - 76 call 37 ntypeargs=2 (baml.Map.set) - 77 pop 1 - 78 jump -41 (to 37) - - 883 79 load_var 4 (out) - 80 return -} - -function openai.internal._chat_push_tool_uses(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], calls: openai.internal.CcToolCall[], provider: string) -> void { - 1148 0 load_var 2 (calls) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 5 (_4) - 5 load_var 5 (_4) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 6 (_5) - 10 load_var 6 (_5) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +74 (to 87) - 14 load_var 6 (_5) - 15 store_var 7 (call) - - 1149 16 load_type 5 - 17 load_type 6 - 18 alloc_map 0 - 19 store_var 8 (empty) - - 1150 20 load_var 7 (call) - 21 load_field 3 (fn) - 22 load_const 7 (null) - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +5 (to 30) - 26 load_var 7 (call) - 27 load_field 3 (fn) - 28 load_field 1 (1) - 29 jump +2 (to 31) - 30 load_const 7 (null) - 31 store_var 10 (_15) - 32 load_var 10 (_15) - 33 narrow_bind 8 10 - 34 pop_jump_if_false +2 (to 36) - 35 jump +4 (to 39) - - 1158 36 load_var 8 (empty) - 37 store_var 9 (args) - - 1150 38 jump +15 (to 53) - 39 load_var 10 (_15) - 40 store_var 11 (raw) - - 1152 41 load_var 11 (raw) - 42 call 144 ntypeargs=0 (baml.String.trim) - 43 load_const 9 ("") - 44 cmp_op == - 45 pop_jump_if_false +2 (to 47) - 46 jump +5 (to 51) - - 1155 47 load_var2 11 3 - 48 call 1130 ntypeargs=0 (openai.internal._chat_tool_args) - 49 store_var 9 (args) - 50 jump +3 (to 53) - - 1153 51 load_var 8 (empty) - 52 store_var 9 (args) - - 1161 53 load_var 7 (call) - 54 load_field 0 (id) - 55 store_var_load_var 13 (_23) - 56 load_const 7 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 10 ("") - 60 store_var 13 (_23) - 61 load_var 13 (_23) - 62 store_var 12 (_22) - 63 load_var 7 (call) - 64 load_field 3 (fn) - 65 load_const 7 (null) - 66 cmp_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +5 (to 73) - 69 load_var 7 (call) - 70 load_field 3 (fn) - 71 load_field 0 (0) - 72 jump +2 (to 74) - 73 load_const 7 (null) - 74 store_var_load_var 14 (_27) - 75 load_const 7 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 11 ("") - 79 store_var 14 (_27) - - 1160 80 load_type 12 - 81 load_var2 1 12 - - 1161 82 load_var2 14 9 - 83 init_instance 0 (ai.content.ToolUse .id, .name, .args) - - 1160 84 call 4 ntypeargs=1 (baml.Array.push) - 85 pop 1 - 86 jump -81 (to 5) - - 1147 87 load_const 7 (null) - 88 store_var 4 (_0) - 89 load_var 4 (_0) - 90 return -} - -function openai.internal._chat_send(request: baml.http.Request, provider: string, audio_mime: string) -> ai.ModelTurn { - 0 load_var 3 (audio_mime) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 1285 4 load_const 1 ("audio/wav") - 5 store_var 3 (audio_mime) - - 1287 6 load_var 1 (request) - 7 load_const 0 () - 8 call 250 ntypeargs=0 (baml.http.send) - 9 store_var 4 (response) - 10 jump +18 (to 28) - 11 load_var 5 (e) - 12 throw_if_panic - - 1291 13 load_type 2 - 14 load_var 5 (e) - 15 call 138 ntypeargs=1 (baml.String.from) - 16 store_var 7 (_10) - 17 load_type 3 - 18 load_var 7 (_10) - 19 call 138 ntypeargs=1 (baml.String.from) - 20 store_var 6 (_9) - - 1289 21 load_var 2 (provider) - - 1291 22 load_const 4 ("transport failed before a response arrived: ") - 23 load_var 6 (_9) - 24 bin_op + - 25 load_const 5 (null) - 26 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 27 throw - - 1296 28 load_var 4 (response) - 29 sys_op 238 (baml.http.Response.text) - 30 store_var 8 (text) - 31 jump +8 (to 39) - 32 load_var 9 (e) - 33 throw_if_panic - - 1298 34 load_var 2 (provider) - 35 load_const 6 ("the response body could not be read completely") - 36 load_const 5 (null) - 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 38 throw - - 1305 39 load_var 4 (response) - 40 call 240 ntypeargs=0 (baml.http.Response.ok) - 41 unary_op ! - 42 pop_jump_if_false +2 (to 44) - 43 jump +17 (to 60) - - 1316 44 load_var 8 (text) - 45 call 350 ntypeargs=0 (baml.json.parse) - 46 store_var 11 (_24) - 47 load_type 7 - 48 load_var 11 (_24) - 49 call 359 ntypeargs=1 (baml.json.to) - 50 jump +6 (to 56) - 51 load_var 10 (e) - 52 throw_if_panic - - 1317 53 load_var2 2 8 - 54 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 55 throw - - 1319 56 load_var2 2 8 - 57 load_var 3 (audio_mime) - 58 call 1132 ntypeargs=0 (openai.internal.chat_parse) - 59 return - - 1309 60 load_var2 2 4 - - 1311 61 load_field 0 (status_code) - - 1312 62 load_var2 8 4 - - 1313 63 load_field 1 (headers) - - 1309 64 call 977 ntypeargs=0 (ai.errors.classify_http) - 65 throw -} - -function openai.internal._chat_stream_failure(provider: string, detail: string) -> ai.errors.Failure { - 1509 0 load_const 0 ("SSE request failed with status ") - 1 store_var 3 (marker) - - 1510 2 load_var2 2 3 - 3 call 155 ntypeargs=0 (baml.String.index_of) - 4 store_var 4 (_6) - 5 load_var 4 (_6) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +42 (to 49) - 8 load_var 4 (_6) - 9 store_var 5 (start) - - 1511 10 load_var 5 (start) - 11 store_var 8 (_10) - 12 load_var 3 (marker) - 13 call 139 ntypeargs=0 (baml.String.length) - 14 load_var 8 (_10) - 15 add_int - 16 store_var 7 (_9) - 17 load_var 2 (detail) - 18 call 139 ntypeargs=0 (baml.String.length) - 19 store_var 9 (_12) - 20 load_var2 2 7 - 21 load_var 9 (_12) - 22 call 153 ntypeargs=0 (baml.String.slice) - 23 store_var 6 (rest) - - 1512 24 load_var 6 (rest) - 25 load_const 2 (":") - 26 call 155 ntypeargs=0 (baml.String.index_of) - 27 store_var 10 (_14) - 28 load_var 10 (_14) - 29 narrow_bind 1 10 - 30 pop_jump_if_false +19 (to 49) - 31 load_var 10 (_14) - 32 store_var 11 (colon) - - 1513 33 load_var 6 (rest) - 34 load_const 1 (0) - 35 load_var 11 (colon) - 36 call 153 ntypeargs=0 (baml.String.slice) - 37 call 81 ntypeargs=0 (baml.Int.parse) - 38 store_var 12 (code) - 39 jump +5 (to 44) - 40 load_var 13 (e) - 41 throw_if_panic - - 1514 42 load_const 1 (0) - 43 store_var 12 (code) - - 1516 44 load_var 12 (code) - 45 load_const 1 (0) - 46 cmp_int_op > - 47 pop_jump_if_false +2 (to 49) - 48 jump +12 (to 60) - - 1527 49 load_type 3 - 50 load_var 2 (detail) - 51 call 138 ntypeargs=1 (baml.String.from) - 52 store_var 18 (_29) - - 1525 53 load_var 1 (provider) - - 1527 54 load_const 4 ("transport failed before a response arrived: ") - 55 load_var 18 (_29) - 56 bin_op + - 57 load_const 5 (null) - 58 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 59 jump +19 (to 78) - - 1519 60 load_var 12 (code) - 61 store_var 14 (_22) - - 1520 62 load_var 11 (colon) - 63 load_const 6 (1) - 64 add_int - 65 store_var 16 (_25) - 66 load_var 6 (rest) - 67 call 139 ntypeargs=0 (baml.String.length) - 68 store_var 17 (_27) - 69 load_var2 6 16 - 70 load_var 17 (_27) - 71 call 153 ntypeargs=0 (baml.String.slice) - 72 call 144 ntypeargs=0 (baml.String.trim) - 73 store_var 15 (_23) - - 1517 74 load_var2 1 14 - 75 load_var 15 (_23) - 76 load_const 7 () - 77 call 977 ntypeargs=0 (ai.errors.classify_http) - 78 return -} - -function openai.internal._chat_tool_args(raw: string, provider: string) -> map { - 1138 0 load_type 0 - 1 load_var 1 (raw) - 2 call 357 ntypeargs=1 (baml.json.from_string) - 3 jump +6 (to 9) - 4 load_var 3 (e) - 5 throw_if_panic - - 1139 6 load_var2 2 1 - 7 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 8 throw - 9 return -} - -function openai.internal._chat_tools(toolbox: ai.tools.Toolbox) -> openai.internal.ChatTool[] | null { - 978 0 load_var 1 (toolbox) - 1 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 2 pop_jump_if_false +2 (to 4) - 3 jump +44 (to 47) - - 981 4 load_type 0 - 5 alloc_array 0 - 6 store_var 2 (tools) - - 982 7 load_var 1 (toolbox) - 8 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 3 (_5) - 13 load_var 3 (_5) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 4 (_6) - 18 load_var 4 (_6) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +24 (to 45) - 22 load_var 4 (_6) - 23 store_var 5 (tool) - - 987 24 load_var 5 (tool) - 25 load_field 0 (name) - 26 store_var 6 (_13) - - 988 27 load_var 5 (tool) - 28 load_field 1 (description) - 29 store_var 7 (_14) - - 989 30 load_type 6 - 31 load_var 5 (tool) - 32 load_field 2 (input_schema) - 33 call 355 ntypeargs=1 (baml.json.to_json) - 34 store_var 8 (_15) - - 983 35 load_type 0 - 36 load_var 2 (tools) - - 984 37 load_const 7 ("function") - - 986 38 load_var2 6 7 - 39 load_var 8 (_15) - 40 init_instance 0 (openai.internal.ChatToolFunction .name, .description, .parameters) - 41 init_instance 1 (openai.internal.ChatTool .type, .fn) - - 983 42 call 4 ntypeargs=1 (baml.Array.push) - 43 pop 1 - 44 jump -31 (to 13) - - 994 45 load_var 2 (tools) - 46 jump +2 (to 48) - - 979 47 load_const 8 (null) - 48 return -} - -function openai.internal._chat_url(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - 924 0 load_type 0 - 1 load_type 0 - 2 alloc_map 0 - 3 store_var 3 (query) - - 925 4 load_type 0 - 5 load_type 0 - 6 load_var 1 (compat) - 7 load_field 12 (compat_query) - 8 call 35 ntypeargs=2 (baml.Map.keys) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 4 (_8) - 13 load_var 4 (_8) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 5 (_9) - 18 load_var 5 (_9) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +22 (to 43) - 22 load_var 5 (_9) - 23 store_var 6 (key) - - 926 24 load_type 0 - 25 load_type 0 - 26 load_var 1 (compat) - 27 load_field 12 (compat_query) - 28 load_var 6 (key) - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var_load_var 7 (_16) - 31 load_const 6 (null) - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - 34 load_const 7 ("") - 35 store_var 7 (_16) - 36 load_type 0 - 37 load_type 0 - 38 load_var2 3 6 - 39 load_var 7 (_16) - 40 call 37 ntypeargs=2 (baml.Map.set) - 41 pop 1 - 42 jump -29 (to 13) - - 928 43 load_var 2 (params) - 44 load_field 9 (query_params) - 45 store_var 8 (_26) - 46 load_var 8 (_26) - 47 narrow_bind 8 8 - 48 pop_jump_if_false +39 (to 87) - 49 load_var 8 (_26) - 50 store_var 9 (user_query) - - 929 51 load_type 0 - 52 load_type 0 - 53 load_var 9 (user_query) - 54 call 35 ntypeargs=2 (baml.Map.keys) - 55 load_type 1 - 56 load_const 9 ("iter") - 57 virtual_call nargs=1 ntypeargs=0 - 58 store_var 10 (_31) - 59 load_var 10 (_31) - 60 load_type 3 - 61 load_const 10 ("next") - 62 virtual_call nargs=1 ntypeargs=0 - 63 store_var 11 (_32) - 64 load_var 11 (_32) - 65 is_type 5 - 66 pop_jump_if_false +2 (to 68) - 67 jump +20 (to 87) - 68 load_var 11 (_32) - 69 store_var 12 (key) - - 930 70 load_type 0 - 71 load_type 0 - 72 load_var2 9 12 - 73 call 38 ntypeargs=2 (baml.Map.get) - 74 store_var_load_var 13 (_39) - 75 load_const 6 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 11 ("") - 79 store_var 13 (_39) - 80 load_type 0 - 81 load_type 0 - 82 load_var2 3 12 - 83 load_var 13 (_39) - 84 call 37 ntypeargs=2 (baml.Map.set) - 85 pop 1 - 86 jump -27 (to 59) - - 933 87 load_type 0 - 88 load_var 1 (compat) - 89 load_field 1 (base_url) - 90 call 138 ntypeargs=1 (baml.String.from) - 91 store_var 15 (_48) - 92 load_type 0 - 93 load_var 1 (compat) - 94 load_field 2 (path) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 16 (_51) - 97 load_var2 15 16 - 98 bin_op + - 99 store_var 14 (url) - - 934 100 load_type 0 - 101 load_type 0 - 102 load_var 3 (query) - 103 call 35 ntypeargs=2 (baml.Map.keys) - 104 container_len - 105 store_var 17 (_55) - 106 load_var 17 (_55) - 107 load_const 12 (0) - 108 cmp_int_op == - 109 pop_jump_if_false +2 (to 111) - 110 jump +74 (to 184) - - 937 111 load_type 0 - 112 alloc_array 0 - 113 store_var 18 (pairs) - - 938 114 load_type 0 - 115 load_type 0 - 116 load_var 3 (query) - 117 call 35 ntypeargs=2 (baml.Map.keys) - 118 load_type 1 - 119 load_const 13 ("iter") - 120 virtual_call nargs=1 ntypeargs=0 - 121 store_var 19 (_63) - 122 load_var 19 (_63) - 123 load_type 3 - 124 load_const 14 ("next") - 125 virtual_call nargs=1 ntypeargs=0 - 126 store_var 20 (_64) - 127 load_var 20 (_64) - 128 is_type 5 - 129 pop_jump_if_false +2 (to 131) - 130 jump +35 (to 165) - 131 load_var 20 (_64) - 132 store_var_load_var 21 (key) - - 939 133 call 1121 ntypeargs=0 (openai.internal._chat_percent_encode) - 134 store_var 23 (_72) - 135 load_type 0 - 136 load_var 23 (_72) - 137 call 138 ntypeargs=1 (baml.String.from) - 138 store_var 22 (_71) - 139 load_type 0 - 140 load_type 0 - 141 load_var2 3 21 - 142 call 38 ntypeargs=2 (baml.Map.get) - 143 store_var_load_var 26 (_78) - 144 load_const 6 (null) - 145 cmp_op == - 146 pop_jump_if_false +3 (to 149) - 147 load_const 15 ("") - 148 store_var 26 (_78) - 149 load_var 26 (_78) - 150 call 1121 ntypeargs=0 (openai.internal._chat_percent_encode) - 151 store_var 25 (_76) - 152 load_type 0 - 153 load_var 25 (_76) - 154 call 138 ntypeargs=1 (baml.String.from) - 155 store_var 24 (_75) - 156 load_type 0 - 157 load_var2 18 22 - 158 load_const 16 ("=") - 159 bin_op + - 160 load_var 24 (_75) - 161 bin_op + - 162 call 4 ntypeargs=1 (baml.Array.push) - 163 pop 1 - 164 jump -42 (to 122) - - 941 165 load_type 0 - 166 load_var 14 (url) - 167 call 138 ntypeargs=1 (baml.String.from) - 168 store_var 27 (_87) - 169 load_type 0 - 170 load_var 18 (pairs) - 171 load_const 17 ("&") - 172 call 15 ntypeargs=1 (baml.Array.join) - 173 store_var 29 (_91) - 174 load_type 0 - 175 load_var 29 (_91) - 176 call 138 ntypeargs=1 (baml.String.from) - 177 store_var 28 (_90) - 178 load_var 27 (_87) - 179 load_const 18 ("?") - 180 bin_op + - 181 load_var 28 (_90) - 182 bin_op + - 183 jump +2 (to 185) - - 935 184 load_var 14 (url) - 185 return -} - -function openai.internal._oai_images_block(datum: openai.internal.OaImageDatum, mime: string) -> ai.content.Media | null { - 348 0 load_var 1 (datum) - 1 load_field 0 (b64_json) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +19 (to 25) - - 354 7 load_var 1 (datum) - 8 load_field 1 (url) - 9 store_var 5 (_10) - 10 load_var 5 (_10) - 11 narrow_bind 0 5 - 12 pop_jump_if_false +2 (to 14) - 13 jump +3 (to 16) - - 360 14 load_const 1 (null) - 15 jump +18 (to 33) - - 354 16 load_var 5 (_10) - 17 store_var_load_var 6 (location) - - 356 18 load_var 2 (mime) - 19 call 1152 ntypeargs=0 (openai.internal._oai_images_fetch_inline) - - 355 20 load_const 2 () - - 357 21 load_var 1 (datum) - 22 load_field 2 (revised_prompt) - - 355 23 call 904 ntypeargs=0 (ai.content.Media.new) - 24 jump +9 (to 33) - - 348 25 load_var 3 (_4) - 26 store_var_load_var 4 (encoded) - - 350 27 load_var 2 (mime) - 28 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 349 29 load_const 2 () - - 351 30 load_var 1 (datum) - 31 load_field 2 (revised_prompt) - - 349 32 call 904 ntypeargs=0 (ai.content.Media.new) - 33 return -} - -function openai.internal._oai_images_client_id(c: openai.ImageClient) -> string { - 88 0 load_type 0 - 1 load_var 1 (c) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 4 (_3) - 5 load_const 1 ("openai-images/") - 6 load_var 4 (_3) - 7 bin_op + - 8 store_var 3 (id) - - 89 9 load_var 3 (id) - 10 store_var 2 (_0) - 11 load_var 2 (_0) - 12 return -} - -function openai.internal._oai_images_drop_nulls(value: baml.json.json) -> baml.json.json { - 97 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +39 (to 44) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 119 12 load_var 1 (value) - - 97 13 jump +77 (to 90) - 14 load_var 10 (_24) - 15 store_var 11 (items) - - 113 16 load_type 2 - 17 alloc_array 0 - 18 store_var 12 (out) - - 114 19 load_var 11 (items) - 20 load_type 3 - 21 load_const 4 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 13 (_28) - 24 load_var 13 (_28) - 25 load_type 5 - 26 load_const 6 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 14 (_29) - 29 load_var 14 (_29) - 30 is_type 7 - 31 pop_jump_if_false +2 (to 33) - 32 jump +10 (to 42) - 33 load_var 14 (_29) - 34 store_var_load_var 15 (item) - - 115 35 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - 36 store_var 16 (_34) - 37 load_type 2 - 38 load_var2 12 16 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -17 (to 24) - - 117 42 load_var 12 (out) - - 97 43 jump +47 (to 90) - 44 load_var 2 (_2) - 45 store_var 3 (object) - - 99 46 load_type 8 - 47 load_type 2 - 48 alloc_map 0 - 49 store_var 4 (out) - - 100 50 load_type 8 - 51 load_type 2 - 52 load_var 3 (object) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 9 - 55 load_const 10 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 5 (_8) - 58 load_var 5 (_8) - 59 load_type 11 - 60 load_const 12 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 6 (_9) - 63 load_var 6 (_9) - 64 is_type 7 - 65 pop_jump_if_false +2 (to 67) - 66 jump +23 (to 89) - 67 load_var 6 (_9) - 68 store_var 7 (key) - - 101 69 load_type 8 - 70 load_type 2 - 71 load_var2 3 7 - 72 call 38 ntypeargs=2 (baml.Map.get) - 73 store_var 8 (entry) - - 102 74 load_var 8 (entry) - 75 load_const 13 (null) - 76 cmp_op == - 77 pop_jump_if_false +2 (to 79) - 78 jump -20 (to 58) - - 105 79 load_var 8 (entry) - 80 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - 81 store_var 9 (_20) - 82 load_type 8 - 83 load_type 2 - 84 load_var2 4 7 - 85 load_var 9 (_20) - 86 call 37 ntypeargs=2 (baml.Map.set) - 87 pop 1 - 88 jump -30 (to 58) - - 110 89 load_var 4 (out) - 90 return -} - -function openai.internal._oai_images_escape_query(raw: string) -> string { - 213 0 load_var 1 (raw) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("&") - 8 load_const 5 ("%26") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("=") - 11 load_const 7 ("%3D") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("?") - 14 load_const 9 ("%3F") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("#") - 17 load_const 11 ("%23") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - - 220 19 store_var 2 (_0) - 20 load_var 2 (_0) - 21 return -} - -function openai.internal._oai_images_fetch_inline(location: string, fallback_mime: string) -> image { - 322 0 load_var 1 (location) - 1 load_const 0 () - 2 call 248 ntypeargs=0 (baml.http.fetch) - 3 store_var 3 (response) - 4 jump +26 (to 30) - 5 load_var 4 (e) - 6 throw_if_panic - - 325 7 load_type 1 - 8 load_var 1 (location) - 9 call 138 ntypeargs=1 (baml.String.from) - 10 store_var 5 (_9) - 11 load_type 2 - 12 load_var 4 (e) - 13 call 138 ntypeargs=1 (baml.String.from) - 14 store_var 7 (_12) - 15 load_type 1 - 16 load_var 7 (_12) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 6 (_11) - - 323 19 load_const 3 ("openai-images") - - 325 20 load_const 4 ("fetching the generated image at ") - 21 load_var 5 (_9) - 22 bin_op + - 23 load_const 5 (" failed: ") - 24 bin_op + - 25 load_var 6 (_11) - 26 bin_op + - 27 load_const 6 (null) - 28 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 29 throw - - 329 30 load_var 3 (response) - 31 call 240 ntypeargs=0 (baml.http.Response.ok) - 32 unary_op ! - 33 pop_jump_if_false +2 (to 35) - 34 jump +47 (to 81) - - 336 35 load_type 1 - 36 load_type 1 - 37 load_var 3 (response) - 38 load_field 1 (headers) - 39 load_const 7 ("content-type") - 40 call 38 ntypeargs=2 (baml.Map.get) - 41 store_var_load_var 13 (_31) - 42 load_const 6 (null) - 43 cmp_op == - 44 pop_jump_if_false +3 (to 47) - 45 load_const 8 ("") - 46 store_var 13 (_31) - 47 load_var 13 (_31) - 48 load_const 9 (";") - 49 call 150 ntypeargs=0 (baml.String.split) - 50 store_var 12 (_29) - 51 load_type 1 - 52 load_var 12 (_29) - 53 load_const 10 (0) - 54 call 3 ntypeargs=1 (baml.Array.at) - 55 store_var_load_var 11 (_27) - 56 load_const 6 (null) - 57 cmp_op == - 58 pop_jump_if_false +3 (to 61) - 59 load_const 11 ("") - 60 store_var 11 (_27) - 61 load_var 11 (_27) - 62 store_var 10 (reported) - - 337 63 load_var 10 (reported) - 64 call 144 ntypeargs=0 (baml.String.trim) - 65 load_const 12 ("") - 66 cmp_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +5 (to 73) - - 340 69 load_var 10 (reported) - 70 call 144 ntypeargs=0 (baml.String.trim) - 71 store_var 14 (mime) - 72 jump +3 (to 75) - - 338 73 load_var 2 (fallback_mime) - 74 store_var 14 (mime) - - 342 75 load_var 3 (response) - 76 sys_op 239 (baml.http.Response.bytes) - 77 call 198 ntypeargs=0 (baml.Uint8Array.to_base64) - 78 load_var 14 (mime) - 79 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 80 return - - 332 81 load_type 1 - 82 load_var 1 (location) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 8 (_21) - 85 load_type 13 - 86 load_var 3 (response) - 87 load_field 0 (status_code) - 88 call 138 ntypeargs=1 (baml.String.from) - 89 store_var 9 (_23) - - 330 90 load_const 14 ("openai-images") - - 332 91 load_const 15 ("fetching the generated image at ") - 92 load_var 8 (_21) - 93 bin_op + - 94 load_const 16 (" returned HTTP ") - 95 bin_op + - 96 load_var 9 (_23) - 97 bin_op + - 98 load_const 6 (null) - 99 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 100 throw -} - -function openai.internal._oai_images_headers(c: openai.ImageClient) -> map { - 247 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 3 (headers) - - 248 6 load_var 1 (c) - 7 load_field 14 (headers) - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 narrow_bind 3 4 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 4 (_4) - 13 store_var 5 (extra) - - 249 14 load_type 2 - 15 load_type 2 - 16 load_var 5 (extra) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 7 (_10) - 27 load_var 7 (_10) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 7 (_10) - 32 store_var 8 (name) - - 250 33 load_var 8 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 9 (_15) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 5 8 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 10 (_17) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 10 (_17) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 3 9 - 49 load_var 10 (_17) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 253 53 load_var 1 (c) - 54 call 1093 ntypeargs=0 (openai.ImageClient.resolved_api_key) - 55 store_var 12 (_28) - 56 load_type 2 - 57 load_var 12 (_28) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 11 (_27) - 60 load_type 2 - 61 load_type 2 - 62 load_var 3 (headers) - 63 load_const 11 ("authorization") - 64 load_const 12 ("Bearer ") - 65 load_var 11 (_27) - 66 bin_op + - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - - 254 69 load_var 3 (headers) - 70 store_var 2 (_0) - 71 load_var 2 (_0) - 72 return -} - -function openai.internal._oai_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - 127 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 4 (_4) - 4 load_const 1 ("Images API only supports text prompts; found ") - 5 load_var 4 (_4) - 6 bin_op + - 7 load_const 2 (" input") - 8 bin_op + - 9 store_var 3 (detail) - - 128 10 load_const 3 ("openai-images") - 11 load_const 4 (null) - - 131 12 load_var 3 (detail) - 13 load_const 4 (null) - 14 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 15 store_var 2 (_0) - 16 load_var 2 (_0) - 17 return -} - -function openai.internal._oai_images_mime(format: string | null) -> string { - 307 0 load_var 1 (format) - 1 store_var_load_var 3 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("png") - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 call 142 ntypeargs=0 (baml.String.to_lower_case) - 9 store_var 2 (normalized) - - 308 10 load_var 2 (normalized) - 11 load_const 2 ("jpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 2 (normalized) - 16 load_const 3 ("jpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 2 (normalized) - 21 load_const 4 ("webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - 25 load_var 2 (normalized) - 26 load_const 5 ("gif") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +3 (to 32) - - 312 30 load_const 6 ("image/png") - - 308 31 jump +8 (to 39) - - 311 32 load_const 7 ("image/gif") - - 308 33 jump +6 (to 39) - - 310 34 load_const 8 ("image/webp") - - 308 35 jump +4 (to 39) - - 309 36 load_const 9 ("image/jpeg") - - 308 37 jump +2 (to 39) - - 309 38 load_const 10 ("image/jpeg") - 39 return -} - -function openai.internal._oai_images_prompt_text(prompt: ai.Prompt, journal: ai.Journal) -> string { - 142 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (parts) - - 143 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +69 (to 86) - 18 load_var 6 (_6) - 19 store_var_load_var 7 (message) - - 144 20 load_field 2 (parts) - 21 load_type 6 - 22 load_const 7 ("iter") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 8 (_11) - 25 load_var 8 (_11) - 26 load_type 8 - 27 load_const 9 ("next") - 28 virtual_call nargs=1 ntypeargs=0 - 29 store_var 9 (_12) - 30 load_var 9 (_12) - 31 is_type 5 - 32 pop_jump_if_false +2 (to 34) - 33 jump -24 (to 9) - 34 load_var 9 (_12) - 35 store_var 10 (part) - - 145 36 load_var 10 (part) - 37 store_var 11 (_16) - 38 load_var 11 (_16) - 39 narrow_bind 10 11 - 40 pop_jump_if_false +2 (to 42) - 41 jump +31 (to 72) - 42 load_var 10 (part) - 43 store_var 14 (_24) - 44 load_var 14 (_24) - 45 narrow_bind 11 14 - 46 pop_jump_if_false +2 (to 48) - 47 jump +22 (to 69) - 48 load_var 10 (part) - 49 store_var 15 (_26) - 50 load_var 15 (_26) - 51 narrow_bind 12 15 - 52 pop_jump_if_false +2 (to 54) - 53 jump +13 (to 66) - 54 load_var 10 (part) - 55 store_var 16 (_28) - 56 load_var 16 (_28) - 57 narrow_bind 13 16 - 58 pop_jump_if_false +2 (to 60) - 59 jump +4 (to 63) - - 163 60 load_const 14 ("pdf") - 61 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 62 throw - - 160 63 load_const 15 ("video") - 64 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 65 throw - - 157 66 load_const 16 ("audio") - 67 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 68 throw - - 154 69 load_const 17 ("image") - 70 call 1143 ntypeargs=0 (openai.internal._oai_images_media_rejected) - 71 throw - - 145 72 load_var 11 (_16) - 73 store_var 12 (text) - - 147 74 load_var 12 (text) - 75 call 144 ntypeargs=0 (baml.String.trim) - 76 store_var 13 (trimmed) - - 148 77 load_var 13 (trimmed) - 78 load_const 18 ("") - 79 cmp_op != - 80 pop_jump_if_false -55 (to 25) - - 149 81 load_type 0 - 82 load_var2 4 13 - 83 call 4 ntypeargs=1 (baml.Array.push) - 84 pop 1 - 85 jump -60 (to 25) - - 168 86 load_var 2 (journal) - 87 call 905 ntypeargs=0 (ai.Journal.entries) - 88 load_type 19 - 89 load_const 20 ("iter") - 90 virtual_call nargs=1 ntypeargs=0 - 91 store_var 17 (_32) - 92 load_var 17 (_32) - 93 load_type 21 - 94 load_const 22 ("next") - 95 virtual_call nargs=1 ntypeargs=0 - 96 store_var 18 (_33) - 97 load_var 18 (_33) - 98 is_type 5 - 99 pop_jump_if_false +2 (to 101) - 100 jump +22 (to 122) - 101 load_var 18 (_33) - 102 store_var 19 (event) - - 169 103 load_var 19 (event) - 104 store_var 20 (_37) - 105 load_var 20 (_37) - 106 narrow_bind 23 20 - 107 pop_jump_if_false -15 (to 92) - 108 load_var 20 (_37) - 109 store_var_load_var 21 (user) - - 170 110 load_field 0 (content) - 111 call 144 ntypeargs=0 (baml.String.trim) - 112 store_var 22 (trimmed) - - 171 113 load_var 22 (trimmed) - 114 load_const 24 ("") - 115 cmp_op != - 116 pop_jump_if_false -24 (to 92) - - 172 117 load_type 0 - 118 load_var2 4 22 - 119 call 4 ntypeargs=1 (baml.Array.push) - 120 pop 1 - 121 jump -29 (to 92) - - 176 122 load_type 0 - 123 load_var 4 (parts) - 124 load_const 25 ("\n\n") - 125 call 15 ntypeargs=1 (baml.Array.join) - 126 store_var 23 (joined) - - 177 127 load_var 23 (joined) - 128 load_const 26 ("") - 129 cmp_op == - 130 pop_jump_if_false +2 (to 132) - 131 jump +5 (to 136) - - 185 132 load_var 23 (joined) - 133 store_var 3 (_0) - 134 load_var 3 (_0) - 135 return - - 178 136 load_const 27 ("openai-images") - 137 load_const 28 (null) - 138 load_const 29 ("Images API request requires a text prompt") - 139 load_const 28 (null) - 140 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 141 throw -} - -function openai.internal._oai_images_response_format(model: string, explicit: string | null) -> string | null { - 193 0 load_var 2 (explicit) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +10 (to 15) - - 196 6 load_var 1 (model) - 7 load_const 1 ("gpt-image") - 8 call 148 ntypeargs=0 (baml.String.starts_with) - 9 pop_jump_if_false +2 (to 11) - 10 jump +3 (to 13) - - 199 11 load_const 2 ("b64_json") - 12 jump +6 (to 18) - - 197 13 load_const 3 (null) - 14 jump +4 (to 18) - - 193 15 load_var 3 (_3) - 16 store_var 4 (chosen) - - 194 17 load_var 4 (chosen) - 18 return -} - -function openai.internal._oai_images_trim_slash(url: string) -> string { - 203 0 load_var 1 (url) - 1 load_const 0 ("/") - 2 call 149 ntypeargs=0 (baml.String.ends_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 206 5 load_var 1 (url) - 6 jump +10 (to 16) - - 204 7 load_var 1 (url) - 8 call 139 ntypeargs=0 (baml.String.length) - 9 store_var 2 (_4) - 10 load_var 1 (url) - 11 load_const 1 (0) - 12 load_var 2 (_4) - 13 load_const 2 (1) - 14 sub_int - 15 call 153 ntypeargs=0 (baml.String.slice) - 16 return -} - -function openai.internal._oai_images_with_query(url: string, params: map | null) -> string { - 224 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (pairs) - - 225 3 load_var 2 (params) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +54 (to 61) - 8 load_var 4 (_4) - 9 store_var 5 (configured) - - 226 10 load_type 0 - 11 load_type 0 - 12 load_var 5 (configured) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_9) - 18 load_var 6 (_9) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_10) - 23 load_var 7 (_10) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +35 (to 61) - 27 load_var 7 (_10) - 28 store_var_load_var 8 (key) - - 228 29 call 1147 ntypeargs=0 (openai.internal._oai_images_escape_query) - 30 store_var 10 (_18) - 31 load_type 0 - 32 load_var 10 (_18) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 9 (_17) - 35 load_type 0 - 36 load_type 0 - 37 load_var2 5 8 - 38 call 38 ntypeargs=2 (baml.Map.get) - 39 store_var_load_var 13 (_24) - 40 load_const 7 (null) - 41 cmp_op == - 42 pop_jump_if_false +3 (to 45) - 43 load_const 8 ("") - 44 store_var 13 (_24) - 45 load_var 13 (_24) - 46 call 1147 ntypeargs=0 (openai.internal._oai_images_escape_query) - 47 store_var 12 (_22) - 48 load_type 0 - 49 load_var 12 (_22) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 11 (_21) - - 227 52 load_type 0 - 53 load_var2 3 9 - - 228 54 load_const 9 ("=") - 55 bin_op + - 56 load_var 11 (_21) - 57 bin_op + - - 227 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -42 (to 18) - - 232 61 load_var 3 (pairs) - 62 container_len - 63 store_var 14 (_33) - 64 load_var 14 (_33) - 65 load_const 10 (0) - 66 cmp_int_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - - 235 69 load_var 1 (url) - 70 load_const 11 ("?") - 71 call 147 ntypeargs=0 (baml.String.includes) - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 238 74 load_const 12 ("?") - 75 store_var 15 (separator) - - 235 76 jump +3 (to 79) - - 236 77 load_const 13 ("&") - 78 store_var 15 (separator) - - 240 79 load_type 0 - 80 load_var 1 (url) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 16 (_37) - 83 load_type 0 - 84 load_var 15 (separator) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 17 (_39) - 87 load_type 0 - 88 load_var 3 (pairs) - 89 load_const 14 ("&") - 90 call 15 ntypeargs=1 (baml.Array.join) - 91 store_var 19 (_43) - 92 load_type 0 - 93 load_var 19 (_43) - 94 call 138 ntypeargs=1 (baml.String.from) - 95 store_var 18 (_42) - 96 load_var2 16 17 - 97 bin_op + - 98 load_var 18 (_42) - 99 bin_op + - 100 jump +2 (to 102) - - 233 101 load_var 1 (url) - 102 return -} - -function openai.internal._openai_apply_message_metadata(body: baml.json.json, metadata: map[]) -> baml.json.json { - 497 0 load_var 1 (body) - 1 store_var 4 (_3) - 2 load_var 4 (_3) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +53 (to 57) - 5 load_var 4 (_3) - 6 store_var 5 (object) - - 499 7 load_type 1 - 8 load_type 2 - 9 load_var 5 (object) - 10 load_const 3 ("input") - 11 call 38 ntypeargs=2 (baml.Map.get) - 12 store_var 6 (_8) - 13 load_var 6 (_8) - 14 narrow_bind 4 6 - 15 pop_jump_if_false +42 (to 57) - 16 load_var 6 (_8) - 17 store_var 7 (items) - - 501 18 load_const 5 (0) - 19 store_var 8 (index) - - 502 20 load_var 2 (metadata) - 21 load_type 6 - 22 load_const 7 ("iter") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 9 (_11) - 25 load_var 9 (_11) - 26 load_type 8 - 27 load_const 9 ("next") - 28 virtual_call nargs=1 ntypeargs=0 - 29 store_var 10 (_12) - 30 load_var 10 (_12) - 31 is_type 10 - 32 pop_jump_if_false +2 (to 34) - 33 jump +24 (to 57) - 34 load_var 10 (_12) - 35 store_var 11 (directives) - - 503 36 load_type 1 - 37 load_type 2 - 38 load_var 11 (directives) - 39 call 35 ntypeargs=2 (baml.Map.keys) - 40 container_len - 41 store_var 12 (_17) - 42 load_var 12 (_17) - 43 load_const 5 (0) - 44 cmp_int_op > - 45 pop_jump_if_false +7 (to 52) - - 504 46 load_type 2 - 47 load_var2 7 8 - 48 call 3 ntypeargs=1 (baml.Array.at) - 49 load_var 11 (directives) - 50 call 1026 ntypeargs=0 (openai.internal._openai_merge_onto_last_part) - 51 pop 1 - - 506 52 load_var 8 (index) - 53 load_const 11 (1) - 54 add_int - 55 store_var 8 (index) - - 502 56 jump -31 (to 25) - - 516 57 load_var 1 (body) - 58 store_var 3 (_0) - 59 load_var 3 (_0) - 60 return -} - -function openai.internal._openai_audio_format(mime_type: string) -> string { - 327 0 load_var 1 (mime_type) - 1 load_const 0 ("audio/wav") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +52 (to 56) - 5 load_var 1 (mime_type) - 6 load_const 1 ("audio/x-wav") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +45 (to 54) - 10 load_var 1 (mime_type) - 11 load_const 2 ("audio/mpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +38 (to 52) - 15 load_var 1 (mime_type) - 16 load_const 3 ("audio/mp3") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +31 (to 50) - 20 load_var 1 (mime_type) - 21 load_const 4 ("audio/flac") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +24 (to 48) - 25 load_var 1 (mime_type) - 26 load_const 5 ("audio/x-flac") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +17 (to 46) - 30 load_var 1 (mime_type) - 31 load_const 6 ("audio/ogg") - 32 cmp_op == - 33 pop_jump_if_false +2 (to 35) - 34 jump +10 (to 44) - 35 load_var 1 (mime_type) - 36 load_const 7 ("audio/webm") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +3 (to 42) - - 333 40 load_var 1 (mime_type) - - 327 41 jump +16 (to 57) - - 332 42 load_const 8 ("webm") - - 327 43 jump +14 (to 57) - - 331 44 load_const 9 ("ogg") - - 327 45 jump +12 (to 57) - - 330 46 load_const 10 ("flac") - - 327 47 jump +10 (to 57) - - 330 48 load_const 11 ("flac") - - 327 49 jump +8 (to 57) - - 329 50 load_const 12 ("mp3") - - 327 51 jump +6 (to 57) - - 329 52 load_const 13 ("mp3") - - 327 53 jump +4 (to 57) - - 328 54 load_const 14 ("wav") - - 327 55 jump +2 (to 57) - - 328 56 load_const 15 ("wav") - 57 return -} - -function openai.internal._openai_decode_batch(batch: string, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1098 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (out) - - 1099 3 load_var 1 (batch) - 4 call 958 ntypeargs=0 (ai.stream.decode_sse_batch) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +47 (to 64) - 18 load_var 6 (_6) - 19 store_var_load_var 7 (raw) - - 1100 20 load_field 1 (data) - 21 store_var 8 (_11) - 22 load_var 8 (_11) - 23 narrow_bind 6 8 - 24 pop_jump_if_false -15 (to 9) - 25 load_var 8 (_11) - 26 store_var 9 (data) - - 1101 27 load_type 7 - 28 load_var 9 (data) - 29 call 357 ntypeargs=1 (baml.json.from_string) - 30 jump +4 (to 34) - 31 load_var 10 (e) - 32 throw_if_panic - - 1102 33 load_const 8 (null) - - 1104 34 store_var 11 (_17) - 35 load_var 11 (_17) - 36 narrow_bind 9 11 - 37 pop_jump_if_false -28 (to 9) - 38 load_var 11 (_17) - 39 store_var_load_var 12 (event) - - 1105 40 load_var 7 (raw) - 41 load_field 0 (event) - 42 load_var 2 (state) - 43 call 1047 ntypeargs=0 (openai.internal._openai_stream_events) - 44 load_type 10 - 45 load_const 11 ("iter") - 46 virtual_call nargs=1 ntypeargs=0 - 47 store_var 13 (_22) - 48 load_var 13 (_22) - 49 load_type 12 - 50 load_const 13 ("next") - 51 virtual_call nargs=1 ntypeargs=0 - 52 store_var 14 (_23) - 53 load_var 14 (_23) - 54 is_type 5 - 55 pop_jump_if_false +2 (to 57) - 56 jump -47 (to 9) - 57 load_var 14 (_23) - 58 store_var 15 (e) - - 1106 59 load_type 0 - 60 load_var2 4 15 - 61 call 4 ntypeargs=1 (baml.Array.push) - 62 pop 1 - 63 jump -15 (to 48) - - 1112 64 load_var 4 (out) - 65 store_var 3 (_0) - 66 load_var 3 (_0) - 67 return -} - -function openai.internal._openai_error_failure(err: openai.internal.OaErrorBody) -> ai.errors.Failure { - 785 0 load_var 1 (err) - 1 load_field 0 (code) - 2 store_var_load_var 4 (_6) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("") - 7 store_var 4 (_6) - 8 load_var 4 (_6) - 9 load_const 2 (" ") - 10 bin_op + - 11 store_var 3 (_4) - 12 load_var 1 (err) - 13 load_field 2 (type) - 14 store_var_load_var 5 (_10) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +3 (to 20) - 18 load_const 3 ("") - 19 store_var 5 (_10) - 20 load_var2 3 5 - 21 bin_op + - 22 call 142 ntypeargs=0 (baml.String.to_lower_case) - 23 store_var 2 (code) - - 786 24 load_var 1 (err) - 25 load_field 1 (message) - 26 store_var_load_var 7 (_14) - 27 load_const 0 (null) - 28 cmp_op == - 29 pop_jump_if_false +3 (to 32) - 30 load_const 4 ("the OpenAI Responses request failed") - 31 store_var 7 (_14) - 32 load_var 7 (_14) - 33 store_var 6 (detail) - - 787 34 load_type 5 - 35 load_var 1 (err) - 36 call 355 ntypeargs=1 (baml.json.to_json) - 37 call 351 ntypeargs=0 (baml.json.stringify) - 38 store_var 8 (raw) - - 788 39 load_var 2 (code) - 40 load_const 6 ("rate_limit") - 41 call 147 ntypeargs=0 (baml.String.includes) - 42 jump_if_false +2 (to 44) - 43 jump +5 (to 48) - 44 pop 1 - 45 load_var 2 (code) - 46 load_const 7 ("quota") - 47 call 147 ntypeargs=0 (baml.String.includes) - 48 jump_if_false +2 (to 50) - 49 jump +5 (to 54) - 50 pop 1 - 51 load_var 2 (code) - 52 load_const 8 ("credit_balance") - 53 call 147 ntypeargs=0 (baml.String.includes) - 54 pop_jump_if_false +2 (to 56) - 55 jump +35 (to 90) - - 790 56 load_var 2 (code) - 57 load_const 9 ("content_filter") - 58 call 147 ntypeargs=0 (baml.String.includes) - 59 jump_if_false +2 (to 61) - 60 jump +5 (to 65) - 61 pop 1 - 62 load_var 2 (code) - 63 load_const 10 ("moderation") - 64 call 147 ntypeargs=0 (baml.String.includes) - 65 jump_if_false +2 (to 67) - 66 jump +5 (to 71) - 67 pop 1 - 68 load_var 2 (code) - 69 load_const 11 ("refusal") - 70 call 147 ntypeargs=0 (baml.String.includes) - 71 pop_jump_if_false +2 (to 73) - 72 jump +14 (to 86) - - 792 73 load_var 2 (code) - 74 call 1039 ntypeargs=0 (openai.internal._openai_transient_code) - 75 pop_jump_if_false +2 (to 77) - 76 jump +6 (to 82) - - 795 77 load_const 12 ("openai") - 78 load_const 0 (null) - - 798 79 load_var2 6 8 - - 799 80 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - - 792 81 jump +13 (to 94) - - 793 82 load_const 13 ("openai") - 83 load_var2 6 8 - 84 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - - 792 85 jump +9 (to 94) - - 791 86 load_const 14 ("openai") - 87 load_var2 6 8 - 88 init_instance 2 (ai.errors.Refused .provider, .reason, .raw_body) - - 790 89 jump +5 (to 94) - - 789 90 load_const 15 ("openai") - 91 load_const 0 (null) - 92 load_var 8 (raw) - 93 init_instance 3 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) - 94 return -} - -function openai.internal._openai_event_key(event: openai.internal.OaStreamEvent) -> string { - 987 0 load_var 1 (event) - 1 load_field 4 (item_id) - 2 store_var 3 (_4) - 3 load_var 3 (_4) - 4 narrow_bind 0 3 - 5 pop_jump_if_false +2 (to 7) - 6 jump +22 (to 28) - - 989 7 load_var 1 (event) - 8 load_field 5 (output_index) - 9 store_var 5 (_7) - 10 load_var 5 (_7) - 11 narrow_bind 1 5 - 12 pop_jump_if_false +2 (to 14) - 13 jump +4 (to 17) - - 992 14 load_const 2 ("") - 15 store_var 2 (item) - - 989 16 jump +16 (to 32) - 17 load_var 5 (_7) - 18 store_var 6 (index) - - 990 19 load_type 3 - 20 load_var 6 (index) - 21 call 138 ntypeargs=1 (baml.String.from) - 22 store_var 7 (_9) - 23 load_const 4 ("#") - 24 load_var 7 (_9) - 25 bin_op + - 26 store_var 2 (item) - - 989 27 jump +5 (to 32) - - 987 28 load_var 3 (_4) - 29 store_var 4 (id) - - 988 30 load_var 4 (id) - 31 store_var 2 (item) - - 994 32 load_var 1 (event) - 33 load_field 6 (content_index) - 34 store_var 8 (_13) - 35 load_var 8 (_13) - 36 narrow_bind 1 8 - 37 pop_jump_if_false +2 (to 39) - 38 jump +3 (to 41) - - 997 39 load_var 2 (item) - - 994 40 jump +16 (to 56) - 41 load_var 8 (_13) - 42 store_var 9 (part) - - 995 43 load_type 5 - 44 load_var 2 (item) - 45 call 138 ntypeargs=1 (baml.String.from) - 46 store_var 10 (_16) - 47 load_type 3 - 48 load_var 9 (part) - 49 call 138 ntypeargs=1 (baml.String.from) - 50 store_var 11 (_19) - 51 load_var 10 (_16) - 52 load_const 6 (":") - 53 bin_op + - 54 load_var 11 (_19) - 55 bin_op + - 56 return -} - -function openai.internal._openai_file_name(source: string | null) -> string { - 312 0 load_var 1 (source) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +45 (to 49) - 5 load_var 2 (_2) - 6 store_var 3 (raw) - - 313 7 load_var 3 (raw) - 8 load_const 1 ("?") - 9 call 150 ntypeargs=0 (baml.String.split) - 10 store_var 6 (_7) - 11 load_type 2 - 12 load_var 6 (_7) - 13 load_const 3 (0) - 14 call 3 ntypeargs=1 (baml.Array.at) - 15 store_var_load_var 5 (_5) - 16 load_const 4 (null) - 17 cmp_op == - 18 pop_jump_if_false +3 (to 21) - 19 load_var 3 (raw) - 20 store_var 5 (_5) - 21 load_var 5 (_5) - 22 store_var 4 (without_query) - - 314 23 load_var 4 (without_query) - 24 load_const 5 ("/") - 25 call 150 ntypeargs=0 (baml.String.split) - 26 store_var 7 (segments) - - 315 27 load_var 7 (segments) - 28 container_len - 29 store_var 10 (_15) - 30 load_type 2 - 31 load_var2 7 10 - 32 load_const 0 (1) - 33 sub_int - 34 call 3 ntypeargs=1 (baml.Array.at) - 35 store_var_load_var 9 (_12) - 36 load_const 4 (null) - 37 cmp_op == - 38 pop_jump_if_false +3 (to 41) - 39 load_const 6 ("") - 40 store_var 9 (_12) - 41 load_var 9 (_12) - 42 store_var 8 (last) - - 316 43 load_var 8 (last) - 44 call 144 ntypeargs=0 (baml.String.trim) - 45 load_const 7 ("") - 46 cmp_op != - 47 pop_jump_if_false +2 (to 49) - 48 jump +3 (to 51) - - 320 49 load_const 8 ("document.pdf") - 50 jump +3 (to 53) - - 317 51 load_var 8 (last) - 52 call 144 ntypeargs=0 (baml.String.trim) - 53 return -} - -function openai.internal._openai_headers(c: openai.ResponsesClient) -> map { - 659 0 load_const 0 ("application/json") - 1 load_const 1 ("content-type") - 2 load_type 2 - 3 load_type 2 - 4 alloc_map 1 - 5 store_var 3 (headers) - - 660 6 load_var 1 (c) - 7 load_field 12 (headers) - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 narrow_bind 3 4 - 11 pop_jump_if_false +42 (to 53) - 12 load_var 4 (_4) - 13 store_var 5 (extra) - - 661 14 load_type 2 - 15 load_type 2 - 16 load_var 5 (extra) - 17 call 35 ntypeargs=2 (baml.Map.keys) - 18 load_type 4 - 19 load_const 5 ("iter") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 6 (_9) - 22 load_var 6 (_9) - 23 load_type 6 - 24 load_const 7 ("next") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 7 (_10) - 27 load_var 7 (_10) - 28 is_type 8 - 29 pop_jump_if_false +2 (to 31) - 30 jump +23 (to 53) - 31 load_var 7 (_10) - 32 store_var 8 (name) - - 662 33 load_var 8 (name) - 34 call 142 ntypeargs=0 (baml.String.to_lower_case) - 35 store_var 9 (_15) - 36 load_type 2 - 37 load_type 2 - 38 load_var2 5 8 - 39 call 38 ntypeargs=2 (baml.Map.get) - 40 store_var_load_var 10 (_17) - 41 load_const 9 (null) - 42 cmp_op == - 43 pop_jump_if_false +3 (to 46) - 44 load_const 10 ("") - 45 store_var 10 (_17) - 46 load_type 2 - 47 load_type 2 - 48 load_var2 3 9 - 49 load_var 10 (_17) - 50 call 37 ntypeargs=2 (baml.Map.set) - 51 pop 1 - 52 jump -30 (to 22) - - 665 53 load_var 1 (c) - 54 call 1012 ntypeargs=0 (openai.ResponsesClient.resolved_api_key) - 55 store_var 12 (_28) - 56 load_type 2 - 57 load_var 12 (_28) - 58 call 138 ntypeargs=1 (baml.String.from) - 59 store_var 11 (_27) - 60 load_type 2 - 61 load_type 2 - 62 load_var 3 (headers) - 63 load_const 11 ("authorization") - 64 load_const 12 ("Bearer ") - 65 load_var 11 (_27) - 66 bin_op + - 67 call 37 ntypeargs=2 (baml.Map.set) - 68 pop 1 - - 666 69 load_var 3 (headers) - 70 store_var 2 (_0) - 71 load_var 2 (_0) - 72 return -} - -function openai.internal._openai_image_mime(output_format: string | null) -> string { - 755 0 load_var 1 (output_format) - 1 store_var_load_var 3 (_5) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("") - 6 store_var 3 (_5) - 7 load_var 3 (_5) - 8 call 144 ntypeargs=0 (baml.String.trim) - 9 call 142 ntypeargs=0 (baml.String.to_lower_case) - 10 store_var 2 (format) - - 756 11 load_var 2 (format) - 12 load_const 2 ("jpeg") - 13 cmp_op == - 14 pop_jump_if_false +2 (to 16) - 15 jump +17 (to 32) - 16 load_var 2 (format) - 17 load_const 3 ("jpg") - 18 cmp_op == - 19 pop_jump_if_false +2 (to 21) - 20 jump +10 (to 30) - 21 load_var 2 (format) - 22 load_const 4 ("webp") - 23 cmp_op == - 24 pop_jump_if_false +2 (to 26) - 25 jump +3 (to 28) - - 759 26 load_const 5 ("image/png") - - 756 27 jump +6 (to 33) - - 758 28 load_const 6 ("image/webp") - - 756 29 jump +4 (to 33) - - 757 30 load_const 7 ("image/jpeg") - - 756 31 jump +2 (to 33) - - 757 32 load_const 8 ("image/jpeg") - 33 return -} - -function openai.internal._openai_media_role_error(kind: string, role: string) -> ai.errors.Failure { - 338 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 5 (_6) - 4 load_type 0 - 5 load_var 2 (role) - 6 call 138 ntypeargs=1 (baml.String.from) - 7 store_var 6 (_8) - 8 load_const 1 ("OpenAI Responses only supports ") - 9 load_var 5 (_6) - 10 bin_op + - 11 load_const 2 (" input in user messages, found ") - 12 bin_op + - 13 load_var 6 (_8) - 14 bin_op + - 15 store_var 4 (detail) - - 339 16 load_const 3 ("openai") - 17 load_const 4 (null) - 18 load_var 4 (detail) - 19 load_const 4 (null) - 20 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 21 store_var 3 (_0) - 22 load_var 3 (_0) - 23 return -} - -function openai.internal._openai_merge_onto_last_part(item: baml.json.json, directives: map) -> void { - 472 0 load_var 1 (item) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +3 (to 8) - - 489 6 load_const 1 (null) - - 472 7 jump +66 (to 73) - 8 load_var 3 (_3) - 9 store_var 4 (message) - - 474 10 load_type 2 - 11 load_type 3 - 12 load_var 4 (message) - 13 load_const 4 ("content") - 14 call 38 ntypeargs=2 (baml.Map.get) - 15 store_var 5 (_8) - 16 load_var 5 (_8) - 17 narrow_bind 5 5 - 18 pop_jump_if_false +2 (to 20) - 19 jump +3 (to 22) - - 486 20 load_const 1 (null) - - 474 21 jump +52 (to 73) - 22 load_var 5 (_8) - 23 store_var 6 (parts) - - 476 24 load_var 6 (parts) - 25 container_len - 26 store_var 7 (_12) - 27 load_type 3 - 28 load_var2 6 7 - 29 load_const 6 (1) - 30 sub_int - 31 call 3 ntypeargs=1 (baml.Array.at) - 32 store_var 8 (_14) - 33 load_var 8 (_14) - 34 narrow_bind 0 8 - 35 pop_jump_if_false +2 (to 37) - 36 jump +3 (to 39) - - 483 37 load_const 1 (null) - - 476 38 jump +35 (to 73) - 39 load_var 8 (_14) - 40 store_var 9 (part) - - 478 41 load_type 2 - 42 load_type 3 - 43 load_var 2 (directives) - 44 call 35 ntypeargs=2 (baml.Map.keys) - 45 load_type 7 - 46 load_const 8 ("iter") - 47 virtual_call nargs=1 ntypeargs=0 - 48 store_var 10 (_19) - 49 load_var 10 (_19) - 50 load_type 9 - 51 load_const 10 ("next") - 52 virtual_call nargs=1 ntypeargs=0 - 53 store_var 11 (_20) - 54 load_var 11 (_20) - 55 is_type 11 - 56 pop_jump_if_false +2 (to 58) - 57 jump +15 (to 72) - 58 load_var 11 (_20) - 59 store_var 12 (key) - - 479 60 load_type 2 - 61 load_type 3 - 62 load_var2 2 12 - 63 call 38 ntypeargs=2 (baml.Map.get) - 64 store_var 13 (_26) - 65 load_type 2 - 66 load_type 3 - 67 load_var2 9 12 - 68 load_var 13 (_26) - 69 call 37 ntypeargs=2 (baml.Map.set) - 70 pop 1 - 71 jump -22 (to 49) - - 481 72 load_const 1 (null) - 73 return -} - -function openai.internal._openai_percent_encode(raw: string) -> string { - 288 0 load_const 0 ("") - 1 store_var 2 (out) - - 289 2 load_var 1 (raw) - 3 call 179 ntypeargs=0 (baml.String.to_utf8) - 4 call 194 ntypeargs=0 (baml.Uint8Array.to_array) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 3 (_5) - 9 load_var 3 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 4 (_6) - 14 load_var 4 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +81 (to 98) - 18 load_var 4 (_6) - 19 store_var_load_var 5 (byte) - - 290 20 load_const 6 (48) - 21 cmp_int_op >= - 22 jump_if_false +5 (to 27) - 23 pop 1 - 24 load_var 5 (byte) - 25 load_const 7 (57) - 26 cmp_int_op <= - 27 jump_if_false +2 (to 29) - 28 jump +10 (to 38) - 29 pop 1 - - 291 30 load_var 5 (byte) - 31 load_const 8 (65) - 32 cmp_int_op >= - 33 jump_if_false +5 (to 38) - 34 pop 1 - 35 load_var 5 (byte) - 36 load_const 9 (90) - 37 cmp_int_op <= - - 290 38 jump_if_false +2 (to 40) - 39 jump +10 (to 49) - 40 pop 1 - - 292 41 load_var 5 (byte) - 42 load_const 10 (97) - 43 cmp_int_op >= - 44 jump_if_false +5 (to 49) - 45 pop 1 - 46 load_var 5 (byte) - 47 load_const 11 (122) - 48 cmp_int_op <= - - 290 49 jump_if_false +2 (to 51) - 50 jump +5 (to 55) - 51 pop 1 - - 293 52 load_var 5 (byte) - 53 load_const 12 (45) - 54 cmp_int_op == - - 290 55 jump_if_false +2 (to 57) - 56 jump +5 (to 61) - 57 pop 1 - - 294 58 load_var 5 (byte) - 59 load_const 13 (46) - 60 cmp_int_op == - - 290 61 jump_if_false +2 (to 63) - 62 jump +5 (to 67) - 63 pop 1 - - 295 64 load_var 5 (byte) - 65 load_const 14 (95) - 66 cmp_int_op == - - 290 67 jump_if_false +2 (to 69) - 68 jump +5 (to 73) - 69 pop 1 - - 296 70 load_var 5 (byte) - 71 load_const 15 (126) - 72 cmp_int_op == - - 297 73 pop_jump_if_false +2 (to 75) - 74 jump +15 (to 89) - - 300 75 load_var 5 (byte) - 76 load_type 16 - 77 alloc_array 1 - 78 call 193 ntypeargs=0 (baml.Uint8Array.from_array) - 79 call 196 ntypeargs=0 (baml.Uint8Array.to_hex) - 80 call 143 ntypeargs=0 (baml.String.to_upper_case) - 81 store_var 7 (_35) - 82 load_var 2 (out) - 83 load_const 17 ("%") - 84 load_var 7 (_35) - 85 bin_op + - 86 bin_op + - 87 store_var 2 (out) - - 297 88 jump -79 (to 9) - - 298 89 load_var 5 (byte) - 90 load_type 16 - 91 alloc_array 1 - 92 call 182 ntypeargs=0 (baml.String.from_code_points) - 93 store_var 6 (_31) - 94 load_var2 2 6 - 95 bin_op + - 96 store_var 2 (out) - - 297 97 jump -88 (to 9) - - 303 98 load_var 2 (out) - 99 return -} - -function openai.internal._openai_prompt_content(message: ai.PromptMessage, role: string) -> (openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile)[] { - 344 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (content) - - 345 3 load_var 1 (message) - 4 load_field 2 (parts) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +233 (to 250) - 18 load_var 6 (_6) - 19 store_var 7 (part) - - 346 20 load_var 7 (part) - 21 store_var 8 (_10) - 22 load_var 8 (_10) - 23 narrow_bind 6 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +202 (to 227) - 26 load_var 7 (part) - 27 store_var 10 (_21) - 28 load_var 10 (_21) - 29 narrow_bind 7 10 - 30 pop_jump_if_false +2 (to 32) - 31 jump +138 (to 169) - 32 load_var 7 (part) - 33 store_var 18 (_46) - 34 load_var 18 (_46) - 35 narrow_bind 8 18 - 36 pop_jump_if_false +2 (to 38) - 37 jump +94 (to 131) - 38 load_var 7 (part) - 39 store_var 24 (_62) - 40 load_var 24 (_62) - 41 narrow_bind 9 24 - 42 pop_jump_if_false +2 (to 44) - 43 jump +7 (to 50) - - 422 44 load_const 10 ("openai") - 45 load_const 11 (null) - 46 load_const 12 ("OpenAI Responses does not support video prompt input") - 47 load_const 11 (null) - 48 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 49 throw - - 346 50 load_var 24 (_62) - 51 store_var 25 (pdf) - - 391 52 load_var 2 (role) - 53 load_const 13 ("user") - 54 cmp_op != - 55 pop_jump_if_false +2 (to 57) - 56 jump +71 (to 127) - - 394 57 load_var 25 (pdf) - 58 load_const 14 (false) - 59 call 933 ntypeargs=0 (ai.wire.resolve_media) - 60 store_var 26 (resolved) - - 395 61 load_var 25 (pdf) - 62 call 323 ntypeargs=0 (baml.media.Pdf.file) - 63 store_var_load_var 28 (_70) - 64 load_const 11 (null) - 65 cmp_op == - 66 pop_jump_if_false +4 (to 70) - 67 load_var 25 (pdf) - 68 call 322 ntypeargs=0 (baml.media.Pdf.url) - 69 store_var 28 (_70) - 70 load_var 28 (_70) - 71 call 1020 ntypeargs=0 (openai.internal._openai_file_name) - 72 store_var 27 (name) - - 396 73 load_var 26 (resolved) - 74 load_field 0 (url) - 75 store_var 29 (_74) - 76 load_var 29 (_74) - 77 narrow_bind 6 29 - 78 pop_jump_if_false +2 (to 80) - 79 jump +35 (to 114) - - 412 80 load_type 15 - 81 load_var 26 (resolved) - 82 load_field 2 (mime_type) - 83 call 138 ntypeargs=1 (baml.String.from) - 84 store_var 31 (_87) - 85 load_var 26 (resolved) - 86 load_field 1 (base64) - 87 store_var_load_var 33 (_92) - 88 load_const 11 (null) - 89 cmp_op == - 90 pop_jump_if_false +3 (to 93) - 91 load_const 16 ("") - 92 store_var 33 (_92) - 93 load_type 15 - 94 load_var 33 (_92) - 95 call 138 ntypeargs=1 (baml.String.from) - 96 store_var 32 (_90) - - 408 97 load_type 0 - 98 load_var 4 (content) - - 409 99 load_const 17 ("input_file") - - 411 100 load_var 27 (name) - - 412 101 load_const 18 ("data:") - 102 load_var 31 (_87) - 103 bin_op + - 104 load_const 19 (";base64,") - 105 bin_op + - 106 load_var 32 (_90) - 107 bin_op + - 108 load_const 11 (null) - 109 load_const 11 (null) - 110 init_instance 1 (openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id) - - 408 111 call 4 ntypeargs=1 (baml.Array.push) - 112 pop 1 - 113 jump -104 (to 9) - - 396 114 load_var 29 (_74) - 115 store_var 30 (url) - - 397 116 load_type 0 - 117 load_var 4 (content) - - 398 118 load_const 20 ("input_file") - - 400 119 load_var 27 (name) - 120 load_const 11 (null) - - 402 121 load_var 30 (url) - 122 load_const 11 (null) - 123 init_instance 2 (openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id) - - 397 124 call 4 ntypeargs=1 (baml.Array.push) - 125 pop 1 - 126 jump -117 (to 9) - - 392 127 load_const 21 ("PDF") - 128 load_var 2 (role) - 129 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 130 throw - - 346 131 load_var 18 (_46) - 132 store_var 19 (audio) - - 374 133 load_var 2 (role) - 134 load_const 22 ("user") - 135 cmp_op != - 136 pop_jump_if_false +2 (to 138) - 137 jump +28 (to 165) - - 378 138 load_var 19 (audio) - 139 load_const 23 (true) - 140 call 933 ntypeargs=0 (ai.wire.resolve_media) - 141 store_var 20 (resolved) - - 383 142 load_var 20 (resolved) - 143 load_field 1 (base64) - 144 store_var_load_var 22 (_56) - 145 load_const 11 (null) - 146 cmp_op == - 147 pop_jump_if_false +3 (to 150) - 148 load_const 24 ("") - 149 store_var 22 (_56) - 150 load_var 22 (_56) - 151 store_var 21 (_55) - - 384 152 load_var 20 (resolved) - 153 load_field 2 (mime_type) - 154 call 1021 ntypeargs=0 (openai.internal._openai_audio_format) - 155 store_var 23 (_59) - - 379 156 load_type 0 - 157 load_var 4 (content) - - 380 158 load_const 25 ("input_audio") - - 382 159 load_var2 21 23 - 160 init_instance 3 (openai.internal.OaAudioPayload .data, .format) - 161 init_instance 4 (openai.internal.OaInputAudio .type, .input_audio) - - 379 162 call 4 ntypeargs=1 (baml.Array.push) - 163 pop 1 - 164 jump -155 (to 9) - - 375 165 load_const 26 ("audio") - 166 load_var 2 (role) - 167 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 168 throw - - 346 169 load_var 10 (_21) - 170 store_var 11 (image) - - 358 171 load_var 2 (role) - 172 load_const 27 ("user") - 173 cmp_op != - 174 pop_jump_if_false +2 (to 176) - 175 jump +48 (to 223) - - 361 176 load_var 11 (image) - 177 load_const 14 (false) - 178 call 933 ntypeargs=0 (ai.wire.resolve_media) - 179 store_var 12 (resolved) - - 362 180 load_var 12 (resolved) - 181 load_field 0 (url) - 182 store_var_load_var 14 (_28) - 183 load_const 11 (null) - 184 cmp_op == - 185 pop_jump_if_false +26 (to 211) - 186 load_type 15 - 187 load_var 12 (resolved) - 188 load_field 2 (mime_type) - 189 call 138 ntypeargs=1 (baml.String.from) - 190 store_var 15 (_33) - 191 load_var 12 (resolved) - 192 load_field 1 (base64) - 193 store_var_load_var 17 (_38) - 194 load_const 11 (null) - 195 cmp_op == - 196 pop_jump_if_false +3 (to 199) - 197 load_const 28 ("") - 198 store_var 17 (_38) - 199 load_type 15 - 200 load_var 17 (_38) - 201 call 138 ntypeargs=1 (baml.String.from) - 202 store_var 16 (_36) - 203 load_const 29 ("data:") - 204 load_var 15 (_33) - 205 bin_op + - 206 load_const 30 (";base64,") - 207 bin_op + - 208 load_var 16 (_36) - 209 bin_op + - 210 store_var 14 (_28) - 211 load_var 14 (_28) - 212 store_var 13 (image_url) - - 363 213 load_type 0 - 214 load_var 4 (content) - - 364 215 load_const 31 ("input_image") - - 366 216 load_var 13 (image_url) - 217 load_const 11 (null) - 218 load_const 32 ("auto") - 219 init_instance 5 (openai.internal.OaInputImage .type, .image_url, .file_id, .detail) - - 363 220 call 4 ntypeargs=1 (baml.Array.push) - 221 pop 1 - 222 jump -213 (to 9) - - 359 223 load_const 33 ("image") - 224 load_var 2 (role) - 225 call 1022 ntypeargs=0 (openai.internal._openai_media_role_error) - 226 throw - - 346 227 load_var 8 (_10) - 228 store_var 9 (text) - - 348 229 load_var 2 (role) - 230 load_const 34 ("assistant") - 231 cmp_op == - 232 pop_jump_if_false +2 (to 234) - 233 jump +9 (to 242) - - 352 234 load_type 0 - 235 load_var 4 (content) - 236 load_const 35 ("input_text") - 237 load_var 9 (text) - 238 init_instance 6 (openai.internal.OaInputText .type, .text) - 239 call 4 ntypeargs=1 (baml.Array.push) - 240 pop 1 - 241 jump -232 (to 9) - - 349 242 load_type 0 - 243 load_var 4 (content) - 244 load_const 36 ("output_text") - 245 load_var 9 (text) - 246 init_instance 7 (openai.internal.OaOutputText .type, .text) - 247 call 4 ntypeargs=1 (baml.Array.push) - 248 pop 1 - 249 jump -240 (to 9) - - 431 250 load_var 4 (content) - 251 store_var 3 (_0) - 252 load_var 3 (_0) - 253 return -} - -function openai.internal._openai_prune_nulls(value: baml.json.json) -> baml.json.json { - 219 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +39 (to 44) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 241 12 load_var 1 (value) - - 219 13 jump +77 (to 90) - 14 load_var 10 (_24) - 15 store_var 11 (items) - - 235 16 load_type 2 - 17 alloc_array 0 - 18 store_var 12 (out) - - 236 19 load_var 11 (items) - 20 load_type 3 - 21 load_const 4 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 13 (_28) - 24 load_var 13 (_28) - 25 load_type 5 - 26 load_const 6 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 14 (_29) - 29 load_var 14 (_29) - 30 is_type 7 - 31 pop_jump_if_false +2 (to 33) - 32 jump +10 (to 42) - 33 load_var 14 (_29) - 34 store_var_load_var 15 (item) - - 237 35 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - 36 store_var 16 (_34) - 37 load_type 2 - 38 load_var2 12 16 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -17 (to 24) - - 239 42 load_var 12 (out) - - 219 43 jump +47 (to 90) - 44 load_var 2 (_2) - 45 store_var 3 (object) - - 221 46 load_type 8 - 47 load_type 2 - 48 alloc_map 0 - 49 store_var 4 (out) - - 222 50 load_type 8 - 51 load_type 2 - 52 load_var 3 (object) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 9 - 55 load_const 10 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 5 (_8) - 58 load_var 5 (_8) - 59 load_type 11 - 60 load_const 12 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 6 (_9) - 63 load_var 6 (_9) - 64 is_type 7 - 65 pop_jump_if_false +2 (to 67) - 66 jump +23 (to 89) - 67 load_var 6 (_9) - 68 store_var 7 (key) - - 223 69 load_type 8 - 70 load_type 2 - 71 load_var2 3 7 - 72 call 38 ntypeargs=2 (baml.Map.get) - 73 store_var 8 (entry) - - 224 74 load_var 8 (entry) - 75 load_const 13 (null) - 76 cmp_op == - 77 pop_jump_if_false +2 (to 79) - 78 jump -20 (to 58) - - 227 79 load_var 8 (entry) - 80 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - 81 store_var 9 (_20) - 82 load_type 8 - 83 load_type 2 - 84 load_var2 4 7 - 85 load_var 9 (_20) - 86 call 37 ntypeargs=2 (baml.Map.set) - 87 pop 1 - 88 jump -30 (to 58) - - 232 89 load_var 4 (out) - 90 return -} - -function openai.internal._openai_reasoning(c: openai.ResponsesClient) -> openai.internal.OaReasoningParams | null { - 641 0 load_var 1 (c) - 1 load_field 6 (reasoning_effort) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 jump_if_false +6 (to 10) - 5 pop 1 - 6 load_var 1 (c) - 7 load_field 7 (reasoning_summary) - 8 load_const 0 (null) - 9 call 672 ntypeargs=0 (baml.ops.equals_equals) - 10 pop_jump_if_false +2 (to 12) - 11 jump +7 (to 18) - - 644 12 load_var 1 (c) - 13 load_field 6 (reasoning_effort) - 14 load_var 1 (c) - 15 load_field 7 (reasoning_summary) - 16 init_instance 0 (openai.internal.OaReasoningParams .effort, .summary) - - 641 17 jump +2 (to 19) - - 642 18 load_const 0 (null) - 19 return -} - -function openai.internal._openai_request(c: openai.ResponsesClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 703 0 load_var 2 (input) - 1 load_field 0 (prompt) - 2 store_var 6 (_5) - 3 load_var 2 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 6 (_5) - 7 call_indirect - 8 store_var 5 (prompt) - - 704 9 load_var 5 (prompt) - 10 call 1024 ntypeargs=0 (openai.internal.openai_lower_prompt) - 11 store_var 7 (items) - - 707 12 load_var 2 (input) - 13 load_field 1 (journal) - 14 store_var 8 (_11) - 15 load_var 1 (c) - 16 load_type 0 - 17 load_const 1 ("id") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 9 (_12) - 20 load_var2 8 9 - 21 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 708 22 call 1028 ntypeargs=0 (openai.internal.openai_lower_journal) - 23 load_type 2 - 24 load_const 3 ("iter") - 25 virtual_call nargs=1 ntypeargs=0 - 26 store_var 10 (_15) - 27 load_var 10 (_15) - 28 load_type 4 - 29 load_const 5 ("next") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 11 (_16) - 32 load_var 11 (_16) - 33 is_type 6 - 34 pop_jump_if_false +2 (to 36) - 35 jump +8 (to 43) - 36 load_var 11 (_16) - 37 store_var 12 (item) - - 709 38 load_type 7 - 39 load_var2 7 12 - 40 call 4 ntypeargs=1 (baml.Array.push) - 41 pop 1 - 42 jump -15 (to 27) - - 711 43 load_var 2 (input) - 44 load_field 3 (output_type) - 45 call 1029 ntypeargs=0 (openai.internal._openai_wants_image) - 46 store_var 13 (wants_image) - - 712 47 load_var 2 (input) - 48 load_field 2 (toolbox) - 49 load_var 13 (wants_image) - 50 call 1030 ntypeargs=0 (openai.internal._openai_tools) - 51 store_var 14 (tools) - - 714 52 load_var 1 (c) - 53 load_field 0 (model) - 54 store_var 16 (_29) - - 716 55 load_var 1 (c) - 56 load_field 10 (store) - 57 store_var 17 (_31) - - 717 58 load_var 3 (stream) - 59 pop_jump_if_false +2 (to 61) - 60 jump +4 (to 64) - - 720 61 load_const 8 (null) - 62 store_var 18 (_32) - - 717 63 jump +3 (to 66) - - 718 64 load_const 9 (true) - 65 store_var 18 (_32) - - 722 66 load_var 1 (c) - 67 load_field 3 (temperature) - 68 store_var 19 (_33) - - 723 69 load_var 1 (c) - 70 load_field 4 (top_p) - 71 store_var 20 (_34) - - 724 72 load_var 1 (c) - 73 load_field 5 (max_output_tokens) - 74 store_var 21 (_35) - - 725 75 load_var 1 (c) - 76 call 1032 ntypeargs=0 (openai.internal._openai_reasoning) - 77 store_var 22 (_36) - - 726 78 load_var 1 (c) - 79 call 1033 ntypeargs=0 (openai.internal._openai_text) - 80 store_var 23 (_37) - - 727 81 load_var 1 (c) - 82 load_field 9 (parallel_tool_calls) - 83 store_var 24 (_38) - - 729 84 load_var2 14 13 - 85 call 1031 ntypeargs=0 (openai.internal._openai_tool_choice) - 86 store_var 25 (_40) - - 713 87 load_var2 16 7 - - 715 88 load_var2 17 18 - 89 load_var2 19 20 - 90 load_var2 21 22 - 91 load_var2 23 24 - - 728 92 load_var2 14 25 - 93 init_instance 0 (openai.internal.OaResponsesRequest .model, .input, .store, .stream, .temperature, .top_p, .max_output_tokens, .reasoning, .text, .parallel_tool_calls, .tools, .tool_choice) - 94 store_var 15 (request) - - 735 95 load_type 10 - 96 load_var 15 (request) - 97 call 355 ntypeargs=1 (baml.json.to_json) - 98 call 1017 ntypeargs=0 (openai.internal._openai_prune_nulls) - - 736 99 load_var 14 (tools) - - 734 100 call 1018 ntypeargs=0 (openai.internal._openai_restore_tool_schemas) - 101 store_var 26 (pruned) - - 739 102 load_var 5 (prompt) - 103 call 1025 ntypeargs=0 (openai.internal.openai_prompt_metadata) - 104 store_var 28 (_52) - 105 load_var2 26 28 - 106 call 1027 ntypeargs=0 (openai.internal._openai_apply_message_metadata) - - 740 107 load_var 1 (c) - 108 load_field 11 (request_body) - - 738 109 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 110 store_var 27 (body) - - 744 111 load_var 1 (c) - 112 call 1035 ntypeargs=0 (openai.internal._openai_url) - 113 store_var 29 (_55) - - 745 114 load_var 1 (c) - 115 call 1034 ntypeargs=0 (openai.internal._openai_headers) - 116 store_var 30 (_56) - - 746 117 load_var 27 (body) - 118 call 351 ntypeargs=0 (baml.json.stringify) - 119 store_var 31 (_57) - - 742 120 load_const 11 ("POST") - 121 load_var2 29 30 - 122 load_var 31 (_57) - 123 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 124 store_var 4 (_0) - 125 load_var 4 (_0) - 126 return -} - -function openai.internal._openai_response_failure(resp: openai.internal.OaResponse) -> ai.errors.Failure { - 805 0 load_var 1 (resp) - 1 load_field 6 (error) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +21 (to 27) - - 809 7 load_var 1 (resp) - 8 load_field 2 (status) - 9 store_var_load_var 5 (_10) - 10 load_const 1 (null) - 11 cmp_op == - 12 pop_jump_if_false +3 (to 15) - 13 load_const 2 ("failed") - 14 store_var 5 (_10) - 15 load_type 3 - 16 load_var 5 (_10) - 17 call 138 ntypeargs=1 (baml.String.from) - 18 store_var 4 (_8) - 19 load_const 1 (null) - 20 load_const 4 ("the response ended with status ") - 21 load_var 4 (_8) - 22 bin_op + - 23 load_const 1 (null) - 24 init_instance 0 (openai.internal.OaErrorBody .code, .message, .type) - - 808 25 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 26 jump +4 (to 30) - - 805 27 load_var 2 (_3) - 28 store_var_load_var 3 (err) - - 806 29 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 30 return -} - -function openai.internal._openai_restore_tool_schemas(body: baml.json.json, tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null) -> baml.json.json { - 250 0 load_var 2 (tools) - 1 store_var_load_var 4 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +4 (to 8) - 5 load_type 1 - 6 alloc_array 0 - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 store_var 3 (list) - - 251 10 load_var 3 (list) - 11 container_len - 12 store_var 5 (_7) - 13 load_var 5 (_7) - 14 load_const 2 (0) - 15 cmp_int_op == - 16 pop_jump_if_false +2 (to 18) - 17 jump +68 (to 85) - - 254 18 load_var 1 (body) - 19 store_var 6 (_8) - 20 load_var 6 (_8) - 21 narrow_bind 3 6 - 22 pop_jump_if_false +61 (to 83) - 23 load_var 6 (_8) - 24 store_var 7 (object) - - 256 25 load_type 4 - 26 load_type 5 - 27 load_var 7 (object) - 28 load_const 6 ("tools") - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var 8 (_13) - 31 load_var 8 (_13) - 32 narrow_bind 7 8 - 33 pop_jump_if_false +50 (to 83) - 34 load_var 8 (_13) - 35 store_var 9 (wire) - - 258 36 load_const 2 (0) - 37 store_var 10 (index) - - 259 38 load_var 3 (list) - 39 load_type 8 - 40 load_const 9 ("iter") - 41 virtual_call nargs=1 ntypeargs=0 - 42 store_var 11 (_17) - 43 load_var 11 (_17) - 44 load_type 10 - 45 load_const 11 ("next") - 46 virtual_call nargs=1 ntypeargs=0 - 47 store_var 12 (_18) - 48 load_var 12 (_18) - 49 is_type 12 - 50 pop_jump_if_false +2 (to 52) - 51 jump +32 (to 83) - 52 load_var 12 (_18) - 53 store_var 13 (tool) - - 260 54 load_var 13 (tool) - 55 store_var 14 (_22) - 56 load_var 14 (_22) - 57 narrow_bind 13 14 - 58 pop_jump_if_false +20 (to 78) - 59 load_var 14 (_22) - 60 store_var 15 (fn) - - 262 61 load_type 5 - 62 load_var2 9 10 - 63 call 3 ntypeargs=1 (baml.Array.at) - 64 store_var 16 (_27) - 65 load_var 16 (_27) - 66 narrow_bind 3 16 - 67 pop_jump_if_false +11 (to 78) - 68 load_var 16 (_27) - 69 store_var 17 (entry) - - 264 70 load_type 4 - 71 load_type 5 - 72 load_var 17 (entry) - 73 load_const 14 ("parameters") - 74 load_var 15 (fn) - 75 load_field 3 (parameters) - 76 call 37 ntypeargs=2 (baml.Map.set) - 77 pop 1 - - 273 78 load_var 10 (index) - 79 load_const 15 (1) - 80 add_int - 81 store_var 10 (index) - - 259 82 jump -39 (to 43) - - 283 83 load_var 1 (body) - 84 jump +2 (to 86) - - 252 85 load_var 1 (body) - 86 return -} - -function openai.internal._openai_sse_failure(error: unknown) -> ai.errors.Failure { - 1121 0 load_var 1 (error) - 1 store_var 3 (_3) - 2 load_var 3 (_3) - 3 narrow_bind 0 3 - 4 pop_jump_if_false +2 (to 6) - 5 jump +6 (to 11) - - 1123 6 load_type 1 - 7 load_var 1 (error) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 2 (text) - 10 jump +6 (to 16) - - 1121 11 load_var 3 (_3) - 12 store_var 4 (io) - - 1122 13 load_var 4 (io) - 14 load_field 0 (message) - 15 store_var 2 (text) - - 1125 16 load_const 2 ("SSE request failed with status ") - 17 store_var 5 (marker) - - 1126 18 load_var2 2 5 - 19 call 155 ntypeargs=0 (baml.String.index_of) - 20 store_var 6 (_9) - 21 load_var 6 (_9) - 22 narrow_bind 3 6 - 23 pop_jump_if_false +43 (to 66) - 24 load_var 6 (_9) - 25 store_var 7 (at) - - 1127 26 load_var 7 (at) - 27 store_var 10 (_13) - 28 load_var 5 (marker) - 29 call 139 ntypeargs=0 (baml.String.length) - 30 load_var 10 (_13) - 31 add_int - 32 store_var 9 (_12) - 33 load_var 2 (text) - 34 call 139 ntypeargs=0 (baml.String.length) - 35 store_var 11 (_15) - 36 load_var2 2 9 - 37 load_var 11 (_15) - 38 call 153 ntypeargs=0 (baml.String.slice) - 39 store_var 8 (rest) - - 1128 40 load_var 8 (rest) - 41 load_const 4 (":") - 42 call 155 ntypeargs=0 (baml.String.index_of) - 43 store_var 12 (_17) - 44 load_var 12 (_17) - 45 narrow_bind 3 12 - 46 pop_jump_if_false +20 (to 66) - 47 load_var 12 (_17) - 48 store_var 13 (separator) - - 1129 49 load_var 8 (rest) - 50 load_const 3 (0) - 51 load_var 13 (separator) - 52 call 153 ntypeargs=0 (baml.String.slice) - 53 call 144 ntypeargs=0 (baml.String.trim) - 54 call 81 ntypeargs=0 (baml.Int.parse) - 55 store_var 14 (code) - 56 jump +5 (to 61) - 57 load_var 15 (e) - 58 throw_if_panic - - 1130 59 load_const 3 (0) - 60 store_var 14 (code) - - 1132 61 load_var 14 (code) - 62 load_const 3 (0) - 63 cmp_int_op > - 64 pop_jump_if_false +2 (to 66) - 65 jump +12 (to 77) - - 1143 66 load_type 5 - 67 load_var 2 (text) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 20 (_33) - - 1141 70 load_const 6 ("openai") - - 1143 71 load_const 7 ("transport failed before a response arrived: ") - 72 load_var 20 (_33) - 73 bin_op + - 74 load_const 8 (null) - 75 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) - 76 jump +19 (to 95) - - 1135 77 load_var 14 (code) - 78 store_var 16 (_26) - - 1136 79 load_var 13 (separator) - 80 load_const 9 (1) - 81 add_int - 82 store_var 18 (_29) - 83 load_var 8 (rest) - 84 call 139 ntypeargs=0 (baml.String.length) - 85 store_var 19 (_31) - 86 load_var2 8 18 - 87 load_var 19 (_31) - 88 call 153 ntypeargs=0 (baml.String.slice) - 89 call 144 ntypeargs=0 (baml.String.trim) - 90 store_var 17 (_27) - - 1133 91 load_const 10 ("openai") - 92 load_var2 16 17 - 93 load_const 11 () - 94 call 977 ntypeargs=0 (ai.errors.classify_http) - 95 return -} - -function openai.internal._openai_stream_events(event: openai.internal.OaStreamEvent, sse_name: string | null, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - 1017 0 load_type 0 - 1 alloc_array 0 - 2 store_var 5 (out) - - 1018 3 load_var 1 (event) - 4 load_field 0 (type) - 5 store_var_load_var 8 (_8) - 6 load_const 1 (null) - 7 cmp_op == - 8 pop_jump_if_false +3 (to 11) - 9 load_var 2 (sse_name) - 10 store_var 8 (_8) - 11 load_var 8 (_8) - 12 store_var_load_var 7 (_6) - 13 load_const 1 (null) - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - 16 load_const 2 ("") - 17 store_var 7 (_6) - 18 load_var 7 (_6) - 19 store_var_load_var 6 (kind) - - 1021 20 load_const 3 ("response.failed") - 21 cmp_op != - 22 jump_if_false +5 (to 27) - 23 pop 1 - 24 load_var 6 (kind) - 25 load_const 4 ("error") - 26 cmp_op != - 27 pop_jump_if_false +8 (to 35) - - 1022 28 load_var 1 (event) - 29 load_field 11 (error) - 30 store_var 9 (_17) - 31 load_var 9 (_17) - 32 narrow_bind 5 9 - 33 pop_jump_if_false +2 (to 35) - 34 jump +306 (to 340) - - 1026 35 load_var 6 (kind) - 36 load_const 6 ("response.created") - 37 cmp_op == - 38 pop_jump_if_false +2 (to 40) - 39 jump +286 (to 325) - 40 load_var 6 (kind) - 41 load_const 7 ("response.in_progress") - 42 cmp_op == - 43 pop_jump_if_false +2 (to 45) - 44 jump +269 (to 313) - 45 load_var 6 (kind) - 46 load_const 8 ("response.output_text.delta") - 47 cmp_op == - 48 pop_jump_if_false +2 (to 50) - 49 jump +238 (to 287) - 50 load_var 6 (kind) - 51 load_const 9 ("response.output_text.done") - 52 cmp_op == - 53 pop_jump_if_false +2 (to 55) - 54 jump +193 (to 247) - 55 load_var 6 (kind) - 56 load_const 10 ("response.function_call_arguments.delta") - 57 cmp_op == - 58 pop_jump_if_false +2 (to 60) - 59 jump +154 (to 213) - 60 load_var 6 (kind) - 61 load_const 11 ("response.function_call_arguments.done") - 62 cmp_op == - 63 pop_jump_if_false +2 (to 65) - 64 jump +128 (to 192) - 65 load_var 6 (kind) - 66 load_const 12 ("response.failed") - 67 cmp_op == - 68 pop_jump_if_false +2 (to 70) - 69 jump +120 (to 189) - 70 load_var 6 (kind) - 71 load_const 13 ("error") - 72 cmp_op == - 73 pop_jump_if_false +2 (to 75) - 74 jump +112 (to 186) - 75 load_var 6 (kind) - 76 load_const 14 ("response.completed") - 77 cmp_op == - 78 pop_jump_if_false +2 (to 80) - 79 jump +56 (to 135) - 80 load_var 6 (kind) - 81 load_const 15 ("response.incomplete") - 82 cmp_op == - 83 pop_jump_if_false +253 (to 336) - - 1078 84 load_var 1 (event) - 85 load_field 8 (response) - 86 store_var 38 (_122) - 87 load_var 38 (_122) - 88 narrow_bind 16 38 - 89 pop_jump_if_false +40 (to 129) - 90 load_var 38 (_122) - 91 store_var_load_var 39 (final_response) - - 1079 92 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 93 store_var 40 (turn) - - 1082 94 load_var 40 (turn) - 95 load_field 1 (stop_reason) - 96 store_var 41 (_128) - - 1083 97 load_var 40 (turn) - 98 load_field 2 (usage) - 99 load_const 1 (null) - 100 cmp_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +6 (to 108) - 103 load_var 40 (turn) - 104 load_field 2 (usage) - 105 load_field 0 (0) - 106 store_var 42 (_129) - 107 jump +3 (to 110) - 108 load_const 1 (null) - 109 store_var 42 (_129) - - 1084 110 load_var 40 (turn) - 111 load_field 2 (usage) - 112 load_const 1 (null) - 113 cmp_op == - 114 pop_jump_if_false +2 (to 116) - 115 jump +6 (to 121) - 116 load_var 40 (turn) - 117 load_field 2 (usage) - 118 load_field 1 (1) - 119 store_var 43 (_133) - 120 jump +3 (to 123) - 121 load_const 1 (null) - 122 store_var 43 (_133) - - 1080 123 load_type 0 - 124 load_var2 5 41 - - 1081 125 load_var2 42 43 - 126 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1080 127 call 4 ntypeargs=1 (baml.Array.push) - 128 pop 1 - - 1088 129 load_type 0 - 130 load_var 5 (out) - 131 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 132 call 4 ntypeargs=1 (baml.Array.push) - 133 pop 1 - 134 jump +202 (to 336) - - 1078 135 load_var 1 (event) - 136 load_field 8 (response) - 137 store_var 32 (_101) - 138 load_var 32 (_101) - 139 narrow_bind 16 32 - 140 pop_jump_if_false +40 (to 180) - 141 load_var 32 (_101) - 142 store_var_load_var 33 (final_response) - - 1079 143 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 144 store_var 34 (turn) - - 1082 145 load_var 34 (turn) - 146 load_field 1 (stop_reason) - 147 store_var 35 (_107) - - 1083 148 load_var 34 (turn) - 149 load_field 2 (usage) - 150 load_const 1 (null) - 151 cmp_op == - 152 pop_jump_if_false +2 (to 154) - 153 jump +6 (to 159) - 154 load_var 34 (turn) - 155 load_field 2 (usage) - 156 load_field 0 (0) - 157 store_var 36 (_108) - 158 jump +3 (to 161) - 159 load_const 1 (null) - 160 store_var 36 (_108) - - 1084 161 load_var 34 (turn) - 162 load_field 2 (usage) - 163 load_const 1 (null) - 164 cmp_op == - 165 pop_jump_if_false +2 (to 167) - 166 jump +6 (to 172) - 167 load_var 34 (turn) - 168 load_field 2 (usage) - 169 load_field 1 (1) - 170 store_var 37 (_112) - 171 jump +3 (to 174) - 172 load_const 1 (null) - 173 store_var 37 (_112) - - 1080 174 load_type 0 - 175 load_var2 5 35 - - 1081 176 load_var2 36 37 - 177 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) - - 1080 178 call 4 ntypeargs=1 (baml.Array.push) - 179 pop 1 - - 1088 180 load_type 0 - 181 load_var 5 (out) - 182 alloc_instance 410 ntypeargs=0 (ai.stream.TurnDone) - 183 call 4 ntypeargs=1 (baml.Array.push) - 184 pop 1 - 185 jump +151 (to 336) - - 1076 186 load_var 1 (event) - 187 call 1046 ntypeargs=0 (openai.internal._openai_stream_failure) - 188 throw - 189 load_var 1 (event) - 190 call 1046 ntypeargs=0 (openai.internal._openai_stream_failure) - 191 throw - - 1071 192 load_var 1 (event) - 193 load_field 3 (arguments) - 194 store_var 28 (_87) - 195 load_var 28 (_87) - 196 narrow_bind 17 28 - 197 pop_jump_if_false +139 (to 336) - 198 load_var 28 (_87) - 199 store_var 29 (full) - - 1072 200 load_var 3 (state) - 201 load_field 2 (call_arguments) - 202 store_var 30 (_90) - 203 load_var 1 (event) - 204 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 205 store_var 31 (_91) - 206 load_type 18 - 207 load_type 18 - 208 load_var2 30 31 - 209 load_var 29 (full) - 210 call 37 ntypeargs=2 (baml.Map.set) - 211 pop 1 - 212 jump +124 (to 336) - - 1061 213 load_var 1 (event) - 214 load_field 1 (delta) - 215 store_var 23 (_67) - 216 load_var 23 (_67) - 217 narrow_bind 17 23 - 218 pop_jump_if_false +118 (to 336) - 219 load_var 23 (_67) - 220 store_var 24 (delta) - - 1062 221 load_var 1 (event) - 222 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 223 store_var 25 (key) - - 1063 224 load_var 3 (state) - 225 load_field 2 (call_arguments) - 226 store_var 26 (_71) - - 1065 227 load_type 18 - 228 load_type 18 - 229 load_var 3 (state) - 230 load_field 2 (call_arguments) - 231 load_var 25 (key) - 232 call 38 ntypeargs=2 (baml.Map.get) - 233 store_var_load_var 27 (_75) - 234 load_const 1 (null) - 235 cmp_op == - 236 pop_jump_if_false +3 (to 239) - 237 load_const 19 ("") - 238 store_var 27 (_75) - - 1063 239 load_type 18 - 240 load_type 18 - 241 load_var2 26 25 - - 1065 242 load_var2 27 24 - 243 bin_op + - - 1063 244 call 37 ntypeargs=2 (baml.Map.set) - 245 pop 1 - 246 jump +90 (to 336) - - 1045 247 load_var 1 (event) - 248 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 249 store_var 19 (key) - - 1046 250 load_type 18 - 251 load_type 20 - 252 load_var 3 (state) - 253 load_field 1 (text_started) - 254 load_var 19 (key) - 255 call 38 ntypeargs=2 (baml.Map.get) - 256 store_var_load_var 20 (_46) - 257 load_const 1 (null) - 258 cmp_op == - 259 pop_jump_if_false +3 (to 262) - 260 load_const 21 (false) - 261 store_var 20 (_46) - 262 load_var 20 (_46) - 263 unary_op ! - 264 pop_jump_if_false +72 (to 336) - - 1047 265 load_var 1 (event) - 266 load_field 2 (text) - 267 store_var 21 (_54) - 268 load_var 21 (_54) - 269 narrow_bind 17 21 - 270 pop_jump_if_false +66 (to 336) - 271 load_var 21 (_54) - 272 store_var 22 (full) - - 1048 273 load_type 18 - 274 load_type 20 - 275 load_var 3 (state) - 276 load_field 1 (text_started) - 277 load_var 19 (key) - 278 load_const 22 (true) - 279 call 37 ntypeargs=2 (baml.Map.set) - 280 pop 1 - - 1049 281 load_type 0 - 282 load_var2 5 22 - 283 init_instance 2 (ai.stream.TextDelta .text) - 284 call 4 ntypeargs=1 (baml.Array.push) - 285 pop 1 - 286 jump +50 (to 336) - - 1036 287 load_var 1 (event) - 288 load_field 1 (delta) - 289 store_var 15 (_31) - 290 load_var 15 (_31) - 291 narrow_bind 17 15 - 292 pop_jump_if_false +44 (to 336) - 293 load_var 15 (_31) - 294 store_var 16 (delta) - - 1037 295 load_var 3 (state) - 296 load_field 1 (text_started) - 297 store_var 17 (_34) - 298 load_var 1 (event) - 299 call 1045 ntypeargs=0 (openai.internal._openai_event_key) - 300 store_var 18 (_35) - 301 load_type 18 - 302 load_type 20 - 303 load_var2 17 18 - 304 load_const 22 (true) - 305 call 37 ntypeargs=2 (baml.Map.set) - 306 pop 1 - - 1038 307 load_type 0 - 308 load_var2 5 16 - 309 init_instance 3 (ai.stream.TextDelta .text) - 310 call 4 ntypeargs=1 (baml.Array.push) - 311 pop 1 - 312 jump +24 (to 336) - - 1030 313 load_var 1 (event) - 314 load_field 8 (response) - 315 store_var 13 (_27) - 316 load_var 13 (_27) - 317 narrow_bind 16 13 - 318 pop_jump_if_false +18 (to 336) - 319 load_var 13 (_27) - 320 store_var 14 (started) - - 1031 321 load_var2 3 14 - 322 load_field 1 (model) - 323 store_field 0 (model) - - 1030 324 jump +12 (to 336) - 325 load_var 1 (event) - 326 load_field 8 (response) - 327 store_var 11 (_23) - 328 load_var 11 (_23) - 329 narrow_bind 16 11 - 330 pop_jump_if_false +6 (to 336) - 331 load_var 11 (_23) - 332 store_var 12 (started) - - 1031 333 load_var2 3 12 - 334 load_field 1 (model) - 335 store_field 0 (model) - - 1093 336 load_var 5 (out) - 337 store_var 4 (_0) - 338 load_var 4 (_0) - 339 return - - 1022 340 load_var 9 (_17) - 341 store_var_load_var 10 (nested) - - 1023 342 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 343 throw -} - -function openai.internal._openai_stream_failure(event: openai.internal.OaStreamEvent) -> ai.errors.Failure { - 1002 0 load_var 1 (event) - 1 load_field 8 (response) - 2 store_var 2 (_3) - 3 load_var 2 (_3) - 4 narrow_bind 0 2 - 5 pop_jump_if_false +2 (to 7) - 6 jump +20 (to 26) - - 1005 7 load_var 1 (event) - 8 load_field 11 (error) - 9 store_var 4 (_7) - 10 load_var 4 (_7) - 11 narrow_bind 1 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +9 (to 22) - - 1008 14 load_var 1 (event) - 15 load_field 9 (code) - 16 load_var 1 (event) - 17 load_field 10 (message) - 18 load_const 2 (null) - 19 init_instance 0 (openai.internal.OaErrorBody .code, .message, .type) - 20 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 21 jump +8 (to 29) - - 1005 22 load_var 4 (_7) - 23 store_var_load_var 5 (nested) - - 1006 24 call 1040 ntypeargs=0 (openai.internal._openai_error_failure) - 25 jump +4 (to 29) - - 1002 26 load_var 2 (_3) - 27 store_var_load_var 3 (response) - - 1003 28 call 1041 ntypeargs=0 (openai.internal._openai_response_failure) - 29 return -} - -function openai.internal._openai_text(c: openai.ResponsesClient) -> openai.internal.OaTextParams | null { - 649 0 load_var 1 (c) - 1 load_field 8 (verbosity) - 2 load_const 0 (null) - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 pop_jump_if_false +2 (to 6) - 5 jump +5 (to 10) - - 652 6 load_var 1 (c) - 7 load_field 8 (verbosity) - 8 init_instance 0 (openai.internal.OaTextParams .verbosity) - - 649 9 jump +2 (to 11) - - 650 10 load_const 0 (null) - 11 return -} - -function openai.internal._openai_tool_choice(tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null, wants_image: bool) -> string | openai.internal.OaToolChoiceObject | null { - 631 0 load_var 2 (wants_image) - 1 pop_jump_if_false +2 (to 3) - 2 jump +10 (to 12) - - 634 3 load_var 1 (tools) - 4 load_const 0 (null) - 5 cmp_op == - 6 pop_jump_if_false +2 (to 8) - 7 jump +3 (to 10) - - 636 8 load_const 1 ("auto") - - 634 9 jump +5 (to 14) - - 635 10 load_const 0 (null) - - 634 11 jump +3 (to 14) - - 632 12 load_const 2 ("image_generation") - 13 init_instance 0 (openai.internal.OaToolChoiceObject .type) - 14 return -} - -function openai.internal._openai_tools(toolbox: ai.tools.Toolbox, wants_image: bool) -> (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null { - 608 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (tools) - - 609 3 load_var 1 (toolbox) - 4 call 922 ntypeargs=0 (ai.tools.Toolbox.list) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_6) - 14 load_var 5 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +24 (to 41) - 18 load_var 5 (_6) - 19 store_var 6 (t) - - 613 20 load_var 6 (t) - 21 load_field 0 (name) - 22 store_var 7 (_12) - - 614 23 load_var 6 (t) - 24 load_field 1 (description) - 25 store_var 8 (_13) - - 615 26 load_type 6 - 27 load_var 6 (t) - 28 load_field 2 (input_schema) - 29 call 355 ntypeargs=1 (baml.json.to_json) - 30 store_var 9 (_14) - - 610 31 load_type 0 - 32 load_var 3 (tools) - - 611 33 load_const 7 ("function") - 34 load_var2 7 8 - 35 load_var 9 (_14) - 36 load_const 8 (false) - 37 init_instance 0 (openai.internal.OaFunctionTool .type, .name, .description, .parameters, .strict) - - 610 38 call 4 ntypeargs=1 (baml.Array.push) - 39 pop 1 - 40 jump -31 (to 9) - - 620 41 load_var 2 (wants_image) - 42 pop_jump_if_false +7 (to 49) - - 621 43 load_type 0 - 44 load_var 3 (tools) - 45 load_const 9 ("image_generation") - 46 init_instance 1 (openai.internal.OaBuiltinTool .type) - 47 call 4 ntypeargs=1 (baml.Array.push) - 48 pop 1 - - 623 49 load_var 3 (tools) - 50 container_len - 51 store_var 10 (_22) - 52 load_var 10 (_22) - 53 load_const 10 (0) - 54 cmp_int_op == - 55 pop_jump_if_false +2 (to 57) - 56 jump +3 (to 59) - - 626 57 load_var 3 (tools) - - 623 58 jump +2 (to 60) - - 624 59 load_const 11 (null) - 60 return -} - -function openai.internal._openai_transient_code(code: string) -> bool { - 771 0 load_var 1 (code) - 1 load_const 0 ("server_error") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 jump_if_false +2 (to 5) - 4 jump +5 (to 9) - 5 pop 1 - - 772 6 load_var 1 (code) - 7 load_const 1 ("timeout") - 8 call 147 ntypeargs=0 (baml.String.includes) - - 771 9 jump_if_false +2 (to 11) - 10 jump +5 (to 15) - 11 pop 1 - - 773 12 load_var 1 (code) - 13 load_const 2 ("timed_out") - 14 call 147 ntypeargs=0 (baml.String.includes) - - 771 15 jump_if_false +2 (to 17) - 16 jump +5 (to 21) - 17 pop 1 - - 774 18 load_var 1 (code) - 19 load_const 3 ("overloaded") - 20 call 147 ntypeargs=0 (baml.String.includes) - - 771 21 jump_if_false +2 (to 23) - 22 jump +5 (to 27) - 23 pop 1 - - 775 24 load_var 1 (code) - 25 load_const 4 ("unavailable") - 26 call 147 ntypeargs=0 (baml.String.includes) - - 771 27 jump_if_false +2 (to 29) - 28 jump +5 (to 33) - 29 pop 1 - - 776 30 load_var 1 (code) - 31 load_const 5 ("try_again") - 32 call 147 ntypeargs=0 (baml.String.includes) - 33 return -} - -function openai.internal._openai_url(c: openai.ResponsesClient) -> string { - 670 0 load_var 1 (c) - 1 call 1013 ntypeargs=0 (openai.ResponsesClient.resolved_base_url) - 2 store_var_load_var 3 (_3) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("https://api.openai.com/v1") - 7 store_var 3 (_3) - 8 load_var 3 (_3) - 9 store_var 2 (base) - - 671 10 load_var 2 (base) - 11 load_const 2 ("/") - 12 call 149 ntypeargs=0 (baml.String.ends_with) - 13 pop_jump_if_false +2 (to 15) - 14 jump +4 (to 18) - - 674 15 load_var 2 (base) - 16 store_var 4 (trimmed) - - 671 17 jump +11 (to 28) - - 672 18 load_var 2 (base) - 19 call 139 ntypeargs=0 (baml.String.length) - 20 store_var 5 (_9) - 21 load_var 2 (base) - 22 load_const 3 (0) - 23 load_var 5 (_9) - 24 load_const 4 (1) - 25 sub_int - 26 call 153 ntypeargs=0 (baml.String.slice) - 27 store_var 4 (trimmed) - - 676 28 load_type 5 - 29 load_var 4 (trimmed) - 30 call 138 ntypeargs=1 (baml.String.from) - 31 load_const 6 ("/responses") - 32 bin_op + - 33 store_var 6 (url) - - 677 34 load_var 1 (c) - 35 load_field 13 (query_params) - 36 store_var 7 (_15) - 37 load_var 7 (_15) - 38 narrow_bind 7 7 - 39 pop_jump_if_false +65 (to 104) - 40 load_var 7 (_15) - 41 store_var 8 (params) - - 678 42 load_type 5 - 43 alloc_array 0 - 44 store_var 9 (pairs) - - 679 45 load_type 5 - 46 load_type 5 - 47 load_var 8 (params) - 48 call 35 ntypeargs=2 (baml.Map.keys) - 49 load_type 8 - 50 load_const 9 ("iter") - 51 virtual_call nargs=1 ntypeargs=0 - 52 store_var 10 (_21) - 53 load_var 10 (_21) - 54 load_type 10 - 55 load_const 11 ("next") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 11 (_22) - 58 load_var 11 (_22) - 59 is_type 12 - 60 pop_jump_if_false +2 (to 62) - 61 jump +35 (to 96) - 62 load_var 11 (_22) - 63 store_var_load_var 12 (key) - - 681 64 call 1019 ntypeargs=0 (openai.internal._openai_percent_encode) - 65 store_var 14 (_30) - 66 load_type 5 - 67 load_var 14 (_30) - 68 call 138 ntypeargs=1 (baml.String.from) - 69 store_var 13 (_29) - 70 load_type 5 - 71 load_type 5 - 72 load_var2 8 12 - 73 call 38 ntypeargs=2 (baml.Map.get) - 74 store_var_load_var 17 (_36) - 75 load_const 0 (null) - 76 cmp_op == - 77 pop_jump_if_false +3 (to 80) - 78 load_const 13 ("") - 79 store_var 17 (_36) - 80 load_var 17 (_36) - 81 call 1019 ntypeargs=0 (openai.internal._openai_percent_encode) - 82 store_var 16 (_34) - 83 load_type 5 - 84 load_var 16 (_34) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 15 (_33) - - 680 87 load_type 5 - 88 load_var2 9 13 - - 681 89 load_const 14 ("=") - 90 bin_op + - 91 load_var 15 (_33) - 92 bin_op + - - 680 93 call 4 ntypeargs=1 (baml.Array.push) - 94 pop 1 - 95 jump -42 (to 53) - - 684 96 load_var 9 (pairs) - 97 container_len - 98 store_var 18 (_45) - 99 load_var 18 (_45) - 100 load_const 3 (0) - 101 cmp_int_op > - 102 pop_jump_if_false +2 (to 104) - 103 jump +3 (to 106) - - 688 104 load_var 6 (url) - 105 jump +19 (to 124) - - 685 106 load_type 5 - 107 load_var 6 (url) - 108 call 138 ntypeargs=1 (baml.String.from) - 109 store_var 19 (_47) - 110 load_type 5 - 111 load_var 9 (pairs) - 112 load_const 15 ("&") - 113 call 15 ntypeargs=1 (baml.Array.join) - 114 store_var 21 (_51) - 115 load_type 5 - 116 load_var 21 (_51) - 117 call 138 ntypeargs=1 (baml.String.from) - 118 store_var 20 (_50) - 119 load_var 19 (_47) - 120 load_const 16 ("?") - 121 bin_op + - 122 load_var 20 (_50) - 123 bin_op + - 124 return -} - -function openai.internal._openai_wants_image(output_type: type) -> bool { - 604 0 load_var 1 (output_type) - 1 call 985 ntypeargs=0 (ai.internal._media_shape) - 2 load_const 0 (":image") - 3 call 149 ntypeargs=0 (baml.String.ends_with) - 4 return -} - -function openai.internal._reject(provider: string, detail: string) -> ai.errors.InvalidRequest { - 38 0 load_var 1 (provider) - 1 load_const 0 (null) - 2 load_var 2 (detail) - 3 load_const 0 (null) - 4 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 5 store_var 3 (_0) - 6 load_var 3 (_0) - 7 return -} - -function openai.internal.chat_build_request(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> openai.internal.ChatRequest { - 1005 0 load_var 3 (input) - 1 load_field 0 (prompt) - 2 store_var 5 (_6) - 3 load_var 3 (input) - 4 load_field 3 (output_type) - 5 call 932 ntypeargs=0 (ai.wire.render_output_format) - 6 load_var 5 (_6) - 7 call_indirect - - 1006 8 load_var 1 (compat) - 9 call 1115 ntypeargs=0 (openai.internal.chat_lower_prompt) - 10 store_var 6 (messages) - - 1007 11 load_var 3 (input) - 12 load_field 1 (journal) - 13 store_var 7 (_12) - 14 load_var2 1 2 - 15 call 1101 ntypeargs=0 (openai.internal.chat_client_id) - 16 store_var 8 (_13) - 17 load_var2 7 8 - 18 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - - 1008 19 call 1116 ntypeargs=0 (openai.internal.chat_lower_journal) - 20 load_type 0 - 21 load_const 1 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 9 (_16) - 24 load_var 9 (_16) - 25 load_type 2 - 26 load_const 3 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 10 (_17) - 29 load_var 10 (_17) - 30 is_type 4 - 31 pop_jump_if_false +2 (to 33) - 32 jump +8 (to 40) - 33 load_var 10 (_17) - 34 store_var 11 (message) - - 1009 35 load_type 5 - 36 load_var2 6 11 - 37 call 4 ntypeargs=1 (baml.Array.push) - 38 pop 1 - 39 jump -15 (to 24) - - 1015 40 load_var 1 (compat) - 41 load_field 9 (max_tokens_key) - 42 load_const 6 ("max_completion_tokens") - 43 cmp_op == - 44 pop_jump_if_false +2 (to 46) - 45 jump +5 (to 50) - - 1018 46 load_var 2 (params) - 47 load_field 3 (max_tokens) - 48 store_var 12 (max_tokens) - - 1015 49 jump +3 (to 52) - - 1016 50 load_const 7 (null) - 51 store_var 12 (max_tokens) - - 1020 52 load_var 1 (compat) - 53 load_field 9 (max_tokens_key) - 54 load_const 8 ("max_completion_tokens") - 55 cmp_op == - 56 pop_jump_if_false +2 (to 58) - 57 jump +5 (to 62) - - 1023 58 load_var 2 (params) - 59 load_field 4 (max_completion_tokens) - 60 store_var 13 (max_completion_tokens) - - 1020 61 jump +12 (to 73) - - 1021 62 load_var 2 (params) - 63 load_field 4 (max_completion_tokens) - 64 store_var_load_var 14 (_30) - 65 load_const 7 (null) - 66 cmp_op == - 67 pop_jump_if_false +4 (to 71) - 68 load_var 2 (params) - 69 load_field 3 (max_tokens) - 70 store_var 14 (_30) - 71 load_var 14 (_30) - 72 store_var 13 (max_completion_tokens) - - 1030 73 load_var 12 (max_tokens) - 74 load_const 7 (null) - 75 call 672 ntypeargs=0 (baml.ops.equals_equals) - 76 jump_if_false +5 (to 81) - 77 pop 1 - - 1031 78 load_var 13 (max_completion_tokens) - 79 load_const 7 (null) - 80 call 672 ntypeargs=0 (baml.ops.equals_equals) - - 1030 81 jump_if_false +7 (to 88) - 82 pop 1 - - 1032 83 load_var 2 (params) - 84 load_field 10 (request_body) - 85 load_const 9 ("max_tokens") - 86 call 1120 ntypeargs=0 (openai.internal._chat_body_mentions) - 87 unary_op ! - - 1030 88 jump_if_false +7 (to 95) - 89 pop 1 - - 1033 90 load_var 2 (params) - 91 load_field 10 (request_body) - 92 load_const 10 ("max_completion_tokens") - 93 call 1120 ntypeargs=0 (openai.internal._chat_body_mentions) - 94 unary_op ! - - 1029 95 pop_jump_if_false +20 (to 115) - - 1035 96 load_var 1 (compat) - 97 load_field 10 (default_max_tokens) - 98 store_var 15 (_44) - 99 load_var 15 (_44) - 100 narrow_bind 11 15 - 101 pop_jump_if_false +14 (to 115) - 102 load_var 15 (_44) - 103 store_var 16 (floor) - - 1036 104 load_var 1 (compat) - 105 load_field 9 (max_tokens_key) - 106 load_const 12 ("max_completion_tokens") - 107 cmp_op == - 108 pop_jump_if_false +2 (to 110) - 109 jump +4 (to 113) - - 1039 110 load_var 16 (floor) - 111 store_var 12 (max_tokens) - - 1036 112 jump +3 (to 115) - - 1037 113 load_var 16 (floor) - 114 store_var 13 (max_completion_tokens) - - 1044 115 load_var 3 (input) - 116 load_field 2 (toolbox) - 117 call 1124 ntypeargs=0 (openai.internal._chat_tools) - 118 store_var 17 (tools) - - 1045 119 load_var 17 (tools) - 120 load_const 7 (null) - 121 call 672 ntypeargs=0 (baml.ops.equals_equals) - 122 pop_jump_if_false +2 (to 124) - 123 jump +4 (to 127) - - 1048 124 load_const 13 ("auto") - 125 store_var 18 (tool_choice) - - 1045 126 jump +3 (to 129) - - 1046 127 load_const 7 (null) - 128 store_var 18 (tool_choice) - - 1050 129 load_var 4 (stream) - 130 pop_jump_if_false +2 (to 132) - 131 jump +4 (to 135) - - 1053 132 load_const 7 (null) - 133 store_var 19 (stream_flag) - - 1050 134 jump +3 (to 137) - - 1051 135 load_const 14 (true) - 136 store_var 19 (stream_flag) - - 1055 137 load_var 4 (stream) - 138 jump_if_false +4 (to 142) - 139 pop 1 - 140 load_var 1 (compat) - 141 load_field 8 (send_stream_options) - 142 pop_jump_if_false +2 (to 144) - 143 jump +4 (to 147) - - 1058 144 load_const 7 (null) - 145 store_var 20 (stream_options) - - 1055 146 jump +4 (to 150) - - 1056 147 load_const 14 (true) - 148 init_instance 0 (openai.internal.ChatStreamOptions .include_usage) - 149 store_var 20 (stream_options) - - 1062 150 load_var 2 (params) - 151 load_field 0 (model) - - 1063 152 load_var2 6 2 - - 1064 153 load_field 2 (temperature) - - 1065 154 load_var2 12 13 - - 1067 155 load_var 2 (params) - 156 load_field 5 (top_p) - - 1068 157 load_var 2 (params) - 158 load_field 6 (stop) - - 1069 159 load_var 2 (params) - 160 load_field 7 (seed) - - 1070 161 load_var2 17 18 - - 1072 162 load_var2 19 20 - - 1073 163 init_instance 1 (openai.internal.ChatRequest .model, .messages, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .tools, .tool_choice, .stream, .stream_options) - 164 return -} - -function openai.internal.chat_client_id(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - 196 0 load_type 0 - 1 load_var 1 (compat) - 2 load_field 0 (provider) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 4 (_4) - 5 load_type 0 - 6 load_var 2 (params) - 7 load_field 0 (model) - 8 call 138 ntypeargs=1 (baml.String.from) - 9 store_var 5 (_7) - 10 load_var 4 (_4) - 11 load_const 1 ("/") - 12 bin_op + - 13 load_var 5 (_7) - 14 bin_op + - 15 store_var 3 (_0) - 16 load_var 3 (_0) - 17 return -} - -function openai.internal.chat_invoke(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.ModelTurn { - 1328 0 load_var2 1 2 - 1 load_var 3 (input) - 2 load_const 0 (false) - 3 call 1127 ntypeargs=0 (openai.internal.chat_render) - 4 store_var 4 (request) - - 1331 5 load_var 1 (compat) - 6 load_field 0 (provider) - 7 store_var 5 (_6) - - 1332 8 load_var 2 (params) - 9 load_field 10 (request_body) - 10 call 1109 ntypeargs=0 (openai.internal._chat_audio_output_mime) - 11 store_var 6 (_7) - - 1330 12 load_var2 4 5 - 13 load_var 6 (_7) - - 1329 14 call 1133 ntypeargs=0 (openai.internal._chat_send) - 15 return -} - -function openai.internal.chat_invoke_stream(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 1539 3 load_var2 1 2 - 4 load_var 3 (input) - 5 load_const 0 (true) - 6 call 1127 ntypeargs=0 (openai.internal.chat_render) - 7 store_var 4 (request) - - 1540 8 load_var 1 (compat) - 9 load_field 0 (provider) - 10 call 1135 ntypeargs=0 (openai.internal.ChatStreamDecoder.new) - 11 store_deref 5 - - 1541 12 load_var 4 (request) - 13 sys_op 252 (baml.http.fetch_sse) - 14 jump +13 (to 27) - 15 load_var 6 (e) - 16 throw_if_panic - - 1542 17 load_var 1 (compat) - 18 load_field 0 (provider) - 19 store_var 7 (_11) - 20 load_type 1 - 21 load_var 6 (e) - 22 call 138 ntypeargs=1 (baml.String.from) - 23 store_var 8 (_12) - 24 load_var2 7 8 - 25 call 1139 ntypeargs=0 (openai.internal._chat_stream_failure) - 26 throw - - 1551 27 load_var 5 (decoder) - 28 make_closure 3044 1 - - 1552 29 load_var 1 (compat) - 30 load_field 0 (provider) - - 1549 31 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 32 return -} - -function openai.internal.chat_lower_journal(j: ai.Journal) -> openai.internal.ChatMessage[] { - 721 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 722 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +194 (to 211) - 18 load_var 5 (_5) - 19 store_var 6 (event) - - 723 20 load_var 6 (event) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +173 (to 198) - 26 load_var 6 (event) - 27 store_var 9 (_15) - 28 load_var 9 (_15) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +50 (to 81) - 32 load_var 6 (event) - 33 store_var 28 (_62) - 34 load_var 28 (_62) - 35 narrow_bind 8 28 - 36 pop_jump_if_false +2 (to 38) - 37 jump +30 (to 67) - 38 load_var 6 (event) - 39 store_var 30 (_69) - 40 load_var 30 (_69) - 41 narrow_bind 9 30 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 30 (_69) - 44 store_var_load_var 31 (failed) - - 796 45 load_field 1 (message) - 46 load_const 10 ("error") - 47 load_type 11 - 48 load_type 11 - 49 alloc_map 1 - 50 store_var 32 (err) - - 800 51 load_type 12 - 52 load_var 32 (err) - 53 call 355 ntypeargs=1 (baml.json.to_json) - 54 call 351 ntypeargs=0 (baml.json.stringify) - 55 store_var 33 (_75) - - 797 56 load_type 0 - 57 load_var 3 (out) - - 798 58 load_const 13 ("tool") - 59 load_var 33 (_75) - 60 load_const 14 (null) - - 802 61 load_var 31 (failed) - 62 load_field 0 (id) - 63 init_instance 0 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 797 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - 66 jump -57 (to 9) - - 723 67 load_var 28 (_62) - 68 store_var 29 (completed) - - 785 69 load_type 0 - 70 load_var 3 (out) - - 786 71 load_const 15 ("tool") - - 788 72 load_var 29 (completed) - 73 load_field 1 (output) - 74 load_const 14 (null) - - 790 75 load_var 29 (completed) - 76 load_field 0 (id) - 77 init_instance 1 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 785 78 call 4 ntypeargs=1 (baml.Array.push) - 79 pop 1 - 80 jump -71 (to 9) - - 723 81 load_var 9 (_15) - 82 store_var 10 (assistant) - - 736 83 load_const 16 ("") - 84 store_var 11 (text) - - 737 85 load_type 17 - 86 alloc_array 0 - 87 store_var 12 (calls) - - 738 88 load_var 10 (assistant) - 89 load_field 0 (content) - 90 load_type 18 - 91 load_const 19 ("iter") - 92 virtual_call nargs=1 ntypeargs=0 - 93 store_var 13 (_20) - 94 load_var 13 (_20) - 95 load_type 20 - 96 load_const 21 ("next") - 97 virtual_call nargs=1 ntypeargs=0 - 98 store_var 14 (_21) - 99 load_var 14 (_21) - 100 is_type 5 - 101 pop_jump_if_false +2 (to 103) - 102 jump +52 (to 154) - 103 load_var 14 (_21) - 104 store_var 15 (block) - - 739 105 load_var 15 (block) - 106 store_var 16 (_25) - 107 load_var 16 (_25) - 108 narrow_bind 22 16 - 109 pop_jump_if_false +2 (to 111) - 110 jump +29 (to 139) - 111 load_var 15 (block) - 112 store_var 20 (_33) - 113 load_var 20 (_33) - 114 narrow_bind 23 20 - 115 pop_jump_if_false -21 (to 94) - 116 load_var 20 (_33) - 117 store_var 21 (use) - - 747 118 load_var 21 (use) - 119 load_field 0 (id) - 120 store_var 22 (_37) - - 750 121 load_var 21 (use) - 122 load_field 1 (name) - 123 store_var 23 (_39) - - 751 124 load_type 24 - 125 load_var 21 (use) - 126 load_field 2 (args) - 127 call 355 ntypeargs=1 (baml.json.to_json) - 128 call 351 ntypeargs=0 (baml.json.stringify) - 129 store_var 24 (_40) - - 745 130 load_type 17 - 131 load_var2 12 22 - - 746 132 load_const 25 ("function") - - 749 133 load_var2 23 24 - 134 init_instance 2 (openai.internal.ChatToolCallFunction .name, .arguments) - 135 init_instance 3 (openai.internal.ChatToolCall .id, .type, .fn) - - 745 136 call 4 ntypeargs=1 (baml.Array.push) - 137 pop 1 - 138 jump -44 (to 94) - - 739 139 load_var 16 (_25) - 140 store_var 17 (t) - - 741 141 load_type 11 - 142 load_var 11 (text) - 143 call 138 ntypeargs=1 (baml.String.from) - 144 store_var 18 (_27) - 145 load_type 11 - 146 load_var 17 (t) - 147 load_field 0 (text) - 148 call 138 ntypeargs=1 (baml.String.from) - 149 store_var 19 (_30) - 150 load_var2 18 19 - 151 bin_op + - 152 store_var 11 (text) - - 739 153 jump -59 (to 94) - - 762 154 load_var 11 (text) - 155 load_const 26 ("") - 156 cmp_op == - 157 pop_jump_if_false +2 (to 159) - 158 jump +4 (to 162) - - 765 159 load_var 11 (text) - 160 store_var 25 (content) - - 762 161 jump +3 (to 164) - - 763 162 load_const 14 (null) - 163 store_var 25 (content) - - 767 164 load_var 12 (calls) - 165 container_len - 166 store_var 27 (_50) - 167 load_var 27 (_50) - 168 load_const 27 (0) - 169 cmp_int_op == - 170 pop_jump_if_false +2 (to 172) - 171 jump +4 (to 175) - - 770 172 load_var 12 (calls) - 173 store_var 26 (tool_calls) - - 767 174 jump +3 (to 177) - - 768 175 load_const 14 (null) - 176 store_var 26 (tool_calls) - - 772 177 load_var 25 (content) - 178 load_const 14 (null) - 179 call 672 ntypeargs=0 (baml.ops.equals_equals) - 180 unary_op ! - 181 jump_if_false +2 (to 183) - 182 jump +6 (to 188) - 183 pop 1 - 184 load_var 26 (tool_calls) - 185 load_const 14 (null) - 186 call 672 ntypeargs=0 (baml.ops.equals_equals) - 187 unary_op ! - 188 pop_jump_if_false -179 (to 9) - - 773 189 load_type 0 - 190 load_var 3 (out) - - 774 191 load_const 28 ("assistant") - - 776 192 load_var2 25 26 - - 777 193 load_const 14 (null) - 194 init_instance 4 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 773 195 call 4 ntypeargs=1 (baml.Array.push) - 196 pop 1 - 197 jump -188 (to 9) - - 723 198 load_var 7 (_9) - 199 store_var 8 (user) - - 725 200 load_type 0 - 201 load_var 3 (out) - - 726 202 load_const 29 ("user") - - 728 203 load_var 8 (user) - 204 load_field 0 (content) - 205 load_const 14 (null) - 206 load_const 14 (null) - 207 init_instance 5 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 725 208 call 4 ntypeargs=1 (baml.Array.push) - 209 pop 1 - 210 jump -201 (to 9) - - 810 211 load_var 3 (out) - 212 store_var 2 (_0) - 213 load_var 2 (_0) - 214 return -} - -function openai.internal.chat_lower_prompt(prompt: ai.Prompt, compat: openai.internal.ChatCompat) -> openai.internal.ChatMessage[] { - 670 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (lowered) - - 671 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 5 (_5) - 9 load_var 5 (_5) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 6 (_6) - 14 load_var 6 (_6) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +87 (to 104) - 18 load_var 6 (_6) - 19 store_var 7 (message) - - 672 20 load_var 7 (message) - 21 load_field 0 (role) - 22 store_var_load_var 9 (_11) - 23 load_const 6 ("") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +13 (to 39) - 27 load_var 9 (_11) - 28 load_const 7 ("tool") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +5 (to 36) - - 675 32 load_var 7 (message) - 33 load_field 0 (role) - 34 store_var 8 (role) - - 672 35 jump +7 (to 42) - - 674 36 load_const 8 ("user") - 37 store_var 8 (role) - - 672 38 jump +4 (to 42) - - 673 39 load_var 2 (compat) - 40 load_field 11 (default_role) - 41 store_var 8 (role) - - 677 42 load_var2 7 2 - 43 call 1111 ntypeargs=0 (openai.internal._chat_prompt_parts) - 44 store_var 10 (parts) - - 681 45 load_var2 10 7 - 46 load_field 3 (metadata) - 47 call 1112 ntypeargs=0 (openai.internal._chat_apply_metadata) - 48 pop 1 - - 682 49 load_const 9 (false) - 50 store_var 11 (merged) - - 683 51 load_var 4 (lowered) - 52 container_len - 53 store_var 12 (_22) - 54 load_type 0 - 55 load_var2 4 12 - 56 load_const 10 (1) - 57 sub_int - 58 call 3 ntypeargs=1 (baml.Array.at) - 59 store_var 13 (_24) - 60 load_var 13 (_24) - 61 narrow_bind 11 13 - 62 pop_jump_if_false +32 (to 94) - 63 load_var 13 (_24) - 64 store_var_load_var 14 (last) - - 684 65 load_field 0 (role) - 66 load_var 8 (role) - 67 cmp_op == - 68 pop_jump_if_false +26 (to 94) - - 685 69 load_var 10 (parts) - 70 load_type 12 - 71 load_const 13 ("iter") - 72 virtual_call nargs=1 ntypeargs=0 - 73 store_var 15 (_30) - 74 load_var 15 (_30) - 75 load_type 14 - 76 load_const 15 ("next") - 77 virtual_call nargs=1 ntypeargs=0 - 78 store_var 16 (_31) - 79 load_var 16 (_31) - 80 is_type 5 - 81 pop_jump_if_false +2 (to 83) - 82 jump +10 (to 92) - 83 load_var 16 (_31) - 84 store_var 17 (part) - - 686 85 load_type 16 - 86 load_var 14 (last) - 87 load_field 1 (parts) - 88 load_var 17 (part) - 89 call 4 ntypeargs=1 (baml.Array.push) - 90 pop 1 - 91 jump -17 (to 74) - - 688 92 load_const 17 (true) - 93 store_var 11 (merged) - - 691 94 load_var 11 (merged) - 95 unary_op ! - 96 pop_jump_if_false -87 (to 9) - - 692 97 load_type 0 - 98 load_var2 4 8 - 99 load_var 10 (parts) - 100 init_instance 0 (openai.internal.ChatPromptMessage .role, .parts) - 101 call 4 ntypeargs=1 (baml.Array.push) - 102 pop 1 - 103 jump -94 (to 9) - - 695 104 load_type 18 - 105 alloc_array 0 - 106 store_var 18 (out) - - 696 107 load_var 4 (lowered) - 108 load_type 19 - 109 load_const 20 ("iter") - 110 virtual_call nargs=1 ntypeargs=0 - 111 store_var 19 (_48) - 112 load_var 19 (_48) - 113 load_type 21 - 114 load_const 22 ("next") - 115 virtual_call nargs=1 ntypeargs=0 - 116 store_var 20 (_49) - 117 load_var 20 (_49) - 118 is_type 5 - 119 pop_jump_if_false +2 (to 121) - 120 jump +21 (to 141) - 121 load_var 20 (_49) - 122 store_var 21 (message) - - 699 123 load_var 21 (message) - 124 load_field 0 (role) - 125 store_var 22 (_55) - - 700 126 load_var 21 (message) - 127 load_field 1 (parts) - 128 load_var 2 (compat) - 129 load_field 6 (collapse_text_content) - 130 call 1114 ntypeargs=0 (openai.internal._chat_content) - 131 store_var 23 (_56) - - 697 132 load_type 18 - 133 load_var2 18 22 - - 698 134 load_var 23 (_56) - 135 load_const 23 (null) - 136 load_const 23 (null) - 137 init_instance 1 (openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id) - - 697 138 call 4 ntypeargs=1 (baml.Array.push) - 139 pop 1 - 140 jump -28 (to 112) - - 706 141 load_var 18 (out) - 142 store_var 3 (_0) - 143 load_var 3 (_0) - 144 return -} - -function openai.internal.chat_parse(response: openai.internal.CcResponse, provider: string, raw: string, audio_mime: string) -> ai.ModelTurn { - 0 load_var 4 (audio_mime) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 1179 4 load_const 1 ("audio/wav") - 5 store_var 4 (audio_mime) - - 1181 6 load_var 1 (response) - 7 load_field 2 (choices) - 8 store_var_load_var 6 (_7) - 9 load_const 2 (null) - 10 cmp_op == - 11 pop_jump_if_false +4 (to 15) - 12 load_type 3 - 13 alloc_array 0 - 14 store_var 6 (_7) - 15 load_var 6 (_7) - 16 store_var 5 (choices) - - 1182 17 load_type 3 - 18 load_var 5 (choices) - 19 load_const 4 (0) - 20 call 3 ntypeargs=1 (baml.Array.at) - 21 store_var 8 (_13) - 22 load_var 8 (_13) - 23 narrow_bind 5 8 - 24 pop_jump_if_false +2 (to 26) - 25 jump +4 (to 29) - - 1184 26 load_var2 2 3 - 27 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 28 throw - - 1182 29 load_var 8 (_13) - 30 store_var 9 (first) - - 1183 31 load_var 9 (first) - 32 store_var 7 (choice) - - 1186 33 load_var 7 (choice) - 34 load_field 1 (message) - 35 store_var 11 (_18) - 36 load_var 11 (_18) - 37 narrow_bind 6 11 - 38 pop_jump_if_false +2 (to 40) - 39 jump +4 (to 43) - - 1188 40 load_var2 2 3 - 41 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) - 42 throw - - 1186 43 load_var 11 (_18) - 44 store_var 12 (m) - - 1187 45 load_var 12 (m) - 46 store_var 10 (message) - - 1191 47 load_type 7 - 48 alloc_array 0 - 49 store_var 13 (content) - - 1192 50 load_var 10 (message) - 51 load_field 4 (reasoning_content) - 52 store_var 14 (_23) - 53 load_var 14 (_23) - 54 narrow_bind 8 14 - 55 pop_jump_if_false +11 (to 66) - 56 load_var 14 (_23) - 57 store_var_load_var 15 (reasoning) - - 1193 58 load_const 9 ("") - 59 cmp_op != - 60 pop_jump_if_false +6 (to 66) - - 1194 61 load_type 7 - 62 load_var2 13 15 - 63 init_instance 2 (ai.content.Reasoning .summary) - 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - - 1197 66 load_var 10 (message) - 67 load_field 1 (content) - 68 store_var 16 (_31) - 69 load_var 16 (_31) - 70 store_var 17 (_32) - 71 load_var 17 (_32) - 72 narrow_bind 8 17 - 73 pop_jump_if_false +2 (to 75) - 74 jump +74 (to 148) - 75 load_var 16 (_31) - 76 store_var 19 (_38) - 77 load_var 19 (_38) - 78 narrow_bind 10 19 - 79 pop_jump_if_false +76 (to 155) - 80 load_var 19 (_38) - 81 store_var_load_var 20 (parts) - - 1203 82 load_type 11 - 83 load_const 12 ("iter") - 84 virtual_call nargs=1 ntypeargs=0 - 85 store_var 21 (_41) - 86 load_var 21 (_41) - 87 load_type 13 - 88 load_const 14 ("next") - 89 virtual_call nargs=1 ntypeargs=0 - 90 store_var 22 (_42) - 91 load_var 22 (_42) - 92 is_type 15 - 93 pop_jump_if_false +2 (to 95) - 94 jump +61 (to 155) - 95 load_var 22 (_42) - 96 store_var_load_var 23 (part) - - 1204 97 load_field 0 (type) - 98 store_var_load_var 25 (_47) - 99 load_const 2 (null) - 100 cmp_op == - 101 pop_jump_if_false +3 (to 104) - 102 load_const 16 ("") - 103 store_var 25 (_47) - 104 load_var 25 (_47) - 105 store_var_load_var 24 (kind) - - 1205 106 load_const 17 ("image_url") - 107 cmp_op == - 108 pop_jump_if_false +2 (to 110) - 109 jump +15 (to 124) - - 1211 110 load_var 23 (part) - 111 load_field 1 (text) - 112 store_var 29 (_63) - 113 load_var 29 (_63) - 114 narrow_bind 8 29 - 115 pop_jump_if_false -29 (to 86) - 116 load_var 29 (_63) - 117 store_var 30 (text) - - 1212 118 load_type 7 - 119 load_var2 13 30 - 120 init_instance 3 (ai.content.Text .text) - 121 call 4 ntypeargs=1 (baml.Array.push) - 122 pop 1 - 123 jump -37 (to 86) - - 1206 124 load_var 23 (part) - 125 load_field 2 (image_url) - 126 load_const 2 (null) - 127 cmp_op == - 128 pop_jump_if_false +2 (to 130) - 129 jump +5 (to 134) - 130 load_var 23 (part) - 131 load_field 2 (image_url) - 132 load_field 0 (0) - 133 jump +2 (to 135) - 134 load_const 2 (null) - 135 store_var 26 (_56) - 136 load_var 26 (_56) - 137 narrow_bind 8 26 - 138 pop_jump_if_false -52 (to 86) - 139 load_var 26 (_56) - 140 store_var_load_var 27 (url) - - 1207 141 call 1129 ntypeargs=0 (openai.internal._chat_media_block) - 142 store_var 28 (_59) - 143 load_type 7 - 144 load_var2 13 28 - 145 call 4 ntypeargs=1 (baml.Array.push) - 146 pop 1 - 147 jump -61 (to 86) - - 1197 148 load_var 17 (_32) - 149 store_var 18 (text) - - 1199 150 load_type 7 - 151 load_var2 13 18 - 152 init_instance 4 (ai.content.Text .text) - 153 call 4 ntypeargs=1 (baml.Array.push) - 154 pop 1 - - 1222 155 load_var 10 (message) - 156 load_field 2 (images) - 157 store_var_load_var 32 (_70) - 158 load_const 2 (null) - 159 cmp_op == - 160 pop_jump_if_false +4 (to 164) - 161 load_type 18 - 162 alloc_array 0 - 163 store_var 32 (_70) - 164 load_var 32 (_70) - 165 store_var_load_var 31 (images) - - 1223 166 load_type 19 - 167 load_const 20 ("iter") - 168 virtual_call nargs=1 ntypeargs=0 - 169 store_var 33 (_74) - 170 load_var 33 (_74) - 171 load_type 21 - 172 load_const 22 ("next") - 173 virtual_call nargs=1 ntypeargs=0 - 174 store_var 34 (_75) - 175 load_var 34 (_75) - 176 is_type 15 - 177 pop_jump_if_false +2 (to 179) - 178 jump +34 (to 212) - 179 load_var 34 (_75) - 180 store_var_load_var 35 (image) - - 1224 181 load_field 1 (image_url) - 182 load_const 2 (null) - 183 cmp_op == - 184 pop_jump_if_false +2 (to 186) - 185 jump +5 (to 190) - 186 load_var 35 (image) - 187 load_field 1 (image_url) - 188 load_field 0 (0) - 189 jump +2 (to 191) - 190 load_const 2 (null) - 191 store_var_load_var 36 (_80) - 192 load_const 2 (null) - 193 cmp_op == - 194 pop_jump_if_false +4 (to 198) - 195 load_var 35 (image) - 196 load_field 2 (url) - 197 store_var 36 (_80) - 198 load_var 36 (_80) - 199 store_var 37 (_86) - 200 load_var 37 (_86) - 201 narrow_bind 8 37 - 202 pop_jump_if_false -32 (to 170) - 203 load_var 37 (_86) - 204 store_var_load_var 38 (url) - - 1225 205 call 1129 ntypeargs=0 (openai.internal._chat_media_block) - 206 store_var 39 (_89) - 207 load_type 7 - 208 load_var2 13 39 - 209 call 4 ntypeargs=1 (baml.Array.push) - 210 pop 1 - 211 jump -41 (to 170) - - 1230 212 load_var 10 (message) - 213 load_field 3 (audio) - 214 store_var 40 (_93) - 215 load_var 40 (_93) - 216 narrow_bind 23 40 - 217 pop_jump_if_false +40 (to 257) - 218 load_var 40 (_93) - 219 store_var_load_var 41 (audio) - - 1231 220 load_field 2 (transcript) - 221 store_var 42 (_96) - 222 load_var 42 (_96) - 223 narrow_bind 8 42 - 224 pop_jump_if_false +11 (to 235) - 225 load_var 42 (_96) - 226 store_var_load_var 43 (transcript) - - 1232 227 load_const 24 ("") - 228 cmp_op != - 229 pop_jump_if_false +6 (to 235) - - 1233 230 load_type 7 - 231 load_var2 13 43 - 232 init_instance 5 (ai.content.Text .text) - 233 call 4 ntypeargs=1 (baml.Array.push) - 234 pop 1 - - 1236 235 load_var 41 (audio) - 236 load_field 1 (data) - 237 store_var 44 (_105) - 238 load_var 44 (_105) - 239 narrow_bind 8 44 - 240 pop_jump_if_false +17 (to 257) - 241 load_var 44 (_105) - 242 store_var_load_var 45 (data) - - 1237 243 load_const 25 ("") - 244 cmp_op != - 245 pop_jump_if_false +12 (to 257) - - 1240 246 load_var2 45 4 - 247 call 335 ntypeargs=0 (baml.media.Audio.from_base64) - - 1241 248 load_var 41 (audio) - 249 load_field 0 (id) - 250 load_const 0 () - - 1239 251 call 904 ntypeargs=0 (ai.content.Media.new) - 252 store_var 46 (_110) - - 1238 253 load_type 7 - 254 load_var2 13 46 - 255 call 4 ntypeargs=1 (baml.Array.push) - 256 pop 1 - - 1247 257 load_var 10 (message) - 258 load_field 6 (tool_calls) - 259 store_var_load_var 48 (_116) - 260 load_const 2 (null) - 261 cmp_op == - 262 pop_jump_if_false +4 (to 266) - 263 load_type 26 - 264 alloc_array 0 - 265 store_var 48 (_116) - 266 load_var 48 (_116) - 267 store_var 47 (calls) - - 1248 268 load_var2 13 47 - 269 load_var 2 (provider) - 270 call 1131 ntypeargs=0 (openai.internal._chat_push_tool_uses) - 271 pop 1 - - 1249 272 load_var 10 (message) - 273 load_field 5 (refusal) - 274 store_var 49 (_123) - 275 load_var 49 (_123) - 276 narrow_bind 8 49 - 277 pop_jump_if_false +8 (to 285) - 278 load_var 49 (_123) - 279 store_var 50 (refusal) - - 1250 280 load_type 7 - 281 load_var2 13 50 - 282 init_instance 6 (ai.content.Text .text) - 283 call 4 ntypeargs=1 (baml.Array.push) - 284 pop 1 - - 1253 285 load_var 47 (calls) - 286 container_len - 287 store_var 52 (_131) - 288 load_var 52 (_131) - 289 load_const 4 (0) - 290 cmp_int_op > - 291 pop_jump_if_false +2 (to 293) - 292 jump +28 (to 320) - - 1255 293 load_var 10 (message) - 294 load_field 5 (refusal) - 295 load_const 2 (null) - 296 call 672 ntypeargs=0 (baml.ops.equals_equals) - 297 unary_op ! - 298 pop_jump_if_false +2 (to 300) - 299 jump +17 (to 316) - - 1258 300 load_var 7 (choice) - 301 load_field 2 (finish_reason) - 302 store_var 53 (_136) - 303 load_var 53 (_136) - 304 narrow_bind 8 53 - 305 pop_jump_if_false +2 (to 307) - 306 jump +5 (to 311) - - 1260 307 load_const 4 (ai.content.StopReason.Complete) - 308 alloc_variant 774 (ai.content.StopReason) - 309 store_var 51 (stop) - - 1258 310 jump +13 (to 323) - 311 load_var 53 (_136) - 312 store_var_load_var 54 (reason) - - 1259 313 call 1128 ntypeargs=0 (openai.internal.chat_stop_reason) - 314 store_var 51 (stop) - 315 jump +8 (to 323) - - 1256 316 load_const 27 (ai.content.StopReason.Refused) - 317 alloc_variant 774 (ai.content.StopReason) - 318 store_var 51 (stop) - - 1255 319 jump +4 (to 323) - - 1254 320 load_const 8 (ai.content.StopReason.ToolUse) - 321 alloc_variant 774 (ai.content.StopReason) - 322 store_var 51 (stop) - - 1264 323 load_var 1 (response) - 324 load_field 3 (usage) - 325 store_var 56 (_141) - 326 load_var 56 (_141) - 327 narrow_bind 28 56 - 328 pop_jump_if_false +2 (to 330) - 329 jump +4 (to 333) - - 1273 330 load_const 2 (null) - 331 store_var 55 (usage) - - 1264 332 jump +52 (to 384) - 333 load_var 56 (_141) - 334 store_var_load_var 57 (u) - - 1267 335 load_field 0 (prompt_tokens) - 336 store_var_load_var 59 (_144) - 337 load_const 2 (null) - 338 cmp_op == - 339 pop_jump_if_false +3 (to 342) - 340 load_const 4 (0) - 341 store_var 59 (_144) - 342 load_var 59 (_144) - 343 store_var 58 (_143) - - 1268 344 load_var 57 (u) - 345 load_field 1 (completion_tokens) - 346 store_var_load_var 61 (_148) - 347 load_const 2 (null) - 348 cmp_op == - 349 pop_jump_if_false +3 (to 352) - 350 load_const 4 (0) - 351 store_var 61 (_148) - 352 load_var 61 (_148) - 353 store_var 60 (_147) - - 1269 354 load_var 57 (u) - 355 load_field 3 (prompt_tokens_details) - 356 load_const 2 (null) - 357 cmp_op == - 358 pop_jump_if_false +2 (to 360) - 359 jump +6 (to 365) - 360 load_var 57 (u) - 361 load_field 3 (prompt_tokens_details) - 362 load_field 0 (0) - 363 store_var 62 (_151) - 364 jump +3 (to 367) - 365 load_const 2 (null) - 366 store_var 62 (_151) - - 1270 367 load_var 57 (u) - 368 load_field 4 (completion_tokens_details) - 369 load_const 2 (null) - 370 cmp_op == - 371 pop_jump_if_false +2 (to 373) - 372 jump +6 (to 378) - 373 load_var 57 (u) - 374 load_field 4 (completion_tokens_details) - 375 load_field 0 (0) - 376 store_var 63 (_155) - 377 jump +3 (to 380) - 378 load_const 2 (null) - 379 store_var 63 (_155) - - 1266 380 load_var2 58 60 - 381 load_var2 62 63 - 382 init_instance 7 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 383 store_var 55 (usage) - - 1276 384 load_var2 13 51 - 385 load_var 55 (usage) - 386 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) - 387 return -} - -function openai.internal.chat_render(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - 1091 0 load_var2 1 2 - 1 load_var2 3 4 - 2 call 1125 ntypeargs=0 (openai.internal.chat_build_request) - 3 store_var 6 (request) - - 1094 4 load_var2 1 2 - 5 call 1122 ntypeargs=0 (openai.internal._chat_url) - 6 store_var 7 (_6) - - 1095 7 load_var2 1 2 - 8 call 1123 ntypeargs=0 (openai.internal._chat_headers) - 9 store_var 8 (_7) - - 1096 10 load_var2 1 2 - 11 load_var 6 (request) - 12 call 1126 ntypeargs=0 (openai.internal.chat_render_body) - 13 store_var 9 (_8) - - 1092 14 load_const 0 ("POST") - 15 load_var2 7 8 - 16 load_var 9 (_8) - 17 init_instance 0 (baml.http.Request .method, .url, .headers, .body) - 18 store_var 5 (_0) - 19 load_var 5 (_0) - 20 return -} - -function openai.internal.chat_render_body(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, request: openai.internal.ChatRequest) -> string { - 1080 0 load_type 0 - 1 load_var 3 (request) - 2 call 356 ntypeargs=1 (baml.json.from) - 3 call 1119 ntypeargs=0 (openai.internal._chat_prune_nulls) - 4 call 1118 ntypeargs=0 (openai.internal._chat_apply_directives) - - 1081 5 load_var 2 (params) - 6 load_field 10 (request_body) - 7 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 8 call 351 ntypeargs=0 (baml.json.stringify) - 9 return -} - -function openai.internal.chat_stop_reason(reason: string) -> ai.content.StopReason { - 1105 0 load_var 1 (reason) - 1 load_const 0 ("tool_calls") - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +36 (to 40) - 5 load_var 1 (reason) - 6 load_const 1 ("function_call") - 7 cmp_op == - 8 pop_jump_if_false +2 (to 10) - 9 jump +28 (to 37) - 10 load_var 1 (reason) - 11 load_const 2 ("length") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +20 (to 34) - 15 load_var 1 (reason) - 16 load_const 3 ("max_tokens") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +12 (to 31) - 20 load_var 1 (reason) - 21 load_const 4 ("content_filter") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +4 (to 28) - - 1109 25 load_const 5 (ai.content.StopReason.Complete) - 26 alloc_variant 774 (ai.content.StopReason) - - 1105 27 jump +15 (to 42) - - 1108 28 load_const 6 (ai.content.StopReason.Refused) - 29 alloc_variant 774 (ai.content.StopReason) - - 1105 30 jump +12 (to 42) - - 1107 31 load_const 7 (ai.content.StopReason.MaxTokens) - 32 alloc_variant 774 (ai.content.StopReason) - - 1105 33 jump +9 (to 42) - - 1107 34 load_const 7 (ai.content.StopReason.MaxTokens) - 35 alloc_variant 774 (ai.content.StopReason) - - 1105 36 jump +6 (to 42) - - 1106 37 load_const 8 (ai.content.StopReason.ToolUse) - 38 alloc_variant 774 (ai.content.StopReason) - - 1105 39 jump +3 (to 42) - - 1106 40 load_const 8 (ai.content.StopReason.ToolUse) - 41 alloc_variant 774 (ai.content.StopReason) - 42 return -} - -function openai.internal.images_invoke(c: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 404 0 load_var2 1 2 - 1 call 1150 ntypeargs=0 (openai.internal.images_render) - 2 store_var 3 (req) - - 405 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("openai-images") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - 7 store_var 4 (resp) - - 406 8 load_var2 1 4 - 9 call 1154 ntypeargs=0 (openai.internal.images_parse) - 10 return -} - -function openai.internal.images_parse(c: openai.ImageClient, resp: openai.internal.OaImagesResponse) -> ai.ModelTurn { - 367 0 load_var 2 (resp) - 1 load_field 3 (output_format) - 2 store_var_load_var 4 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (c) - 7 load_field 7 (output_format) - 8 store_var 4 (_5) - 9 load_var 4 (_5) - 10 call 1151 ntypeargs=0 (openai.internal._oai_images_mime) - 11 store_var 3 (mime) - - 368 12 load_var 2 (resp) - 13 load_field 1 (data) - 14 store_var_load_var 6 (_9) - 15 load_const 0 (null) - 16 cmp_op == - 17 pop_jump_if_false +4 (to 21) - 18 load_type 1 - 19 alloc_array 0 - 20 store_var 6 (_9) - 21 load_var 6 (_9) - 22 store_var 5 (data) - - 369 23 load_type 2 - 24 alloc_array 0 - 25 store_var 7 (content) - - 370 26 load_var 5 (data) - 27 load_type 3 - 28 load_const 4 ("iter") - 29 virtual_call nargs=1 ntypeargs=0 - 30 store_var 8 (_14) - 31 load_var 8 (_14) - 32 load_type 5 - 33 load_const 6 ("next") - 34 virtual_call nargs=1 ntypeargs=0 - 35 store_var 9 (_15) - 36 load_var 9 (_15) - 37 is_type 7 - 38 pop_jump_if_false +2 (to 40) - 39 jump +16 (to 55) - 40 load_var 9 (_15) - 41 store_var_load_var 10 (datum) - - 371 42 load_var 3 (mime) - 43 call 1153 ntypeargs=0 (openai.internal._oai_images_block) - 44 store_var 11 (_22) - 45 load_var 11 (_22) - 46 narrow_bind 8 11 - 47 pop_jump_if_false -16 (to 31) - 48 load_var 11 (_22) - 49 store_var 12 (block) - - 372 50 load_type 2 - 51 load_var2 7 12 - 52 call 4 ntypeargs=1 (baml.Array.push) - 53 pop 1 - 54 jump -23 (to 31) - - 375 55 load_var 7 (content) - 56 container_len - 57 store_var 13 (_28) - 58 load_var 13 (_28) - 59 load_const 9 (0) - 60 cmp_int_op == - 61 pop_jump_if_false +2 (to 63) - 62 jump +41 (to 103) - - 381 63 load_var 2 (resp) - 64 load_field 6 (usage) - 65 store_var 15 (_32) - 66 load_var 15 (_32) - 67 narrow_bind 10 15 - 68 pop_jump_if_false +2 (to 70) - 69 jump +4 (to 73) - - 389 70 load_const 0 (null) - 71 store_var 14 (usage) - - 381 72 jump +25 (to 97) - 73 load_var 15 (_32) - 74 store_var_load_var 16 (reported) - - 383 75 load_field 0 (input_tokens) - 76 store_var_load_var 18 (_35) - 77 load_const 0 (null) - 78 cmp_op == - 79 pop_jump_if_false +3 (to 82) - 80 load_const 9 (0) - 81 store_var 18 (_35) - 82 load_var 18 (_35) - 83 store_var 17 (_34) - - 384 84 load_var 16 (reported) - 85 load_field 1 (output_tokens) - 86 store_var_load_var 19 (_39) - 87 load_const 0 (null) - 88 cmp_op == - 89 pop_jump_if_false +3 (to 92) - 90 load_const 9 (0) - 91 store_var 19 (_39) - - 382 92 load_var2 17 19 - - 384 93 load_const 0 (null) - 94 load_const 0 (null) - 95 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 96 store_var 14 (usage) - - 392 97 load_var 7 (content) - 98 load_const 9 (ai.content.StopReason.Complete) - 99 alloc_variant 774 (ai.content.StopReason) - - 394 100 load_var 14 (usage) - 101 init_instance 1 (ai.ModelTurn .content, .stop_reason, .usage) - 102 return - - 376 103 load_const 11 ("openai-images") - 104 load_const 12 ("the images response contained no image data in data[]") - 105 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 106 throw -} - -function openai.internal.images_render(c: openai.ImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - 259 0 load_var 2 (input) - 1 load_field 2 (toolbox) - 2 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 3 unary_op ! - 4 pop_jump_if_false +2 (to 6) - 5 jump +102 (to 107) - - 267 6 load_var 2 (input) - 7 load_field 1 (journal) - 8 store_var 5 (_8) - 9 load_var 1 (c) - 10 call 1141 ntypeargs=0 (openai.internal._oai_images_client_id) - 11 store_var 6 (_9) - 12 load_var2 5 6 - 13 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 14 store_var 4 (journal) - - 271 15 load_const 0 ("") - 16 load_var 2 (input) - 17 load_field 0 (prompt) - 18 call_indirect - 19 load_var 4 (journal) - 20 call 1144 ntypeargs=0 (openai.internal._oai_images_prompt_text) - 21 store_var 7 (text) - - 273 22 load_var 1 (c) - 23 load_field 0 (model) - 24 store_var 9 (_15) - - 275 25 load_var 1 (c) - 26 load_field 3 (n) - 27 store_var 10 (_17) - - 276 28 load_var 1 (c) - 29 load_field 4 (size) - 30 store_var 11 (_18) - - 277 31 load_var 1 (c) - 32 load_field 5 (quality) - 33 store_var 12 (_19) - - 278 34 load_var 1 (c) - 35 load_field 6 (background) - 36 store_var 13 (_20) - - 279 37 load_var 1 (c) - 38 load_field 7 (output_format) - 39 store_var 14 (_21) - - 280 40 load_var 1 (c) - 41 load_field 8 (output_compression) - 42 store_var 15 (_22) - - 281 43 load_var 1 (c) - 44 load_field 9 (moderation) - 45 store_var 16 (_23) - - 282 46 load_var 1 (c) - 47 load_field 10 (style) - 48 store_var 17 (_24) - - 283 49 load_var 1 (c) - 50 load_field 11 (user) - 51 store_var 18 (_25) - - 284 52 load_var 1 (c) - 53 load_field 0 (model) - 54 load_var 1 (c) - 55 load_field 12 (response_format) - 56 call 1145 ntypeargs=0 (openai.internal._oai_images_response_format) - 57 store_var 19 (_26) - - 272 58 load_var2 9 7 - - 274 59 load_var2 10 11 - 60 load_var2 12 13 - 61 load_var2 14 15 - 62 load_var2 16 17 - 63 load_var2 18 19 - 64 init_instance 0 (openai.internal.OaImagesRequest .model, .prompt, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format) - 65 store_var 8 (request) - - 286 66 load_type 1 - 67 load_var 8 (request) - 68 call 355 ntypeargs=1 (baml.json.to_json) - 69 call 1142 ntypeargs=0 (openai.internal._oai_images_drop_nulls) - - 287 70 load_var 1 (c) - 71 load_field 13 (request_body) - 72 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 73 store_var 20 (merged) - - 289 74 load_var 1 (c) - 75 call 1094 ntypeargs=0 (openai.ImageClient.resolved_base_url) - 76 store_var_load_var 23 (_41) - 77 load_const 2 (null) - 78 cmp_op == - 79 pop_jump_if_false +3 (to 82) - 80 load_const 3 ("https://api.openai.com/v1") - 81 store_var 23 (_41) - 82 load_var 23 (_41) - 83 call 1146 ntypeargs=0 (openai.internal._oai_images_trim_slash) - 84 store_var 22 (_39) - 85 load_type 4 - 86 load_var 22 (_39) - 87 call 138 ntypeargs=1 (baml.String.from) - 88 load_const 5 ("/images/generations") - 89 bin_op + - - 290 90 load_var 1 (c) - 91 load_field 15 (query_params) - - 288 92 call 1148 ntypeargs=0 (openai.internal._oai_images_with_query) - 93 store_var 21 (url) - - 295 94 load_var 1 (c) - 95 call 1149 ntypeargs=0 (openai.internal._oai_images_headers) - 96 store_var 24 (_47) - - 296 97 load_var 20 (merged) - 98 call 351 ntypeargs=0 (baml.json.stringify) - 99 store_var 25 (_48) - - 292 100 load_const 6 ("POST") - - 294 101 load_var2 21 24 - 102 load_var 25 (_48) - 103 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 104 store_var 3 (_0) - 105 load_var 3 (_0) - 106 return - - 260 107 load_const 7 ("openai-images") - 108 load_const 2 (null) - 109 load_const 8 ("the Images API has no tool calling; run tools with a chat client instead") - 110 load_const 2 (null) - 111 init_instance 2 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 112 throw -} - -function openai.internal.invoke(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 930 0 load_var2 1 2 - 1 call 1036 ntypeargs=0 (openai.internal.openai_render) - 2 store_var 3 (req) - - 931 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("openai") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - - 932 7 call 1042 ntypeargs=0 (openai.internal.openai_parse) - 8 return -} - -function openai.internal.invoke_stream(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 1151 3 load_var2 1 2 - 4 load_const 0 (true) - 5 call 1037 ntypeargs=0 (openai.internal._openai_request) - - 1152 6 sys_op 252 (baml.http.fetch_sse) - 7 store_var 3 (sse) - 8 jump +6 (to 14) - 9 load_var 4 (e) - 10 throw_if_panic - - 1153 11 load_var 4 (e) - 12 call 1049 ntypeargs=0 (openai.internal._openai_sse_failure) - 13 throw - - 1155 14 call 1044 ntypeargs=0 (openai.internal.OaStreamState.new) - 15 store_deref 5 - - 1163 16 load_var2 3 5 - - 1164 17 make_closure 2752 1 - 18 load_const 1 ("openai") - - 1162 19 call 959 ntypeargs=0 (ai.stream.TurnStream.from_sse) - 20 return -} - -function openai.internal.openai_lower_journal(j: ai.Journal) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - 523 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (items) - - 524 3 load_var 1 (j) - 4 call 905 ntypeargs=0 (ai.Journal.entries) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +151 (to 168) - 18 load_var 5 (_5) - 19 store_var 6 (e) - - 525 20 load_var 6 (e) - 21 store_var 7 (_9) - 22 load_var 7 (_9) - 23 narrow_bind 6 7 - 24 pop_jump_if_false +2 (to 26) - 25 jump +128 (to 153) - 26 load_var 6 (e) - 27 store_var 9 (_17) - 28 load_var 9 (_17) - 29 narrow_bind 7 9 - 30 pop_jump_if_false +2 (to 32) - 31 jump +55 (to 86) - 32 load_var 6 (e) - 33 store_var 21 (_44) - 34 load_var 21 (_44) - 35 narrow_bind 8 21 - 36 pop_jump_if_false +2 (to 38) - 37 jump +36 (to 73) - 38 load_var 6 (e) - 39 store_var 23 (_51) - 40 load_var 23 (_51) - 41 narrow_bind 9 23 - 42 pop_jump_if_false -33 (to 9) - 43 load_var 23 (_51) - 44 store_var 24 (f) - - 578 45 load_type 10 - 46 load_type 11 - 47 alloc_map 0 - 48 store_var 25 (err) - - 579 49 load_type 10 - 50 load_type 11 - 51 load_var 25 (err) - 52 load_const 12 ("error") - 53 load_var 24 (f) - 54 load_field 1 (message) - 55 call 37 ntypeargs=2 (baml.Map.set) - 56 pop 1 - - 583 57 load_var 24 (f) - 58 load_field 0 (id) - 59 store_var 26 (_60) - - 584 60 load_type 13 - 61 load_var 25 (err) - 62 call 355 ntypeargs=1 (baml.json.to_json) - 63 call 351 ntypeargs=0 (baml.json.stringify) - 64 store_var 27 (_61) - - 580 65 load_type 0 - 66 load_var 3 (items) - - 581 67 load_const 14 ("function_call_output") - 68 load_var2 26 27 - 69 init_instance 0 (openai.internal.OaFunctionCallOutputItem .type, .call_id, .output) - - 580 70 call 4 ntypeargs=1 (baml.Array.push) - 71 pop 1 - 72 jump -63 (to 9) - - 525 73 load_var 21 (_44) - 74 store_var 22 (c) - - 568 75 load_type 0 - 76 load_var 3 (items) - - 569 77 load_const 15 ("function_call_output") - - 571 78 load_var 22 (c) - 79 load_field 0 (id) - - 572 80 load_var 22 (c) - 81 load_field 1 (output) - 82 init_instance 1 (openai.internal.OaFunctionCallOutputItem .type, .call_id, .output) - - 568 83 call 4 ntypeargs=1 (baml.Array.push) - 84 pop 1 - 85 jump -76 (to 9) - - 525 86 load_var 9 (_17) - 87 store_var_load_var 10 (a) - - 536 88 load_field 0 (content) - 89 load_type 16 - 90 load_const 17 ("iter") - 91 virtual_call nargs=1 ntypeargs=0 - 92 store_var 11 (_20) - 93 load_var 11 (_20) - 94 load_type 18 - 95 load_const 19 ("next") - 96 virtual_call nargs=1 ntypeargs=0 - 97 store_var 12 (_21) - 98 load_var 12 (_21) - 99 is_type 5 - 100 pop_jump_if_false +2 (to 102) - 101 jump -92 (to 9) - 102 load_var 12 (_21) - 103 store_var 13 (b) - - 537 104 load_var 13 (b) - 105 store_var 14 (_25) - 106 load_var 14 (_25) - 107 narrow_bind 20 14 - 108 pop_jump_if_false +2 (to 110) - 109 jump +29 (to 138) - 110 load_var 13 (b) - 111 store_var 16 (_33) - 112 load_var 16 (_33) - 113 narrow_bind 21 16 - 114 pop_jump_if_false -21 (to 93) - 115 load_var 16 (_33) - 116 store_var 17 (use) - - 551 117 load_var 17 (use) - 118 load_field 0 (id) - 119 store_var 18 (_37) - - 552 120 load_var 17 (use) - 121 load_field 1 (name) - 122 store_var 19 (_38) - - 553 123 load_type 13 - 124 load_var 17 (use) - 125 load_field 2 (args) - 126 call 355 ntypeargs=1 (baml.json.to_json) - 127 call 351 ntypeargs=0 (baml.json.stringify) - 128 store_var 20 (_39) - - 548 129 load_type 0 - 130 load_var 3 (items) - - 549 131 load_const 22 ("function_call") - 132 load_var2 18 19 - 133 load_var 20 (_39) - 134 init_instance 2 (openai.internal.OaFunctionCallItem .type, .call_id, .name, .arguments) - - 548 135 call 4 ntypeargs=1 (baml.Array.push) - 136 pop 1 - 137 jump -44 (to 93) - - 537 138 load_var 14 (_25) - 139 store_var 15 (t) - - 539 140 load_type 0 - 141 load_var 3 (items) - - 540 142 load_const 23 ("assistant") - - 542 143 load_const 24 ("output_text") - 144 load_var 15 (t) - 145 load_field 0 (text) - 146 init_instance 3 (openai.internal.OaOutputText .type, .text) - 147 load_type 25 - 148 alloc_array 1 - 149 init_instance 4 (openai.internal.OaMessageItem .role, .content) - - 539 150 call 4 ntypeargs=1 (baml.Array.push) - 151 pop 1 - 152 jump -59 (to 93) - - 525 153 load_var 7 (_9) - 154 store_var 8 (u) - - 527 155 load_type 0 - 156 load_var 3 (items) - - 528 157 load_const 26 ("user") - - 530 158 load_const 27 ("input_text") - 159 load_var 8 (u) - 160 load_field 0 (content) - 161 init_instance 5 (openai.internal.OaInputText .type, .text) - 162 load_type 25 - 163 alloc_array 1 - 164 init_instance 6 (openai.internal.OaMessageItem .role, .content) - - 527 165 call 4 ntypeargs=1 (baml.Array.push) - 166 pop 1 - 167 jump -158 (to 9) - - 592 168 load_var 3 (items) - 169 store_var 2 (_0) - 170 load_var 2 (_0) - 171 return -} - -function openai.internal.openai_lower_prompt(prompt: ai.Prompt) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - 438 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (items) - - 439 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +36 (to 53) - 18 load_var 5 (_5) - 19 store_var 6 (message) - - 440 20 load_var 6 (message) - 21 load_field 0 (role) - 22 store_var_load_var 8 (_10) - 23 load_const 6 ("") - 24 cmp_op == - 25 pop_jump_if_false +2 (to 27) - 26 jump +13 (to 39) - 27 load_var 8 (_10) - 28 load_const 7 ("tool") - 29 cmp_op == - 30 pop_jump_if_false +2 (to 32) - 31 jump +5 (to 36) - - 442 32 load_var 6 (message) - 33 load_field 0 (role) - 34 store_var 7 (role) - - 440 35 jump +6 (to 41) - - 441 36 load_const 8 ("user") - 37 store_var 7 (role) - - 440 38 jump +3 (to 41) - - 441 39 load_const 9 ("user") - 40 store_var 7 (role) - - 444 41 load_var 7 (role) - 42 store_var 9 (_15) - 43 load_var2 6 7 - 44 call 1023 ntypeargs=0 (openai.internal._openai_prompt_content) - 45 store_var 10 (_16) - 46 load_type 0 - 47 load_var2 3 9 - 48 load_var 10 (_16) - 49 init_instance 0 (openai.internal.OaMessageItem .role, .content) - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -43 (to 9) - - 446 53 load_var 3 (items) - 54 store_var 2 (_0) - 55 load_var 2 (_0) - 56 return -} - -function openai.internal.openai_parse(resp: openai.internal.OaResponse) -> ai.ModelTurn { - 819 0 load_var 1 (resp) - 1 load_field 2 (status) - 2 store_var_load_var 2 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +3 (to 8) - 6 load_const 1 ("") - 7 store_var 2 (_5) - 8 load_var 2 (_5) - 9 load_const 2 ("failed") - 10 cmp_op == - 11 jump_if_false +2 (to 13) - 12 jump +7 (to 19) - 13 pop 1 - 14 load_var 1 (resp) - 15 load_field 6 (error) - 16 load_const 0 (null) - 17 call 672 ntypeargs=0 (baml.ops.equals_equals) - 18 unary_op ! - 19 pop_jump_if_false +2 (to 21) - 20 jump +367 (to 387) - - 822 21 load_type 3 - 22 alloc_array 0 - 23 store_var 3 (content) - - 823 24 load_const 4 (false) - 25 store_var 4 (has_call) - - 824 26 load_const 4 (false) - 27 store_var 5 (refused) - - 825 28 load_var 1 (resp) - 29 load_field 3 (output) - 30 store_var_load_var 7 (_15) - 31 load_const 0 (null) - 32 cmp_op == - 33 pop_jump_if_false +4 (to 37) - 34 load_type 5 - 35 alloc_array 0 - 36 store_var 7 (_15) - 37 load_var 7 (_15) - 38 store_var_load_var 6 (output) - - 826 39 load_type 6 - 40 load_const 7 ("iter") - 41 virtual_call nargs=1 ntypeargs=0 - 42 store_var 8 (_19) - 43 load_var 8 (_19) - 44 load_type 8 - 45 load_const 9 ("next") - 46 virtual_call nargs=1 ntypeargs=0 - 47 store_var 9 (_20) - 48 load_var 9 (_20) - 49 is_type 10 - 50 pop_jump_if_false +2 (to 52) - 51 jump +211 (to 262) - 52 load_var 9 (_20) - 53 store_var 10 (item) - - 827 54 load_var 10 (item) - 55 load_field 0 (type) - 56 store_var_load_var 11 (_24) - 57 load_const 11 ("function_call") - 58 cmp_op == - 59 pop_jump_if_false +2 (to 61) - 60 jump +152 (to 212) - 61 load_var 11 (_24) - 62 load_const 12 ("message") - 63 cmp_op == - 64 pop_jump_if_false +2 (to 66) - 65 jump +74 (to 139) - 66 load_var 11 (_24) - 67 load_const 13 ("reasoning") - 68 cmp_op == - 69 pop_jump_if_false +2 (to 71) - 70 jump +30 (to 100) - 71 load_var 11 (_24) - 72 load_const 14 ("image_generation_call") - 73 cmp_op == - 74 pop_jump_if_false -31 (to 43) - - 884 75 load_var 10 (item) - 76 load_field 8 (result) - 77 store_var 35 (_98) - 78 load_var 35 (_98) - 79 narrow_bind 15 35 - 80 pop_jump_if_false -37 (to 43) - 81 load_var 35 (_98) - 82 store_var 36 (encoded) - - 885 83 load_var 10 (item) - 84 load_field 10 (output_format) - 85 call 1038 ntypeargs=0 (openai.internal._openai_image_mime) - 86 store_var 37 (mime) - - 888 87 load_var2 36 37 - 88 call 349 ntypeargs=0 (baml.media.Image.from_base64) - - 889 89 load_var 10 (item) - 90 load_field 1 (id) - - 890 91 load_var 10 (item) - 92 load_field 9 (revised_prompt) - - 887 93 call 904 ntypeargs=0 (ai.content.Media.new) - 94 store_var 38 (_103) - - 886 95 load_type 3 - 96 load_var2 3 38 - 97 call 4 ntypeargs=1 (baml.Array.push) - 98 pop 1 - 99 jump -56 (to 43) - - 870 100 load_var 10 (item) - 101 load_field 7 (summary) - 102 store_var_load_var 29 (_80) - 103 load_const 0 (null) - 104 cmp_op == - 105 pop_jump_if_false +4 (to 109) - 106 load_type 16 - 107 alloc_array 0 - 108 store_var 29 (_80) - 109 load_var 29 (_80) - 110 store_var_load_var 28 (parts) - - 871 111 load_type 17 - 112 load_const 18 ("iter") - 113 virtual_call nargs=1 ntypeargs=0 - 114 store_var 30 (_84) - 115 load_var 30 (_84) - 116 load_type 19 - 117 load_const 20 ("next") - 118 virtual_call nargs=1 ntypeargs=0 - 119 store_var 31 (_85) - 120 load_var 31 (_85) - 121 is_type 10 - 122 pop_jump_if_false +2 (to 124) - 123 jump -80 (to 43) - 124 load_var 31 (_85) - 125 store_var_load_var 32 (part) - - 872 126 load_field 1 (text) - 127 store_var 33 (_90) - 128 load_var 33 (_90) - 129 narrow_bind 15 33 - 130 pop_jump_if_false -15 (to 115) - 131 load_var 33 (_90) - 132 store_var 34 (txt) - - 873 133 load_type 3 - 134 load_var2 3 34 - 135 init_instance 0 (ai.content.Reasoning .summary) - 136 call 4 ntypeargs=1 (baml.Array.push) - 137 pop 1 - 138 jump -23 (to 115) - - 851 139 load_var 10 (item) - 140 load_field 6 (content) - 141 store_var_load_var 20 (_49) - 142 load_const 0 (null) - 143 cmp_op == - 144 pop_jump_if_false +4 (to 148) - 145 load_type 16 - 146 alloc_array 0 - 147 store_var 20 (_49) - 148 load_var 20 (_49) - 149 store_var_load_var 19 (parts) - - 852 150 load_type 17 - 151 load_const 21 ("iter") - 152 virtual_call nargs=1 ntypeargs=0 - 153 store_var 21 (_53) - 154 load_var 21 (_53) - 155 load_type 19 - 156 load_const 22 ("next") - 157 virtual_call nargs=1 ntypeargs=0 - 158 store_var 22 (_54) - 159 load_var 22 (_54) - 160 is_type 10 - 161 pop_jump_if_false +2 (to 163) - 162 jump -119 (to 43) - 163 load_var 22 (_54) - 164 store_var_load_var 23 (part) - - 853 165 load_field 0 (type) - 166 store_var_load_var 25 (_59) - 167 load_const 0 (null) - 168 cmp_op == - 169 pop_jump_if_false +3 (to 172) - 170 load_const 23 ("") - 171 store_var 25 (_59) - 172 load_var 25 (_59) - 173 store_var_load_var 24 (kind) - - 854 174 load_const 24 ("output_text") - 175 cmp_op == - 176 pop_jump_if_false +2 (to 178) - 177 jump +21 (to 198) - 178 load_var 24 (kind) - 179 load_const 25 ("refusal") - 180 cmp_op == - 181 pop_jump_if_false -27 (to 154) - - 860 182 load_const 26 (true) - 183 store_var 5 (refused) - - 861 184 load_var 23 (part) - 185 load_field 2 (refusal) - 186 store_var_load_var 27 (_74) - 187 load_const 0 (null) - 188 cmp_op == - 189 pop_jump_if_false +3 (to 192) - 190 load_const 27 ("") - 191 store_var 27 (_74) - 192 load_type 3 - 193 load_var2 3 27 - 194 init_instance 1 (ai.content.Text .text) - 195 call 4 ntypeargs=1 (baml.Array.push) - 196 pop 1 - 197 jump -43 (to 154) - - 856 198 load_var 23 (part) - 199 load_field 1 (text) - 200 store_var_load_var 26 (_66) - 201 load_const 0 (null) - 202 cmp_op == - 203 pop_jump_if_false +3 (to 206) - 204 load_const 28 ("") - 205 store_var 26 (_66) - 206 load_type 3 - 207 load_var2 3 26 - 208 init_instance 2 (ai.content.Text .text) - 209 call 4 ntypeargs=1 (baml.Array.push) - 210 pop 1 - 211 jump -57 (to 154) - - 829 212 load_const 26 (true) - 213 store_var 4 (has_call) - - 830 214 load_type 29 - 215 load_type 30 - 216 alloc_map 0 - 217 store_var 12 (args) - - 831 218 load_var 10 (item) - 219 load_field 5 (arguments) - 220 store_var 13 (_28) - 221 load_var 13 (_28) - 222 narrow_bind 15 13 - 223 pop_jump_if_false +14 (to 237) - 224 load_var 13 (_28) - 225 store_var 14 (s) - - 837 226 load_type 31 - 227 load_var 14 (s) - 228 call 357 ntypeargs=1 (baml.json.from_string) - 229 store_var 12 (args) - 230 jump +7 (to 237) - 231 load_var 15 (e) - 232 throw_if_panic - - 838 233 load_const 32 ("openai") - 234 load_var 14 (s) - 235 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) - 236 throw - - 843 237 load_var 10 (item) - 238 load_field 3 (call_id) - 239 store_var_load_var 17 (_38) - 240 load_const 0 (null) - 241 cmp_op == - 242 pop_jump_if_false +3 (to 245) - 243 load_const 33 ("") - 244 store_var 17 (_38) - 245 load_var 17 (_38) - 246 store_var 16 (_37) - - 844 247 load_var 10 (item) - 248 load_field 4 (name) - 249 store_var_load_var 18 (_42) - 250 load_const 0 (null) - 251 cmp_op == - 252 pop_jump_if_false +3 (to 255) - 253 load_const 34 ("") - 254 store_var 18 (_42) - - 841 255 load_type 3 - 256 load_var2 3 16 - - 844 257 load_var2 18 12 - - 845 258 init_instance 4 (ai.content.ToolUse .id, .name, .args) - - 841 259 call 4 ntypeargs=1 (baml.Array.push) - 260 pop 1 - 261 jump -218 (to 43) - - 902 262 load_var 4 (has_call) - 263 pop_jump_if_false +2 (to 265) - 264 jump +55 (to 319) - - 904 265 load_var 5 (refused) - 266 pop_jump_if_false +2 (to 268) - 267 jump +48 (to 315) - - 906 268 load_var 1 (resp) - 269 load_field 2 (status) - 270 store_var_load_var 40 (_115) - 271 load_const 0 (null) - 272 cmp_op == - 273 pop_jump_if_false +3 (to 276) - 274 load_const 35 ("") - 275 store_var 40 (_115) - 276 load_var 40 (_115) - 277 load_const 36 ("incomplete") - 278 cmp_op == - 279 pop_jump_if_false +2 (to 281) - 280 jump +5 (to 285) - - 913 281 load_const 37 (ai.content.StopReason.Complete) - 282 alloc_variant 774 (ai.content.StopReason) - 283 store_var 39 (stop) - - 906 284 jump +38 (to 322) - - 907 285 load_var 1 (resp) - 286 load_field 5 (incomplete_details) - 287 load_const 0 (null) - 288 cmp_op == - 289 pop_jump_if_false +2 (to 291) - 290 jump +5 (to 295) - 291 load_var 1 (resp) - 292 load_field 5 (incomplete_details) - 293 load_field 0 (0) - 294 jump +2 (to 296) - 295 load_const 0 (null) - 296 store_var_load_var 41 (_120) - 297 load_const 0 (null) - 298 cmp_op == - 299 pop_jump_if_false +3 (to 302) - 300 load_const 38 ("") - 301 store_var 41 (_120) - 302 load_var 41 (_120) - 303 load_const 39 ("content_filter") - 304 cmp_op == - 305 pop_jump_if_false +2 (to 307) - 306 jump +5 (to 311) - - 910 307 load_const 40 (ai.content.StopReason.MaxTokens) - 308 alloc_variant 774 (ai.content.StopReason) - 309 store_var 39 (stop) - - 907 310 jump +12 (to 322) - - 908 311 load_const 41 (ai.content.StopReason.Refused) - 312 alloc_variant 774 (ai.content.StopReason) - 313 store_var 39 (stop) - - 907 314 jump +8 (to 322) - - 905 315 load_const 41 (ai.content.StopReason.Refused) - 316 alloc_variant 774 (ai.content.StopReason) - 317 store_var 39 (stop) - - 904 318 jump +4 (to 322) - - 903 319 load_const 15 (ai.content.StopReason.ToolUse) - 320 alloc_variant 774 (ai.content.StopReason) - 321 store_var 39 (stop) - - 915 322 load_var 1 (resp) - 323 load_field 4 (usage) - 324 store_var 43 (_128) - 325 load_var 43 (_128) - 326 narrow_bind 42 43 - 327 pop_jump_if_false +2 (to 329) - 328 jump +4 (to 332) - - 923 329 load_const 0 (null) - 330 store_var 42 (usage) - - 915 331 jump +52 (to 383) - 332 load_var 43 (_128) - 333 store_var_load_var 44 (u) - - 917 334 load_field 0 (input_tokens) - 335 store_var_load_var 46 (_131) - 336 load_const 0 (null) - 337 cmp_op == - 338 pop_jump_if_false +3 (to 341) - 339 load_const 37 (0) - 340 store_var 46 (_131) - 341 load_var 46 (_131) - 342 store_var 45 (_130) - - 918 343 load_var 44 (u) - 344 load_field 1 (output_tokens) - 345 store_var_load_var 48 (_135) - 346 load_const 0 (null) - 347 cmp_op == - 348 pop_jump_if_false +3 (to 351) - 349 load_const 37 (0) - 350 store_var 48 (_135) - 351 load_var 48 (_135) - 352 store_var 47 (_134) - - 919 353 load_var 44 (u) - 354 load_field 3 (input_tokens_details) - 355 load_const 0 (null) - 356 cmp_op == - 357 pop_jump_if_false +2 (to 359) - 358 jump +6 (to 364) - 359 load_var 44 (u) - 360 load_field 3 (input_tokens_details) - 361 load_field 0 (0) - 362 store_var 49 (_138) - 363 jump +3 (to 366) - 364 load_const 0 (null) - 365 store_var 49 (_138) - - 920 366 load_var 44 (u) - 367 load_field 4 (output_tokens_details) - 368 load_const 0 (null) - 369 cmp_op == - 370 pop_jump_if_false +2 (to 372) - 371 jump +6 (to 377) - 372 load_var 44 (u) - 373 load_field 4 (output_tokens_details) - 374 load_field 0 (0) - 375 store_var 50 (_142) - 376 jump +3 (to 379) - 377 load_const 0 (null) - 378 store_var 50 (_142) - - 916 379 load_var2 45 47 - 380 load_var2 49 50 - 381 init_instance 5 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 382 store_var 42 (usage) - - 925 383 load_var2 3 39 - 384 load_var 42 (usage) - 385 init_instance 6 (ai.ModelTurn .content, .stop_reason, .usage) - 386 return - - 820 387 load_var 1 (resp) - 388 call 1041 ntypeargs=0 (openai.internal._openai_response_failure) - 389 throw -} - -function openai.internal.openai_prompt_metadata(prompt: ai.Prompt) -> map[] { - 461 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 462 3 load_var 1 (prompt) - 4 call 910 ntypeargs=0 (ai.Prompt.messages) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +9 (to 26) - 18 load_var 5 (_5) - 19 store_var 6 (message) - - 463 20 load_type 0 - 21 load_var2 3 6 - 22 load_field 3 (metadata) - 23 call 4 ntypeargs=1 (baml.Array.push) - 24 pop 1 - 25 jump -16 (to 9) - - 465 26 load_var 3 (out) - 27 store_var 2 (_0) - 28 load_var 2 (_0) - 29 return -} - -function openai.internal.openai_render(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> baml.http.Request { - 693 0 load_var2 1 2 - 1 load_const 0 (false) - 2 call 1037 ntypeargs=0 (openai.internal._openai_request) - 3 return -} - -function testing.$invoke_collector(collector: (testing.TestCollector) -> void throws unknown, c: testing.TestCollector) -> void { - 143 0 load_var2 2 1 - 1 call_indirect - 2 return -} - -function testing.FailFast() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 104 0 make_closure 2060 0 - 1 store_var 1 (_0) - 2 load_var 1 (_0) - 3 return -} - -function testing.PassRate(threshold: float) -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 70 3 load_deref 1 - 4 load_const 0 (0.0) - 5 cmp_float_op < - 6 jump_if_false +2 (to 8) - 7 jump +5 (to 12) - 8 pop 1 - 9 load_deref 1 - 10 load_const 1 (1.0) - 11 cmp_float_op > - 12 pop_jump_if_false +4 (to 16) - - 71 13 load_const 2 ("testing.PassRate requires 0.0 <= threshold <= 1.0") - 14 call 277 ntypeargs=0 (baml.sys.panic) - 15 pop 1 - - 76 16 load_var 1 (threshold) - 17 make_closure 2055 1 - 18 store_var 2 (_0) - 19 load_var 2 (_0) - 20 return -} - -function testing.Quorum(n: int, m: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 2 6 load_deref 1 - 7 load_const 0 (0) - 8 cmp_int_op <= - 9 pop_jump_if_false +2 (to 11) - 10 jump +15 (to 25) - - 4 11 load_deref 2 - 12 load_const 0 (0) - 13 cmp_int_op < - 14 jump_if_false +2 (to 16) - 15 jump +5 (to 20) - 16 pop 1 - 17 load_deref 2 - 18 load_deref 1 - 19 cmp_int_op > - 20 pop_jump_if_false +8 (to 28) - - 5 21 load_const 1 ("testing.Quorum requires 0 <= m <= n") - 22 call 277 ntypeargs=0 (baml.sys.panic) - 23 pop 1 - 24 jump +4 (to 28) - - 3 25 load_const 2 ("testing.Quorum requires n > 0") - 26 call 277 ntypeargs=0 (baml.sys.panic) - 27 pop 1 - - 10 28 load_var2 1 2 - 29 make_closure 2039 2 - 30 store_var 3 (_0) - 31 load_var 3 (_0) - 32 return -} - -function testing.Retry(max_attempts: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 36 3 load_deref 1 - 4 load_const 0 (0) - 5 cmp_int_op <= - 6 pop_jump_if_false +4 (to 10) - - 37 7 load_const 1 ("testing.Retry requires max_attempts > 0") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 pop 1 - - 42 10 load_var 1 (max_attempts) - 11 make_closure 2049 1 - 12 store_var 2 (_0) - 13 load_var 2 (_0) - 14 return -} - -function testing.Sequential() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - 98 0 make_closure 2058 0 - 1 store_var 1 (_0) - 2 load_var 1 (_0) - 3 return -} - -function testing.TestCollector.find_test(self: testing.TestCollector, name: string) -> testing.TestRegistration { - 131 0 load_var 1 (self) - 1 load_field 1 (tests) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 4 (_4) - 6 load_var 4 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 5 (_5) - 11 load_var 5 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +11 (to 25) - 15 load_var 5 (_5) - 16 store_var_load_var 6 (t) - - 132 17 load_field 0 (name) - 18 load_var 2 (name) - 19 cmp_op == - 20 pop_jump_if_false -14 (to 6) - - 133 21 load_var 6 (t) - 22 store_var 3 (_0) - 23 load_var 3 (_0) - 24 return - - 136 25 load_const 5 ("Test not found: ") - 26 load_var 2 (name) - 27 bin_op + - 28 throw -} - -function testing.TestCollector.find_testset(self: testing.TestCollector, name: string) -> testing.TestSetRegistration { - 122 0 load_var 1 (self) - 1 load_field 2 (testsets) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 4 (_4) - 6 load_var 4 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 5 (_5) - 11 load_var 5 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +11 (to 25) - 15 load_var 5 (_5) - 16 store_var_load_var 6 (ts) - - 123 17 load_field 0 (name) - 18 load_var 2 (name) - 19 cmp_op == - 20 pop_jump_if_false -14 (to 6) - - 124 21 load_var 6 (ts) - 22 store_var 3 (_0) - 23 load_var 3 (_0) - 24 return - - 127 25 load_const 5 ("TestSet not found: ") - 26 load_var 2 (name) - 27 bin_op + - 28 throw -} - -function testing.TestCollector.new(prefix: string) -> testing.TestCollector { - 30 0 load_var 1 (prefix) - 1 load_type 0 - 2 alloc_array 0 - 3 load_type 1 - 4 alloc_array 0 - 5 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 6 store_var 2 (_0) - 7 load_var 2 (_0) - 8 return -} - -function testing.TestCollector.register_test(self: testing.TestCollector, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - 34 0 load_var 2 (name) - 1 load_const 0 ("::") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 pop_jump_if_false +2 (to 5) - 4 jump +89 (to 93) - - 39 5 load_var 1 (self) - 6 load_field 0 (prefix) - 7 load_const 1 ("") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +9 (to 19) - - 42 11 load_var 1 (self) - 12 load_field 0 (prefix) - 13 load_const 2 ("::") - 14 bin_op + - 15 load_var 2 (name) - 16 bin_op + - 17 store_var 6 (full_name) - - 39 18 jump +3 (to 21) - - 40 19 load_var 2 (name) - 20 store_var 6 (full_name) - - 44 21 load_const 3 (0) - 22 store_var 7 (count) - - 45 23 load_var 6 (full_name) - 24 load_const 4 ("#") - 25 bin_op + - 26 store_var 8 (hash_prefix) - - 46 27 load_var 1 (self) - 28 load_field 1 (tests) - 29 load_type 5 - 30 load_const 6 ("iter") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 9 (_17) - 33 load_var 9 (_17) - 34 load_type 7 - 35 load_const 8 ("next") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 10 (_18) - 38 load_var 10 (_18) - 39 is_type 9 - 40 pop_jump_if_false +2 (to 42) - 41 jump +19 (to 60) - 42 load_var 10 (_18) - 43 store_var_load_var 11 (t) - - 47 44 load_field 0 (name) - 45 load_var 6 (full_name) - 46 cmp_op == - 47 jump_if_false +2 (to 49) - 48 jump +6 (to 54) - 49 pop 1 - 50 load_var 11 (t) - 51 load_field 0 (name) - 52 load_var 8 (hash_prefix) - 53 call 148 ntypeargs=0 (baml.String.starts_with) - 54 pop_jump_if_false -21 (to 33) - - 48 55 load_var 7 (count) - 56 load_const 10 (1) - 57 add_int - 58 store_var 7 (count) - - 47 59 jump -26 (to 33) - - 53 60 load_var 7 (count) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 56 65 load_var 6 (full_name) - 66 store_var 12 (final_name) - - 53 67 jump +14 (to 81) - - 54 68 load_var 6 (full_name) - 69 load_const 11 ("#") - 70 bin_op + - 71 store_var 13 (_31) - 72 load_type 12 - 73 load_var 7 (count) - 74 load_const 10 (1) - 75 add_int - 76 call 138 ntypeargs=1 (baml.String.from) - 77 store_var 14 (_33) - 78 load_var2 13 14 - 79 bin_op + - 80 store_var 12 (final_name) - - 58 81 load_type 13 - 82 load_var 1 (self) - 83 load_field 1 (tests) - 84 load_var2 12 3 - 85 load_var 4 (runner) - 86 init_instance 0 (testing.TestRegistration .name, .body, .runner) - 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - - 33 89 load_const 14 (null) - 90 store_var 5 (_0) - 91 load_var 5 (_0) - 92 return - - 35 93 load_const 15 ("test name may not contain reserved separator `::`: ") - 94 load_var 2 (name) - 95 bin_op + - 96 init_instance 1 (testing.InvalidTestName .message) - 97 throw -} - -function testing.TestCollector.register_test_at(self: testing.TestCollector, owner: string, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - 106 0 load_var2 2 1 - 1 load_field 1 (tests) - 2 load_var 1 (self) - 3 load_field 2 (testsets) - 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 5 store_var 6 (scoped) - - 107 6 load_var2 6 3 - 7 load_var2 4 5 - 8 call 840 ntypeargs=0 (testing.TestCollector.register_test) - 9 return -} - -function testing.TestCollector.register_test_set(self: testing.TestCollector, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - 67 0 load_var 2 (name) - 1 load_const 0 ("::") - 2 call 147 ntypeargs=0 (baml.String.includes) - 3 pop_jump_if_false +2 (to 5) - 4 jump +89 (to 93) - - 72 5 load_var 1 (self) - 6 load_field 0 (prefix) - 7 load_const 1 ("") - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +9 (to 19) - - 75 11 load_var 1 (self) - 12 load_field 0 (prefix) - 13 load_const 2 ("::") - 14 bin_op + - 15 load_var 2 (name) - 16 bin_op + - 17 store_var 6 (full_name) - - 72 18 jump +3 (to 21) - - 73 19 load_var 2 (name) - 20 store_var 6 (full_name) - - 77 21 load_const 3 (0) - 22 store_var 7 (count) - - 78 23 load_var 6 (full_name) - 24 load_const 4 ("#") - 25 bin_op + - 26 store_var 8 (hash_prefix) - - 79 27 load_var 1 (self) - 28 load_field 2 (testsets) - 29 load_type 5 - 30 load_const 6 ("iter") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 9 (_17) - 33 load_var 9 (_17) - 34 load_type 7 - 35 load_const 8 ("next") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 10 (_18) - 38 load_var 10 (_18) - 39 is_type 9 - 40 pop_jump_if_false +2 (to 42) - 41 jump +19 (to 60) - 42 load_var 10 (_18) - 43 store_var_load_var 11 (ts) - - 80 44 load_field 0 (name) - 45 load_var 6 (full_name) - 46 cmp_op == - 47 jump_if_false +2 (to 49) - 48 jump +6 (to 54) - 49 pop 1 - 50 load_var 11 (ts) - 51 load_field 0 (name) - 52 load_var 8 (hash_prefix) - 53 call 148 ntypeargs=0 (baml.String.starts_with) - 54 pop_jump_if_false -21 (to 33) - - 81 55 load_var 7 (count) - 56 load_const 10 (1) - 57 add_int - 58 store_var 7 (count) - - 80 59 jump -26 (to 33) - - 86 60 load_var 7 (count) - 61 load_const 3 (0) - 62 cmp_int_op > - 63 pop_jump_if_false +2 (to 65) - 64 jump +4 (to 68) - - 89 65 load_var 6 (full_name) - 66 store_var 12 (final_name) - - 86 67 jump +14 (to 81) - - 87 68 load_var 6 (full_name) - 69 load_const 11 ("#") - 70 bin_op + - 71 store_var 13 (_31) - 72 load_type 12 - 73 load_var 7 (count) - 74 load_const 10 (1) - 75 add_int - 76 call 138 ntypeargs=1 (baml.String.from) - 77 store_var 14 (_33) - 78 load_var2 13 14 - 79 bin_op + - 80 store_var 12 (final_name) - - 91 81 load_type 13 - 82 load_var 1 (self) - 83 load_field 2 (testsets) - - 92 84 load_var2 12 3 - 85 load_var 4 (runner) - 86 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) - - 91 87 call 4 ntypeargs=1 (baml.Array.push) - 88 pop 1 - - 66 89 load_const 14 (null) - 90 store_var 5 (_0) - 91 load_var 5 (_0) - 92 return - - 68 93 load_const 15 ("testset name may not contain reserved separator `::`: ") - 94 load_var 2 (name) - 95 bin_op + - 96 init_instance 1 (testing.InvalidTestName .message) - 97 throw -} - -function testing.TestCollector.register_test_set_at(self: testing.TestCollector, owner: string, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - 117 0 load_var2 2 1 - 1 load_field 1 (tests) - 2 load_var 1 (self) - 3 load_field 2 (testsets) - 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 5 store_var 6 (scoped) - - 118 6 load_var2 6 3 - 7 load_var2 4 5 - 8 call 841 ntypeargs=0 (testing.TestCollector.register_test_set) - 9 return -} - -function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: string) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - 288 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 2 (testsets) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +13 (to 28) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (ts) - - 289 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 290 22 load_var2 1 5 - 23 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 24 pop 1 - - 291 25 load_var 1 (self) - 26 call 848 ntypeargs=0 (testing.TestRegistry.serialize) - 27 jump +33 (to 60) - - 295 28 load_type 5 - 29 load_type 6 - 30 load_var 1 (self) - 31 load_field 1 (expansions) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 7 - 34 load_const 8 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 6 (_17) - 37 load_var 6 (_17) - 38 load_type 9 - 39 load_const 10 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 7 (_18) - 42 load_var 7 (_18) - 43 is_type 4 - 44 pop_jump_if_false +2 (to 46) - 45 jump +16 (to 61) - 46 load_var 7 (_18) - 47 store_var 8 (k) - - 296 48 load_var 1 (self) - 49 load_field 1 (expansions) - 50 load_var 8 (k) - 51 load_map_element - 52 store_var 9 (sub) - - 297 53 load_var2 2 8 - 54 load_const 11 ("::") - 55 bin_op + - 56 call 148 ntypeargs=0 (baml.String.starts_with) - 57 pop_jump_if_false -20 (to 37) - - 298 58 load_var2 9 2 - 59 call 855 ntypeargs=0 (testing.TestRegistry.expand_set) - 60 return - - 301 61 load_const 12 ("TestSet not found for expansion: ") - 62 load_var 2 (name) - 63 bin_op + - 64 throw -} - -function testing.TestRegistry.expand_testset_registry(self: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestRegistry { - 305 0 load_type 0 - 1 load_type 1 - 2 load_var 1 (self) - 3 load_field 1 (expansions) - 4 load_var 2 (ts) - 5 load_field 0 (name) - 6 call 38 ntypeargs=2 (baml.Map.get) - 7 store_var 3 (_8) - 8 load_var 3 (_8) - 9 narrow_bind 2 3 - 10 pop_jump_if_false +2 (to 12) - 11 jump +53 (to 64) - - 308 12 sys_op 539 (baml.time.Instant.now) - 13 store_var 5 (start) - - 309 14 load_var 2 (ts) - 15 load_field 0 (name) - 16 load_type 3 - 17 alloc_array 0 - 18 load_type 4 - 19 alloc_array 0 - 20 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) - 21 store_var_load_var 6 (sub_collector) - - 310 22 load_var 2 (ts) - 23 load_field 1 (collector) - 24 call_indirect - 25 pop 1 - - 315 26 load_var 5 (start) - 27 call 540 ntypeargs=0 (baml.time.Instant.elapsed) - 28 call 527 ntypeargs=0 (baml.time.Duration.to_milliseconds) - 29 call 92 ntypeargs=0 (baml.Bigint.to_int) - 30 store_var 7 (elapsed) - 31 jump +15 (to 46) - 32 load_var 8 (_) - 33 is_type 5 - 34 pop_jump_if_false +2 (to 36) - 35 jump +3 (to 38) - 36 load_var 8 (_) - 37 rethrow - 38 load_var 8 (_) - 39 load_field 0 (0) - 40 store_var 9 (message) - - 317 41 load_const 6 ("testing: expansion duration: ") - 42 load_var 9 (message) - 43 bin_op + - 44 call 277 ntypeargs=0 (baml.sys.panic) - 45 store_var 7 (elapsed) - - 320 46 load_var 6 (sub_collector) - 47 load_type 0 - 48 load_type 1 - 49 alloc_map 0 - 50 load_var 7 (elapsed) - 51 init_instance 1 (testing.TestRegistry .collector, .expansions, .loading_time_ms) - 52 store_var 10 (sub_registry) - - 321 53 load_type 0 - 54 load_type 1 - 55 load_var 1 (self) - 56 load_field 1 (expansions) - 57 load_var 2 (ts) - 58 load_field 0 (name) - 59 load_var 10 (sub_registry) - 60 call 37 ntypeargs=2 (baml.Map.set) - 61 pop 1 - - 322 62 load_var 10 (sub_registry) - - 305 63 jump +4 (to 67) - 64 load_var 3 (_8) - 65 store_var 4 (existing) - - 306 66 load_var 4 (existing) - 67 return -} - -function testing.TestRegistry.list_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 281 0 load_var2 1 2 - 1 load_var2 3 4 - 2 load_var 5 (cli_exclude) - 3 call 876 ntypeargs=0 (testing.select_names_layered) - 4 return -} - -function testing.TestRegistry.new(collector: testing.TestCollector) -> testing.TestRegistry { - 169 0 load_var 1 (collector) - 1 load_type 0 - 2 load_type 1 - 3 alloc_map 0 - 4 load_const 2 (0) - 5 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) - 6 store_var 2 (_0) - 7 load_var 2 (_0) - 8 return -} - -function testing.TestRegistry.run_all(self: testing.TestRegistry) -> testing.TestSetReport { - 237 0 load_var 1 (self) - 1 call 857 ntypeargs=0 (testing.testset_children) - 2 load_const 0 (null) - 3 call 867 ntypeargs=0 (testing.run_testset) - 4 return -} - -function testing.TestRegistry.run_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> testing.FlatTestReport { - 259 0 load_var2 1 2 - 1 load_var2 3 4 - 2 load_var 5 (cli_exclude) - 3 call 876 ntypeargs=0 (testing.select_names_layered) - 4 store_var 6 (selected_names) - - 261 5 load_var 2 (profile_include) - 6 container_len - 7 store_var 7 (_12) - 8 load_var 7 (_12) - 9 load_const 0 (0) - 10 cmp_int_op == - 11 jump_if_false +8 (to 19) - 12 pop 1 - - 262 13 load_var 3 (profile_exclude) - 14 container_len - 15 store_var 8 (_13) - 16 load_var 8 (_13) - 17 load_const 0 (0) - 18 cmp_int_op == - - 261 19 jump_if_false +8 (to 27) - 20 pop 1 - - 263 21 load_var 4 (cli_include) - 22 container_len - 23 store_var 9 (_14) - 24 load_var 9 (_14) - 25 load_const 0 (0) - 26 cmp_int_op == - - 261 27 jump_if_false +8 (to 35) - 28 pop 1 - - 264 29 load_var 5 (cli_exclude) - 30 container_len - 31 store_var 10 (_15) - 32 load_var 10 (_15) - 33 load_const 0 (0) - 34 cmp_int_op == - - 260 35 pop_jump_if_false +2 (to 37) - 36 jump +4 (to 40) - - 268 37 load_var2 1 6 - 38 call 852 ntypeargs=0 (testing.TestRegistry.run_selected) - 39 jump +3 (to 42) - - 266 40 load_var 1 (self) - 41 call 851 ntypeargs=0 (testing.TestRegistry.run_all) - - 270 42 load_var 6 (selected_names) - 43 call 882 ntypeargs=0 (testing.flatten_with_tolerated) - 44 return -} - -function testing.TestRegistry.run_selected(self: testing.TestRegistry, names: string[]) -> testing.TestSetReport { - 241 0 load_var2 1 2 - 1 call 858 ntypeargs=0 (testing.testset_children_selected) - 2 load_const 0 (null) - 3 call 867 ntypeargs=0 (testing.run_testset) - 4 return -} - -function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) -> testing.TestReport { - 205 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 1 (tests) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +13 (to 28) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (t) - - 206 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 207 22 load_var 5 (t) - 23 load_field 1 (body) - 24 load_var 5 (t) - 25 load_field 2 (runner) - 26 call 866 ntypeargs=0 (testing.run_test) - 27 jump +33 (to 60) - - 211 28 load_type 5 - 29 load_type 6 - 30 load_var 1 (self) - 31 load_field 1 (expansions) - 32 call 35 ntypeargs=2 (baml.Map.keys) - 33 load_type 7 - 34 load_const 8 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 6 (_17) - 37 load_var 6 (_17) - 38 load_type 9 - 39 load_const 10 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 7 (_18) - 42 load_var 7 (_18) - 43 is_type 4 - 44 pop_jump_if_false +2 (to 46) - 45 jump +16 (to 61) - 46 load_var 7 (_18) - 47 store_var 8 (k) - - 212 48 load_var 1 (self) - 49 load_field 1 (expansions) - 50 load_var 8 (k) - 51 load_map_element - 52 store_var 9 (sub) - - 214 53 load_var2 2 8 - 54 load_const 11 ("::") - 55 bin_op + - 56 call 148 ntypeargs=0 (baml.String.starts_with) - 57 pop_jump_if_false -20 (to 37) - - 215 58 load_var2 9 2 - 59 call 849 ntypeargs=0 (testing.TestRegistry.run_test) - 60 return - - 218 61 load_const 12 ("Test not found: ") - 62 load_var 2 (name) - 63 bin_op + - 64 throw -} - -function testing.TestRegistry.run_testset(self: testing.TestRegistry, name: string) -> testing.TestSetReport { - 222 0 load_var 1 (self) - 1 load_field 0 (collector) - 2 load_field 2 (testsets) - 3 load_type 0 - 4 load_const 1 ("iter") - 5 virtual_call nargs=1 ntypeargs=0 - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 load_type 2 - 9 load_const 3 ("next") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 4 (_5) - 12 load_var 4 (_5) - 13 is_type 4 - 14 pop_jump_if_false +2 (to 16) - 15 jump +14 (to 29) - 16 load_var 4 (_5) - 17 store_var_load_var 5 (ts) - - 223 18 load_field 0 (name) - 19 load_var 2 (name) - 20 cmp_op == - 21 pop_jump_if_false -14 (to 7) - - 224 22 load_var2 1 5 - 23 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 24 call 857 ntypeargs=0 (testing.testset_children) - 25 load_var 5 (ts) - 26 load_field 2 (runner) - 27 call 867 ntypeargs=0 (testing.run_testset) - 28 jump +33 (to 61) - - 227 29 load_type 5 - 30 load_type 6 - 31 load_var 1 (self) - 32 load_field 1 (expansions) - 33 call 35 ntypeargs=2 (baml.Map.keys) - 34 load_type 7 - 35 load_const 8 ("iter") - 36 virtual_call nargs=1 ntypeargs=0 - 37 store_var 6 (_19) - 38 load_var 6 (_19) - 39 load_type 9 - 40 load_const 10 ("next") - 41 virtual_call nargs=1 ntypeargs=0 - 42 store_var 7 (_20) - 43 load_var 7 (_20) - 44 is_type 4 - 45 pop_jump_if_false +2 (to 47) - 46 jump +16 (to 62) - 47 load_var 7 (_20) - 48 store_var 8 (k) - - 228 49 load_var 1 (self) - 50 load_field 1 (expansions) - 51 load_var 8 (k) - 52 load_map_element - 53 store_var 9 (sub) - - 229 54 load_var2 2 8 - 55 load_const 11 ("::") - 56 bin_op + - 57 call 148 ntypeargs=0 (baml.String.starts_with) - 58 pop_jump_if_false -20 (to 38) - - 230 59 load_var2 9 2 - 60 call 850 ntypeargs=0 (testing.TestRegistry.run_testset) - 61 return - - 233 62 load_const 12 ("TestSet not found: ") - 63 load_var 2 (name) - 64 bin_op + - 65 throw -} - -function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - 178 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (items) - - 179 3 load_var 1 (self) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_5) - 15 load_var 5 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +12 (to 30) - 19 load_var 5 (_5) - 20 store_var 6 (t) - - 180 21 load_type 0 - 22 load_var 3 (items) - 23 load_const 6 ("test") - 24 load_var 6 (t) - 25 load_field 0 (name) - 26 init_instance 0 (testing.SerializedTest .type, .name) - 27 call 4 ntypeargs=1 (baml.Array.push) - 28 pop 1 - 29 jump -19 (to 10) - - 182 30 load_var 1 (self) - 31 load_field 0 (collector) - 32 load_field 2 (testsets) - 33 load_type 7 - 34 load_const 8 ("iter") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 7 (_14) - 37 load_var 7 (_14) - 38 load_type 9 - 39 load_const 10 ("next") - 40 virtual_call nargs=1 ntypeargs=0 - 41 store_var 8 (_15) - 42 load_var 8 (_15) - 43 is_type 5 - 44 pop_jump_if_false +2 (to 46) - 45 jump +40 (to 85) - 46 load_var 8 (_15) - 47 store_var 9 (ts) - - 183 48 load_type 11 - 49 load_type 12 - 50 load_var 1 (self) - 51 load_field 1 (expansions) - 52 load_var 9 (ts) - 53 load_field 0 (name) - 54 call 38 ntypeargs=2 (baml.Map.get) - - 184 55 store_var 10 (_25) - 56 load_var 10 (_25) - 57 narrow_bind 13 10 - 58 pop_jump_if_false +2 (to 60) - 59 jump +10 (to 69) - - 195 60 load_type 0 - 61 load_var 3 (items) - 62 load_const 14 ("lazyTestSet") - 63 load_var 9 (ts) - 64 load_field 0 (name) - 65 init_instance 1 (testing.SerializedTest .type, .name) - 66 call 4 ntypeargs=1 (baml.Array.push) - 67 pop 1 - 68 jump -31 (to 37) - - 184 69 load_var 10 (_25) - 70 store_var 11 (sub) - - 188 71 load_var 9 (ts) - 72 load_field 0 (name) - 73 store_var 12 (_28) - - 189 74 load_var 11 (sub) - 75 call 848 ntypeargs=0 (testing.TestRegistry.serialize) - 76 store_var 13 (_29) - - 186 77 load_type 0 - 78 load_var2 3 12 - - 187 79 load_var2 13 11 - - 190 80 load_field 2 (loading_time_ms) - 81 init_instance 2 (testing.SerializedTestSet .name, .items, .loadingTimeMs) - - 186 82 call 4 ntypeargs=1 (baml.Array.push) - 83 pop 1 - 84 jump -47 (to 37) - - 199 85 load_var 3 (items) - 86 store_var 2 (_0) - 87 load_var 2 (_0) - 88 return -} - -function testing._has_selected_descendant(prefix: string, names: string[]) -> bool { - 415 0 load_var 1 (prefix) - 1 load_const 0 ("::") - 2 bin_op + - 3 store_var 3 (descendant_prefix) - - 416 4 load_var 2 (names) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +8 (to 25) - 18 load_var 5 (_5) - 19 store_var 6 (selected) - - 417 20 load_var2 6 3 - 21 call 148 ntypeargs=0 (baml.String.starts_with) - 22 pop_jump_if_false -13 (to 9) - - 418 23 load_const 6 (true) - 24 jump +2 (to 26) - - 423 25 load_const 7 (false) - 26 return -} - -function testing._int_to_float(value: int) -> float { - 128 0 load_type 0 - 1 load_var 1 (value) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 call 130 ntypeargs=0 (baml.Float.parse) - 4 jump +5 (to 9) - 5 load_var 2 (e) - 6 throw_if_panic - - 129 7 load_const 1 ("failed to convert int to float") - 8 call 277 ntypeargs=0 (baml.sys.panic) - 9 return -} - -function testing._name_selected(name: string, names: string[]) -> bool { - 404 0 load_var 2 (names) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - 14 load_var 4 (_4) - 15 store_var_load_var 5 (selected) - - 405 16 load_var 1 (name) - 17 cmp_op == - 18 pop_jump_if_false -13 (to 5) - - 406 19 load_const 5 (true) - 20 jump +2 (to 22) - - 411 21 load_const 6 (false) - 22 return -} - -function testing.aggregate_reports(named_results: testing.NamedChildReport[]) -> testing.TestSetReport { - 427 0 load_const 0 (0) - 1 store_var 3 (passed) - - 428 2 load_const 0 (0) - 3 store_var 4 (failed) - - 429 4 load_const 1 (false) - 5 store_var 5 (has_error) - - 430 6 load_type 2 - 7 alloc_array 0 - 8 store_var 6 (failed_names) - - 431 9 load_type 3 - 10 alloc_array 0 - 11 store_var 7 (results) - - 432 12 load_type 2 - 13 alloc_array 0 - 14 store_var 8 (result_names) - - 433 15 load_var 1 (named_results) - 16 load_type 4 - 17 load_const 5 ("iter") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 9 (_8) - 20 load_var 9 (_8) - 21 load_type 6 - 22 load_const 7 ("next") - 23 virtual_call nargs=1 ntypeargs=0 - 24 store_var 10 (_9) - 25 load_var 10 (_9) - 26 is_type 8 - 27 pop_jump_if_false +2 (to 29) - 28 jump +101 (to 129) - 29 load_var 10 (_9) - 30 store_var 11 (named_result) - - 434 31 load_var 11 (named_result) - 32 load_field 1 (report) - 33 store_var 12 (result) - - 435 34 load_type 3 - 35 load_var2 7 12 - 36 call 4 ntypeargs=1 (baml.Array.push) - 37 pop 1 - - 436 38 load_type 2 - 39 load_var2 8 11 - 40 load_field 0 (name) - 41 call 4 ntypeargs=1 (baml.Array.push) - 42 pop 1 - - 437 43 load_var 12 (result) - 44 store_var 14 (_21) - 45 load_var 14 (_21) - 46 narrow_bind 9 14 - 47 pop_jump_if_false +2 (to 49) - 48 jump +7 (to 55) - 49 load_var 12 (result) - 50 store_var 16 (report) - - 439 51 load_var 16 (report) - 52 load_field 0 (outcome) - 53 store_var 13 (outcome) - - 437 54 jump +6 (to 60) - 55 load_var 14 (_21) - 56 store_var 15 (report) - - 438 57 load_var 15 (report) - 58 load_field 0 (outcome) - 59 store_var 13 (outcome) - - 441 60 load_var 13 (outcome) - 61 load_const 10 ("pass") - 62 call 672 ntypeargs=0 (baml.ops.equals_equals) - 63 pop_jump_if_false +2 (to 65) - 64 jump +60 (to 124) - - 444 65 load_var 4 (failed) - 66 load_const 11 (1) - 67 add_int - 68 store_var 4 (failed) - - 445 69 load_var 12 (result) - 70 store_var 17 (_27) - 71 load_var 17 (_27) - 72 narrow_bind 9 17 - 73 pop_jump_if_false +2 (to 75) - 74 jump +19 (to 93) - 75 load_var 12 (result) - 76 store_var_load_var 18 (report) - - 448 77 load_field 4 (failed_names) - 78 container_len - 79 store_var 19 (_31) - 80 load_var 19 (_31) - 81 load_const 0 (0) - 82 cmp_int_op > - 83 pop_jump_if_false +2 (to 85) - 84 jump +6 (to 90) - - 451 85 load_var 11 (named_result) - 86 load_field 0 (name) - 87 load_type 2 - 88 alloc_array 1 - - 448 89 jump +8 (to 97) - - 449 90 load_var 18 (report) - 91 load_field 4 (failed_names) - - 448 92 jump +5 (to 97) - - 446 93 load_var 11 (named_result) - 94 load_field 0 (name) - 95 load_type 2 - 96 alloc_array 1 - - 455 97 load_type 12 - 98 load_const 13 ("iter") - 99 virtual_call nargs=1 ntypeargs=0 - 100 store_var 20 (_35) - 101 load_var 20 (_35) - 102 load_type 14 - 103 load_const 15 ("next") - 104 virtual_call nargs=1 ntypeargs=0 - 105 store_var 21 (_36) - 106 load_var 21 (_36) - 107 is_type 8 - 108 pop_jump_if_false +2 (to 110) - 109 jump +8 (to 117) - 110 load_var 21 (_36) - 111 store_var 22 (name) - - 456 112 load_type 2 - 113 load_var2 6 22 - 114 call 4 ntypeargs=1 (baml.Array.push) - 115 pop 1 - 116 jump -15 (to 101) - - 458 117 load_var 13 (outcome) - 118 load_const 16 ("error") - 119 call 672 ntypeargs=0 (baml.ops.equals_equals) - 120 pop_jump_if_false -100 (to 20) - - 459 121 load_const 17 (true) - 122 store_var 5 (has_error) - - 458 123 jump -103 (to 20) - - 442 124 load_var 3 (passed) - 125 load_const 11 (1) - 126 add_int - 127 store_var 3 (passed) - - 441 128 jump -108 (to 20) - - 465 129 load_var 5 (has_error) - 130 pop_jump_if_false +2 (to 132) - 131 jump +10 (to 141) - - 467 132 load_var 4 (failed) - 133 load_const 0 (0) - 134 cmp_int_op == - 135 pop_jump_if_false +2 (to 137) - 136 jump +3 (to 139) - - 470 137 load_const 18 ("fail") - - 467 138 jump +4 (to 142) - - 468 139 load_const 19 ("pass") - - 467 140 jump +2 (to 142) - - 466 141 load_const 20 ("error") - - 473 142 store_var 23 (_49) - - 474 143 load_var 3 (passed) - 144 store_var 24 (_50) - - 475 145 load_var 4 (failed) - 146 store_var 25 (_51) - - 476 147 load_var 7 (results) - 148 container_len - 149 store_var 26 (_52) - - 472 150 load_var2 23 24 - 151 load_var2 25 26 - - 477 152 load_var2 6 7 - - 479 153 load_var 8 (result_names) - 154 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) - 155 store_var 2 (_0) - 156 load_var 2 (_0) - 157 return -} - -function testing.any_pattern_matches(pats: string[], canonical_id: string) -> bool { - 607 0 load_var 1 (pats) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - 14 load_var 4 (_4) - 15 store_var 5 (p) - - 608 16 load_var2 2 5 - 17 call 869 ntypeargs=0 (testing.glob_match) - 18 pop_jump_if_false -13 (to 5) - - 609 19 load_const 5 (true) - 20 jump +2 (to 22) - - 612 21 load_const 6 (false) - 22 return -} - -function testing.classify_selected_names(selected_names: string[], hard_failed_names: string[], all_failed_names: string[]) -> testing.LeafIdentities { - 947 0 load_type 0 - 1 alloc_array 0 - 2 load_type 0 - 3 alloc_array 0 - 4 load_type 0 - 5 alloc_array 0 - 6 init_instance 0 (testing.LeafIdentities .passed, .failed, .tolerated) - 7 store_var 5 (out) - - 948 8 load_var 1 (selected_names) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 6 (_8) - 13 load_var 6 (_8) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 7 (_9) - 18 load_var 7 (_9) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +32 (to 53) - 22 load_var 7 (_9) - 23 store_var_load_var 8 (name) - - 949 24 load_var 3 (all_failed_names) - 25 call 885 ntypeargs=0 (testing.failure_matches_selected) - 26 pop_jump_if_false +2 (to 28) - 27 jump +8 (to 35) - - 956 28 load_type 0 - 29 load_var 5 (out) - 30 load_field 0 (passed) - 31 load_var 8 (name) - 32 call 4 ntypeargs=1 (baml.Array.push) - 33 pop 1 - 34 jump -21 (to 13) - - 950 35 load_var2 8 2 - 36 call 885 ntypeargs=0 (testing.failure_matches_selected) - 37 pop_jump_if_false +2 (to 39) - 38 jump +8 (to 46) - - 953 39 load_type 0 - 40 load_var 5 (out) - 41 load_field 2 (tolerated) - 42 load_var 8 (name) - 43 call 4 ntypeargs=1 (baml.Array.push) - 44 pop 1 - 45 jump -32 (to 13) - - 951 46 load_type 0 - 47 load_var 5 (out) - 48 load_field 1 (failed) - 49 load_var 8 (name) - 50 call 4 ntypeargs=1 (baml.Array.push) - 51 pop 1 - 52 jump -39 (to 13) - - 959 53 load_var 5 (out) - 54 store_var 4 (_0) - 55 load_var 4 (_0) - 56 return -} - -function testing.collect_all_failed_names(report: testing.TestSetReport, out: string[]) -> void { - 1049 0 load_var 1 (report) - 1 load_field 4 (failed_names) - 2 load_type 0 - 3 load_const 1 ("iter") - 4 virtual_call nargs=1 ntypeargs=0 - 5 store_var 4 (_4) - 6 load_var 4 (_4) - 7 load_type 2 - 8 load_const 3 ("next") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 5 (_5) - 11 load_var 5 (_5) - 12 is_type 4 - 13 pop_jump_if_false +2 (to 15) - 14 jump +12 (to 26) - 15 load_var 5 (_5) - 16 store_var_load_var 6 (name) - - 1050 17 load_var 2 (out) - 18 call 884 ntypeargs=0 (testing.name_in) - 19 unary_op ! - 20 pop_jump_if_false -14 (to 6) - - 1051 21 load_type 5 - 22 load_var2 2 6 - 23 call 4 ntypeargs=1 (baml.Array.push) - 24 pop 1 - 25 jump -19 (to 6) - - 1054 26 load_var 1 (report) - 27 load_field 5 (results) - 28 load_type 6 - 29 load_const 7 ("iter") - 30 virtual_call nargs=1 ntypeargs=0 - 31 store_var 7 (_16) - 32 load_var 7 (_16) - 33 load_type 8 - 34 load_const 9 ("next") - 35 virtual_call nargs=1 ntypeargs=0 - 36 store_var 8 (_17) - 37 load_var 8 (_17) - 38 is_type 4 - 39 pop_jump_if_false +2 (to 41) - 40 jump +12 (to 52) - 41 load_var 8 (_17) - 42 store_var_load_var 9 (child) - - 1055 43 is_type 10 - 44 pop_jump_if_false +2 (to 46) - 45 jump -13 (to 32) - 46 load_var 9 (child) - 47 store_var_load_var 10 (nested) - - 1057 48 load_var 2 (out) - 49 call 887 ntypeargs=0 (testing.collect_all_failed_names) - 50 pop 1 - 51 jump -19 (to 32) - - 1048 52 load_const 11 (null) - 53 store_var 3 (_0) - 54 load_var 3 (_0) - 55 return -} - -function testing.collect_leaf_identities(report: testing.TestSetReport, tolerated_by_parent: bool, selected_names: string[], out: testing.LeafIdentities) -> void { - 993 0 load_var 1 (report) - 1 load_field 6 (result_names) - 2 store_var_load_var 5 (_5) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +2 (to 7) - 6 jump +157 (to 163) - 7 load_var 5 (_5) - 8 store_var 6 (names) - - 996 9 load_var 6 (names) - 10 container_len - 11 store_var 8 (_10) - 12 load_var 1 (report) - 13 load_field 5 (results) - 14 container_len - 15 store_var 9 (_11) - 16 load_var2 8 9 - 17 cmp_int_op < - 18 pop_jump_if_false +2 (to 20) - 19 jump +6 (to 25) - - 999 20 load_var 1 (report) - 21 load_field 5 (results) - 22 container_len - 23 store_var 7 (limit) - 24 jump +4 (to 28) - - 997 25 load_var 6 (names) - 26 container_len - 27 store_var 7 (limit) - - 1001 28 load_const 1 (0) - 29 store_var 10 (i) - 30 load_var2 10 7 - 31 cmp_int_op < - 32 pop_jump_if_false +2 (to 34) - 33 jump +3 (to 36) - - 995 34 load_const 0 (null) - - 993 35 jump +129 (to 164) - - 1002 36 load_var2 6 10 - 37 load_array_element - 38 store_var 11 (name) - - 1003 39 load_var 1 (report) - 40 load_field 5 (results) - 41 load_var 10 (i) - 42 load_array_element - 43 store_var 12 (_22) - 44 load_var 12 (_22) - 45 store_var 13 (_25) - 46 load_var 13 (_25) - 47 narrow_bind 2 13 - 48 pop_jump_if_false +2 (to 50) - 49 jump +79 (to 128) - 50 load_var 12 (_22) - 51 store_var 15 (nested) - - 1014 52 load_var 2 (tolerated_by_parent) - 53 jump_if_false +3 (to 56) - 54 store_var 16 (nested_tolerated) - 55 jump +7 (to 62) - 56 pop 1 - 57 load_var 15 (nested) - 58 load_field 0 (outcome) - 59 load_const 3 ("pass") - 60 call 672 ntypeargs=0 (baml.ops.equals_equals) - 61 store_var 16 (nested_tolerated) - - 1015 62 load_var 15 (nested) - 63 load_field 5 (results) - 64 container_len - 65 store_var 17 (_42) - 66 load_var 17 (_42) - 67 load_const 1 (0) - 68 cmp_int_op > - 69 pop_jump_if_false +2 (to 71) - 70 jump +53 (to 123) - - 1022 71 load_var 15 (nested) - 72 load_field 2 (failed) - 73 load_const 1 (0) - 74 cmp_int_op > - 75 pop_jump_if_false +83 (to 158) - - 1023 76 load_var 11 (name) - 77 load_const 4 ("::(failed to expand)") - 78 bin_op + - 79 store_var_load_var 18 (sentinel) - - 1024 80 load_var 3 (selected_names) - 81 call 884 ntypeargs=0 (testing.name_in) - 82 pop_jump_if_false +2 (to 84) - 83 jump +21 (to 104) - - 1026 84 load_var 15 (nested) - 85 load_field 4 (failed_names) - 86 container_len - 87 store_var 20 (_54) - 88 load_var 20 (_54) - 89 load_const 1 (0) - 90 cmp_int_op > - 91 pop_jump_if_false +2 (to 93) - 92 jump +6 (to 98) - - 1029 93 load_var 11 (name) - 94 load_const 5 ("::(testset error)") - 95 bin_op + - 96 store_var 19 (identity) - - 1026 97 jump +9 (to 106) - - 1027 98 load_var 15 (nested) - 99 load_field 4 (failed_names) - 100 load_const 1 (0) - 101 load_array_element - 102 store_var 19 (identity) - - 1026 103 jump +3 (to 106) - - 1025 104 load_var 18 (sentinel) - 105 store_var 19 (identity) - - 1031 106 load_var 16 (nested_tolerated) - 107 pop_jump_if_false +2 (to 109) - 108 jump +8 (to 116) - - 1034 109 load_type 6 - 110 load_var 4 (out) - 111 load_field 1 (failed) - 112 load_var 19 (identity) - 113 call 4 ntypeargs=1 (baml.Array.push) - 114 pop 1 - 115 jump +43 (to 158) - - 1032 116 load_type 6 - 117 load_var 4 (out) - 118 load_field 2 (tolerated) - 119 load_var 19 (identity) - 120 call 4 ntypeargs=1 (baml.Array.push) - 121 pop 1 - 122 jump +36 (to 158) - - 1017 123 load_var2 15 16 - - 1018 124 load_var2 3 4 - - 1016 125 call 886 ntypeargs=0 (testing.collect_leaf_identities) - 126 pop 1 - 127 jump +31 (to 158) - - 1003 128 load_var 13 (_25) - 129 store_var_load_var 14 (leaf) - - 1005 130 load_field 0 (outcome) - 131 load_const 7 ("pass") - 132 call 672 ntypeargs=0 (baml.ops.equals_equals) - 133 pop_jump_if_false +2 (to 135) - 134 jump +18 (to 152) - - 1007 135 load_var 2 (tolerated_by_parent) - 136 pop_jump_if_false +2 (to 138) - 137 jump +8 (to 145) - - 1010 138 load_type 6 - 139 load_var 4 (out) - 140 load_field 1 (failed) - 141 load_var 11 (name) - 142 call 4 ntypeargs=1 (baml.Array.push) - 143 pop 1 - 144 jump +14 (to 158) - - 1008 145 load_type 6 - 146 load_var 4 (out) - 147 load_field 2 (tolerated) - 148 load_var 11 (name) - 149 call 4 ntypeargs=1 (baml.Array.push) - 150 pop 1 - 151 jump +7 (to 158) - - 1006 152 load_type 6 - 153 load_var 4 (out) - 154 load_field 0 (passed) - 155 load_var 11 (name) - 156 call 4 ntypeargs=1 (baml.Array.push) - 157 pop 1 - - 1001 158 load_var 10 (i) - 159 load_const 8 (1) - 160 add_int - 161 store_var 10 (i) - 162 jump -132 (to 30) - - 994 163 load_const 0 (null) - 164 return -} - -function testing.collect_leaf_messages(results: (testing.TestReport | testing.TestSetReport)[], out: string[]) -> void { - 1065 0 load_var 1 (results) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 4 (_3) - 5 load_var 4 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 5 (_4) - 10 load_var 5 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +52 (to 65) - 14 load_var 5 (_4) - 15 store_var 6 (r) - - 1066 16 load_var 6 (r) - 17 store_var 7 (_8) - 18 load_var 7 (_8) - 19 narrow_bind 5 7 - 20 pop_jump_if_false +2 (to 22) - 21 jump +8 (to 29) - 22 load_var 6 (r) - 23 store_var_load_var 14 (tsr) - - 1077 24 load_field 5 (results) - 25 load_var 2 (out) - 26 call 888 ntypeargs=0 (testing.collect_leaf_messages) - 27 pop 1 - 28 jump -23 (to 5) - - 1066 29 load_var 7 (_8) - 30 store_var_load_var 8 (tr) - - 1068 31 load_field 1 (runs) - 32 load_type 6 - 33 load_const 7 ("iter") - 34 virtual_call nargs=1 ntypeargs=0 - 35 store_var 9 (_11) - 36 load_var 9 (_11) - 37 load_type 8 - 38 load_const 9 ("next") - 39 virtual_call nargs=1 ntypeargs=0 - 40 store_var 10 (_12) - 41 load_var 10 (_12) - 42 is_type 4 - 43 pop_jump_if_false +2 (to 45) - 44 jump -39 (to 5) - 45 load_var 10 (_12) - 46 store_var_load_var 11 (run) - - 1069 47 load_field 0 (outcome) - 48 load_const 10 ("pass") - 49 call 672 ntypeargs=0 (baml.ops.equals_equals) - 50 unary_op ! - 51 pop_jump_if_false -15 (to 36) - - 1070 52 load_var 11 (run) - 53 load_field 2 (message) - 54 store_var 12 (_20) - 55 load_var 12 (_20) - 56 narrow_bind 11 12 - 57 pop_jump_if_false -21 (to 36) - 58 load_var 12 (_20) - 59 store_var 13 (m) - - 1071 60 load_type 12 - 61 load_var2 2 13 - 62 call 4 ntypeargs=1 (baml.Array.push) - 63 pop 1 - 64 jump -28 (to 36) - - 1064 65 load_const 13 (null) - 66 store_var 3 (_0) - 67 load_var 3 (_0) - 68 return -} - -function testing.collect_leaf_names(registry: testing.TestRegistry) -> string[] { - 744 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (out) - - 745 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_5) - 15 load_var 5 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +9 (to 27) - 19 load_var 5 (_5) - 20 store_var 6 (t) - - 746 21 load_type 0 - 22 load_var2 3 6 - 23 load_field 0 (name) - 24 call 4 ntypeargs=1 (baml.Array.push) - 25 pop 1 - 26 jump -16 (to 10) - - 748 27 load_var 1 (registry) - 28 load_field 0 (collector) - 29 load_field 2 (testsets) - 30 load_type 6 - 31 load_const 7 ("iter") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 7 (_13) - 34 load_var 7 (_13) - 35 load_type 8 - 36 load_const 9 ("next") - 37 virtual_call nargs=1 ntypeargs=0 - 38 store_var 8 (_14) - 39 load_var 8 (_14) - 40 is_type 5 - 41 pop_jump_if_false +2 (to 43) - 42 jump +25 (to 67) - 43 load_var 8 (_14) - 44 store_var 9 (ts) - - 749 45 load_var2 1 9 - 46 call 879 ntypeargs=0 (testing.collect_subtree_names) - 47 load_type 10 - 48 load_const 11 ("iter") - 49 virtual_call nargs=1 ntypeargs=0 - 50 store_var 10 (_20) - 51 load_var 10 (_20) - 52 load_type 12 - 53 load_const 13 ("next") - 54 virtual_call nargs=1 ntypeargs=0 - 55 store_var 11 (_21) - 56 load_var 11 (_21) - 57 is_type 5 - 58 pop_jump_if_false +2 (to 60) - 59 jump -25 (to 34) - 60 load_var 11 (_21) - 61 store_var 12 (name) - - 750 62 load_type 0 - 63 load_var2 3 12 - 64 call 4 ntypeargs=1 (baml.Array.push) - 65 pop 1 - 66 jump -15 (to 51) - - 753 67 load_var 3 (out) - 68 store_var 2 (_0) - 69 load_var 2 (_0) - 70 return -} - -function testing.collect_subtree_names(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> string[] { - 762 0 load_var2 1 2 - 1 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - 2 call 878 ntypeargs=0 (testing.collect_leaf_names) - 3 jump +91 (to 94) - 4 load_var 3 (e) - 5 store_var 4 (_5) - 6 load_var 4 (_5) - 7 narrow_bind 0 4 - 8 pop_jump_if_false +2 (to 10) - 9 jump +81 (to 90) - 10 load_var 3 (e) - 11 is_type 1 - 12 pop_jump_if_false +2 (to 14) - 13 jump +70 (to 83) - 14 load_var 3 (e) - 15 is_type 2 - 16 pop_jump_if_false +2 (to 18) - 17 jump +66 (to 83) - 18 load_var 3 (e) - 19 is_type 3 - 20 pop_jump_if_false +2 (to 22) - 21 jump +62 (to 83) - 22 load_var 3 (e) - 23 is_type 4 - 24 pop_jump_if_false +2 (to 26) - 25 jump +58 (to 83) - 26 load_var 3 (e) - 27 is_type 5 - 28 pop_jump_if_false +2 (to 30) - 29 jump +54 (to 83) - 30 load_var 3 (e) - 31 is_type 6 - 32 pop_jump_if_false +2 (to 34) - 33 jump +50 (to 83) - 34 load_var 3 (e) - 35 is_type 7 - 36 pop_jump_if_false +2 (to 38) - 37 jump +46 (to 83) - 38 load_var 3 (e) - 39 is_type 8 - 40 pop_jump_if_false +2 (to 42) - 41 jump +42 (to 83) - 42 load_var 3 (e) - 43 is_type 9 - 44 pop_jump_if_false +2 (to 46) - 45 jump +38 (to 83) - 46 load_var 3 (e) - 47 is_type 10 - 48 pop_jump_if_false +2 (to 50) - 49 jump +34 (to 83) - 50 load_var 3 (e) - 51 is_type 11 - 52 pop_jump_if_false +2 (to 54) - 53 jump +30 (to 83) - 54 load_var 3 (e) - 55 is_type 12 - 56 pop_jump_if_false +2 (to 58) - 57 jump +26 (to 83) - 58 load_var 3 (e) - 59 is_type 13 - 60 pop_jump_if_false +2 (to 62) - 61 jump +22 (to 83) - 62 load_var 3 (e) - 63 is_type 14 - 64 pop_jump_if_false +2 (to 66) - 65 jump +18 (to 83) - 66 load_var 3 (e) - 67 is_type 15 - 68 pop_jump_if_false +2 (to 70) - 69 jump +14 (to 83) - 70 load_var 3 (e) - 71 is_type 16 - 72 pop_jump_if_false +2 (to 74) - 73 jump +10 (to 83) - 74 load_var 3 (e) - 75 throw_if_panic - - 765 76 load_var 2 (ts) - 77 load_field 0 (name) - 78 load_const 17 ("::(failed to expand)") - 79 bin_op + - 80 load_type 18 - 81 alloc_array 1 - - 762 82 jump +12 (to 94) - - 764 83 load_var 2 (ts) - 84 load_field 0 (name) - 85 load_const 19 ("::(failed to expand)") - 86 bin_op + - 87 load_type 18 - 88 alloc_array 1 - - 762 89 jump +5 (to 94) - 90 load_var 4 (_5) - 91 store_var 5 (err) - - 763 92 load_var 5 (err) - 93 throw - 94 return -} - -function testing.collect_subtree_names_layered(registry: testing.TestRegistry, ts: testing.TestSetRegistration, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 778 0 load_var2 1 2 - 1 call 856 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) - - 777 2 load_var2 3 4 - 3 load_var2 5 6 - 4 call 876 ntypeargs=0 (testing.select_names_layered) - 5 jump +111 (to 116) - 6 load_var 7 (e) - 7 store_var 8 (_9) - 8 load_var 8 (_9) - 9 narrow_bind 0 8 - 10 pop_jump_if_false +2 (to 12) - 11 jump +101 (to 112) - 12 load_var 7 (e) - 13 is_type 1 - 14 pop_jump_if_false +2 (to 16) - 15 jump +80 (to 95) - 16 load_var 7 (e) - 17 is_type 2 - 18 pop_jump_if_false +2 (to 20) - 19 jump +76 (to 95) - 20 load_var 7 (e) - 21 is_type 3 - 22 pop_jump_if_false +2 (to 24) - 23 jump +72 (to 95) - 24 load_var 7 (e) - 25 is_type 4 - 26 pop_jump_if_false +2 (to 28) - 27 jump +68 (to 95) - 28 load_var 7 (e) - 29 is_type 5 - 30 pop_jump_if_false +2 (to 32) - 31 jump +64 (to 95) - 32 load_var 7 (e) - 33 is_type 6 - 34 pop_jump_if_false +2 (to 36) - 35 jump +60 (to 95) - 36 load_var 7 (e) - 37 is_type 7 - 38 pop_jump_if_false +2 (to 40) - 39 jump +56 (to 95) - 40 load_var 7 (e) - 41 is_type 8 - 42 pop_jump_if_false +2 (to 44) - 43 jump +52 (to 95) - 44 load_var 7 (e) - 45 is_type 9 - 46 pop_jump_if_false +2 (to 48) - 47 jump +48 (to 95) - 48 load_var 7 (e) - 49 is_type 10 - 50 pop_jump_if_false +2 (to 52) - 51 jump +44 (to 95) - 52 load_var 7 (e) - 53 is_type 11 - 54 pop_jump_if_false +2 (to 56) - 55 jump +40 (to 95) - 56 load_var 7 (e) - 57 is_type 12 - 58 pop_jump_if_false +2 (to 60) - 59 jump +36 (to 95) - 60 load_var 7 (e) - 61 is_type 13 - 62 pop_jump_if_false +2 (to 64) - 63 jump +32 (to 95) - 64 load_var 7 (e) - 65 is_type 14 - 66 pop_jump_if_false +2 (to 68) - 67 jump +28 (to 95) - 68 load_var 7 (e) - 69 is_type 15 - 70 pop_jump_if_false +2 (to 72) - 71 jump +24 (to 95) - 72 load_var 7 (e) - 73 is_type 16 - 74 pop_jump_if_false +2 (to 76) - 75 jump +20 (to 95) - 76 load_var 7 (e) - 77 throw_if_panic - - 802 78 load_var 2 (ts) - 79 load_field 0 (name) - 80 load_const 17 ("::(failed to expand)") - 81 bin_op + - 82 store_var_load_var 11 (sentinel) - - 805 83 load_var2 3 4 - 84 load_var2 5 6 - - 804 85 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 803 86 pop_jump_if_false +2 (to 88) - 87 jump +4 (to 91) - - 814 88 load_type 18 - 89 alloc_array 0 - - 803 90 jump +26 (to 116) - - 812 91 load_var 11 (sentinel) - 92 load_type 18 - 93 alloc_array 1 - - 803 94 jump +22 (to 116) - - 786 95 load_var 2 (ts) - 96 load_field 0 (name) - 97 load_const 19 ("::(failed to expand)") - 98 bin_op + - 99 store_var_load_var 10 (sentinel) - - 789 100 load_var2 3 4 - 101 load_var2 5 6 - - 788 102 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 787 103 pop_jump_if_false +2 (to 105) - 104 jump +4 (to 108) - - 798 105 load_type 18 - 106 alloc_array 0 - - 787 107 jump +9 (to 116) - - 796 108 load_var 10 (sentinel) - 109 load_type 18 - 110 alloc_array 1 - - 787 111 jump +5 (to 116) - - 777 112 load_var 8 (_9) - 113 store_var 9 (err) - - 784 114 load_var 9 (err) - 115 throw - 116 return -} - -function testing.count_leaves(results: (testing.TestReport | testing.TestSetReport)[], tolerated_by_parent: bool) -> testing.LeafCounts { - 838 0 load_const 0 (0) - 1 store_var 3 (passed) - - 839 2 load_const 0 (0) - 3 store_var 4 (failed) - - 840 4 load_const 0 (0) - 5 store_var 5 (tolerated) - - 841 6 load_const 0 (0) - 7 store_var 6 (total) - - 842 8 load_var 1 (results) - 9 load_type 1 - 10 load_const 2 ("iter") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 7 (_7) - 13 load_var 7 (_7) - 14 load_type 3 - 15 load_const 4 ("next") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 8 (_8) - 18 load_var 8 (_8) - 19 is_type 5 - 20 pop_jump_if_false +2 (to 22) - 21 jump +106 (to 127) - 22 load_var 8 (_8) - 23 store_var 9 (r) - - 843 24 load_var 9 (r) - 25 store_var 11 (_13) - 26 load_var 11 (_13) - 27 narrow_bind 6 11 - 28 pop_jump_if_false +2 (to 30) - 29 jump +51 (to 80) - 30 load_var 9 (r) - 31 store_var 13 (tsr) - - 854 32 load_var 2 (tolerated_by_parent) - 33 jump_if_false +3 (to 36) - 34 store_var 14 (ft) - 35 jump +7 (to 42) - 36 pop 1 - 37 load_var 13 (tsr) - 38 load_field 0 (outcome) - 39 load_const 7 ("pass") - 40 call 672 ntypeargs=0 (baml.ops.equals_equals) - 41 store_var 14 (ft) - - 855 42 load_var 13 (tsr) - 43 load_field 5 (results) - 44 container_len - 45 store_var 15 (_21) - 46 load_var 15 (_21) - 47 load_const 0 (0) - 48 cmp_int_op > - 49 pop_jump_if_false +2 (to 51) - 50 jump +24 (to 74) - - 857 51 load_var 14 (ft) - 52 pop_jump_if_false +2 (to 54) - 53 jump +11 (to 64) - - 866 54 load_var 13 (tsr) - 55 load_field 1 (passed) - - 867 56 load_var 13 (tsr) - 57 load_field 2 (failed) - 58 load_const 0 (0) - - 869 59 load_var 13 (tsr) - 60 load_field 3 (total) - 61 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 62 store_var 10 (delta) - - 857 63 jump +47 (to 110) - - 859 64 load_var 13 (tsr) - 65 load_field 1 (passed) - 66 load_const 0 (0) - - 861 67 load_var 13 (tsr) - 68 load_field 2 (failed) - - 862 69 load_var 13 (tsr) - 70 load_field 3 (total) - 71 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 72 store_var 10 (delta) - - 857 73 jump +37 (to 110) - - 856 74 load_var 13 (tsr) - 75 load_field 5 (results) - 76 load_var 14 (ft) - 77 call 881 ntypeargs=0 (testing.count_leaves) - 78 store_var 10 (delta) - 79 jump +31 (to 110) - - 843 80 load_var 11 (_13) - 81 store_var_load_var 12 (tr) - - 845 82 load_field 0 (outcome) - 83 load_const 8 ("pass") - 84 call 672 ntypeargs=0 (baml.ops.equals_equals) - 85 pop_jump_if_false +2 (to 87) - 86 jump +18 (to 104) - - 847 87 load_var 2 (tolerated_by_parent) - 88 pop_jump_if_false +2 (to 90) - 89 jump +8 (to 97) - - 850 90 load_const 0 (0) - 91 load_const 9 (1) - 92 load_const 0 (0) - 93 load_const 9 (1) - 94 init_instance 2 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 95 store_var 10 (delta) - - 847 96 jump +14 (to 110) - - 848 97 load_const 0 (0) - 98 load_const 0 (0) - 99 load_const 9 (1) - 100 load_const 9 (1) - 101 init_instance 3 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 102 store_var 10 (delta) - - 847 103 jump +7 (to 110) - - 846 104 load_const 9 (1) - 105 load_const 0 (0) - 106 load_const 0 (0) - 107 load_const 9 (1) - 108 init_instance 4 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 109 store_var 10 (delta) - - 874 110 load_var2 3 10 - 111 load_field 0 (passed) - 112 add_int - 113 store_var 3 (passed) - - 875 114 load_var2 4 10 - 115 load_field 1 (failed) - 116 add_int - 117 store_var 4 (failed) - - 876 118 load_var2 5 10 - 119 load_field 2 (tolerated) - 120 add_int - 121 store_var 5 (tolerated) - - 877 122 load_var2 6 10 - 123 load_field 3 (total) - 124 add_int - 125 store_var 6 (total) - - 842 126 jump -113 (to 13) - - 879 127 load_var2 3 4 - 128 load_var2 5 6 - 129 init_instance 5 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 130 return -} - -function testing.expansion_error_report(name: string) -> testing.TestSetReport { - 553 0 load_const 0 ("error") - 1 load_const 1 (0) - 2 load_const 2 (1) - 3 load_const 2 (1) - - 564 4 load_var 1 (name) - 5 load_const 3 ("::(testset error)") - 6 bin_op + - 7 load_type 4 - 8 alloc_array 1 - - 565 9 load_type 5 - 10 alloc_array 0 - - 566 11 load_type 4 - 12 alloc_array 0 - 13 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) - 14 store_var 2 (_0) - 15 load_var 2 (_0) - 16 return -} - -function testing.failure_matches_selected(selected: string, failed_names: string[]) -> bool { - 972 0 load_var2 1 2 - 1 call 884 ntypeargs=0 (testing.name_in) - 2 pop_jump_if_false +2 (to 4) - 3 jump +43 (to 46) - - 975 4 load_const 0 ("::(failed to expand)") - 5 store_var 3 (sentinel_suffix) - - 976 6 load_var2 1 3 - 7 call 149 ntypeargs=0 (baml.String.ends_with) - 8 pop_jump_if_false +36 (to 44) - - 977 9 load_var 1 (selected) - 10 call 139 ntypeargs=0 (baml.String.length) - 11 store_var 5 (_10) - 12 load_var 3 (sentinel_suffix) - 13 call 139 ntypeargs=0 (baml.String.length) - 14 store_var 6 (_11) - 15 load_var 1 (selected) - 16 load_const 1 (0) - 17 load_var2 5 6 - 18 sub_int - 19 call 153 ntypeargs=0 (baml.String.slice) - 20 load_const 2 ("::") - 21 bin_op + - 22 store_var 4 (prefix) - - 978 23 load_var 2 (failed_names) - 24 load_type 3 - 25 load_const 4 ("iter") - 26 virtual_call nargs=1 ntypeargs=0 - 27 store_var 7 (_12) - 28 load_var 7 (_12) - 29 load_type 5 - 30 load_const 6 ("next") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 8 (_13) - 33 load_var 8 (_13) - 34 is_type 7 - 35 pop_jump_if_false +2 (to 37) - 36 jump +8 (to 44) - 37 load_var 8 (_13) - 38 store_var 9 (failed) - - 979 39 load_var2 9 4 - 40 call 148 ntypeargs=0 (baml.String.starts_with) - 41 pop_jump_if_false -13 (to 28) - - 980 42 load_const 8 (true) - 43 jump +4 (to 47) - - 984 44 load_const 9 (false) - 45 jump +2 (to 47) - - 973 46 load_const 8 (true) - 47 return -} - -function testing.flatten_with_tolerated(report: testing.TestSetReport, selected_names: string[]) -> testing.FlatTestReport { - 887 0 load_var 1 (report) - 1 load_field 0 (outcome) - 2 load_const 0 ("pass") - 3 call 672 ntypeargs=0 (baml.ops.equals_equals) - 4 store_var 3 (top_tolerated) - - 888 5 load_var 1 (report) - 6 load_field 5 (results) - 7 container_len - 8 store_var 5 (_7) - 9 load_var 5 (_7) - 10 load_const 1 (0) - 11 cmp_int_op > - 12 pop_jump_if_false +2 (to 14) - 13 jump +24 (to 37) - - 890 14 load_var 3 (top_tolerated) - 15 pop_jump_if_false +2 (to 17) - 16 jump +11 (to 27) - - 899 17 load_var 1 (report) - 18 load_field 1 (passed) - - 900 19 load_var 1 (report) - 20 load_field 2 (failed) - 21 load_const 1 (0) - - 902 22 load_var 1 (report) - 23 load_field 3 (total) - 24 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 25 store_var 4 (counts) - - 890 26 jump +16 (to 42) - - 892 27 load_var 1 (report) - 28 load_field 1 (passed) - 29 load_const 1 (0) - - 894 30 load_var 1 (report) - 31 load_field 2 (failed) - - 895 32 load_var 1 (report) - 33 load_field 3 (total) - 34 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) - 35 store_var 4 (counts) - - 890 36 jump +6 (to 42) - - 889 37 load_var 1 (report) - 38 load_field 5 (results) - 39 load_var 3 (top_tolerated) - 40 call 881 ntypeargs=0 (testing.count_leaves) - 41 store_var 4 (counts) - - 905 42 load_type 2 - 43 alloc_array 0 - 44 store_var 6 (messages) - - 906 45 load_var 1 (report) - 46 load_field 5 (results) - 47 load_var 6 (messages) - 48 call 888 ntypeargs=0 (testing.collect_leaf_messages) - 49 pop 1 - - 907 50 load_type 2 - 51 alloc_array 0 - 52 store_var 7 (all_failed_names) - - 908 53 load_var2 1 7 - 54 call 887 ntypeargs=0 (testing.collect_all_failed_names) - 55 pop 1 - - 909 56 load_type 2 - 57 alloc_array 0 - 58 load_type 2 - 59 alloc_array 0 - 60 load_type 2 - 61 alloc_array 0 - 62 init_instance 2 (testing.LeafIdentities .passed, .failed, .tolerated) - 63 store_var 8 (executed) - - 910 64 load_var2 1 3 - 65 load_var2 2 8 - 66 call 886 ntypeargs=0 (testing.collect_leaf_identities) - 67 pop 1 - - 916 68 load_var 8 (executed) - 69 load_field 0 (passed) - 70 container_len - 71 store_var 10 (_36) - 72 load_var2 10 4 - 73 load_field 0 (passed) - 74 cmp_int_op == - 75 jump_if_false +9 (to 84) - 76 pop 1 - - 917 77 load_var 8 (executed) - 78 load_field 1 (failed) - 79 container_len - 80 store_var 11 (_39) - 81 load_var2 11 4 - 82 load_field 1 (failed) - 83 cmp_int_op == - - 916 84 jump_if_false +9 (to 93) - 85 pop 1 - - 918 86 load_var 8 (executed) - 87 load_field 2 (tolerated) - 88 container_len - 89 store_var 12 (_42) - 90 load_var2 12 4 - 91 load_field 2 (tolerated) - 92 cmp_int_op == - - 915 93 pop_jump_if_false +2 (to 95) - 94 jump +24 (to 118) - - 921 95 load_var 2 (selected_names) - 96 container_len - 97 store_var 13 (_46) - 98 load_var2 13 4 - 99 load_field 3 (total) - 100 cmp_int_op == - 101 pop_jump_if_false +2 (to 103) - 102 jump +10 (to 112) - - 927 103 load_type 2 - 104 alloc_array 0 - 105 load_type 2 - 106 alloc_array 0 - 107 load_type 2 - 108 alloc_array 0 - 109 init_instance 3 (testing.LeafIdentities .passed, .failed, .tolerated) - 110 store_var 9 (identities) - - 921 111 jump +9 (to 120) - - 922 112 load_var2 2 1 - 113 load_field 4 (failed_names) - 114 load_var 7 (all_failed_names) - 115 call 883 ntypeargs=0 (testing.classify_selected_names) - 116 store_var 9 (identities) - 117 jump +3 (to 120) - - 920 118 load_var 8 (executed) - 119 store_var 9 (identities) - - 930 120 load_var 1 (report) - 121 load_field 0 (outcome) - - 931 122 load_var 4 (counts) - 123 load_field 0 (passed) - - 932 124 load_var 4 (counts) - 125 load_field 1 (failed) - - 933 126 load_var 4 (counts) - 127 load_field 2 (tolerated) - - 934 128 load_var 4 (counts) - 129 load_field 3 (total) - - 935 130 load_var 9 (identities) - 131 load_field 0 (passed) - - 936 132 load_var 9 (identities) - 133 load_field 1 (failed) - - 937 134 load_var 9 (identities) - 135 load_field 2 (tolerated) - - 938 136 load_var 6 (messages) - 137 init_instance 4 (testing.FlatTestReport .outcome, .passed, .failed, .tolerated, .total, .passed_names, .failed_names, .tolerated_names, .messages) - 138 return -} - -function testing.glob_match(subject: string, pattern: string) -> bool { - 574 0 load_var 2 (pattern) - 1 load_const 0 ("*") - 2 call 150 ntypeargs=0 (baml.String.split) - 3 store_var 3 (parts) - - 575 4 load_var 3 (parts) - 5 container_len - 6 store_var 4 (n) - - 576 7 load_var 4 (n) - 8 load_const 1 (1) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +87 (to 98) - - 579 12 load_var 3 (parts) - 13 load_const 2 (0) - 14 load_array_element - 15 store_var 5 (first) - - 580 16 load_var2 3 4 - 17 load_const 1 (1) - 18 sub_int - 19 load_array_element - 20 store_var 6 (last) - - 581 21 load_var2 1 5 - 22 call 148 ntypeargs=0 (baml.String.starts_with) - 23 unary_op ! - 24 pop_jump_if_false +2 (to 26) - 25 jump +71 (to 96) - - 584 26 load_var2 1 6 - 27 call 149 ntypeargs=0 (baml.String.ends_with) - 28 unary_op ! - 29 pop_jump_if_false +2 (to 31) - 30 jump +64 (to 94) - - 587 31 load_var 5 (first) - 32 call 139 ntypeargs=0 (baml.String.length) - 33 store_var 7 (start) - - 588 34 load_var 1 (subject) - 35 call 139 ntypeargs=0 (baml.String.length) - 36 store_var 9 (_24) - 37 load_var 6 (last) - 38 call 139 ntypeargs=0 (baml.String.length) - 39 store_var 10 (_25) - 40 load_var2 9 10 - 41 sub_int - 42 store_var 8 (end_limit) - - 589 43 load_var2 7 8 - 44 cmp_int_op > - 45 pop_jump_if_false +2 (to 47) - 46 jump +46 (to 92) - - 592 47 load_var 7 (start) - 48 store_var 11 (pos) - - 593 49 load_const 1 (1) - 50 store_var 12 (i) - 51 load_var2 12 4 - 52 load_const 1 (1) - 53 sub_int - 54 cmp_int_op < - 55 pop_jump_if_false +2 (to 57) - 56 jump +3 (to 59) - - 603 57 load_const 3 (true) - 58 jump +45 (to 103) - - 594 59 load_var2 3 12 - 60 load_array_element - 61 store_var_load_var 13 (part) - - 595 62 load_const 4 ("") - 63 cmp_op != - 64 pop_jump_if_false +23 (to 87) - - 596 65 load_var2 1 11 - 66 load_var 8 (end_limit) - 67 call 153 ntypeargs=0 (baml.String.slice) - 68 load_var 13 (part) - 69 call 155 ntypeargs=0 (baml.String.index_of) - 70 store_var 14 (_45) - 71 load_var 14 (_45) - 72 narrow_bind 2 14 - 73 pop_jump_if_false +2 (to 75) - 74 jump +3 (to 77) - - 599 75 load_const 5 (false) - 76 jump +27 (to 103) - - 596 77 load_var 14 (_45) - 78 store_var 15 (idx) - - 597 79 load_var2 11 15 - 80 add_int - 81 store_var 16 (_47) - 82 load_var 13 (part) - 83 call 139 ntypeargs=0 (baml.String.length) - 84 load_var 16 (_47) - 85 add_int - 86 store_var 11 (pos) - - 593 87 load_var 12 (i) - 88 load_const 1 (1) - 89 add_int - 90 store_var 12 (i) - 91 jump -40 (to 51) - - 590 92 load_const 5 (false) - 93 jump +10 (to 103) - - 585 94 load_const 5 (false) - 95 jump +8 (to 103) - - 582 96 load_const 5 (false) - 97 jump +6 (to 103) - - 577 98 load_var2 1 2 - 99 call 155 ntypeargs=0 (baml.String.index_of) - 100 load_const 6 (null) - 101 call 672 ntypeargs=0 (baml.ops.equals_equals) - 102 unary_op ! - 103 return -} - -function testing.leaf_selected(name: string, include: string[], exclude: string[]) -> bool { - 618 0 load_var2 3 1 - 1 call 870 ntypeargs=0 (testing.any_pattern_matches) - 2 pop_jump_if_false +2 (to 4) - 3 jump +14 (to 17) - - 621 4 load_var 2 (include) - 5 container_len - 6 store_var 4 (_6) - 7 load_var 4 (_6) - 8 load_const 0 (0) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +4 (to 15) - - 624 12 load_var2 2 1 - 13 call 870 ntypeargs=0 (testing.any_pattern_matches) - 14 jump +4 (to 18) - - 622 15 load_const 1 (true) - 16 jump +2 (to 18) - - 619 17 load_const 2 (false) - 18 return -} - -function testing.leaf_selected_layered(name: string, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> bool { - 637 0 load_var2 1 2 - 1 load_var 3 (profile_exclude) - 2 call 871 ntypeargs=0 (testing.leaf_selected) - 3 jump_if_false +5 (to 8) - 4 pop 1 - - 638 5 load_var2 1 4 - 6 load_var 5 (cli_exclude) - 7 call 871 ntypeargs=0 (testing.leaf_selected) - 8 return -} - -function testing.name_in(name: string, names: string[]) -> bool { - 963 0 load_var 2 (names) - 1 load_type 0 - 2 load_const 1 ("iter") - 3 virtual_call nargs=1 ntypeargs=0 - 4 store_var 3 (_3) - 5 load_var 3 (_3) - 6 load_type 2 - 7 load_const 3 ("next") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 is_type 4 - 12 pop_jump_if_false +2 (to 14) - 13 jump +8 (to 21) - 14 load_var 4 (_4) - 15 store_var_load_var 5 (candidate) - - 964 16 load_var 1 (name) - 17 cmp_op == - 18 pop_jump_if_false -13 (to 5) - - 965 19 load_const 5 (true) - 20 jump +2 (to 22) - - 968 21 load_const 6 (false) - 22 return -} - -function testing.pattern_may_match_descendant(pattern: string, prefix: string) -> bool { - 666 0 load_var 2 (prefix) - 1 load_const 0 ("::") - 2 bin_op + - 3 store_var 3 (descendant_prefix) - - 667 4 load_var 1 (pattern) - 5 load_const 1 ("*") - 6 call 155 ntypeargs=0 (baml.String.index_of) - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 load_const 2 (null) - 10 cmp_op == - 11 pop_jump_if_false +2 (to 13) - 12 jump +16 (to 28) - 13 load_var 4 (_4) - 14 store_var 5 (star) - - 670 15 load_var 1 (pattern) - 16 load_const 3 (0) - 17 load_var 5 (star) - 18 call 153 ntypeargs=0 (baml.String.slice) - 19 store_var 6 (literal) - - 671 20 load_var2 3 6 - 21 call 148 ntypeargs=0 (baml.String.starts_with) - 22 jump_if_false +2 (to 24) - 23 jump +6 (to 29) - 24 pop 1 - 25 load_var2 6 3 - 26 call 148 ntypeargs=0 (baml.String.starts_with) - 27 jump +2 (to 29) - - 668 28 load_const 4 (true) - 29 return -} - -function testing.run_children_parallel(children: testing.TestSetChild[]) -> testing.TestSetReport { - 0 load_var 5 - 1 make_cell - 2 store_var 5 - - 484 3 load_type 0 - 4 alloc_array 0 - 5 store_var 2 (futures) - - 485 6 load_var 1 (children) - 7 load_type 1 - 8 load_const 2 ("iter") - 9 virtual_call nargs=1 ntypeargs=0 - 10 store_var 3 (_3) - 11 load_var 3 (_3) - 12 load_type 3 - 13 load_const 4 ("next") - 14 virtual_call nargs=1 ntypeargs=0 - 15 store_var 4 (_4) - 16 load_var 4 (_4) - 17 is_type 5 - 18 pop_jump_if_false +2 (to 20) - 19 jump +19 (to 38) - 20 load_const 6 (null) - 21 make_cell - 22 store_var 5 (child) - 23 load_var 4 (_4) - 24 store_deref 5 - - 486 25 load_var 5 (child) - 26 make_closure 1940 1 - 27 load_const 6 (null) - 28 load_const 6 (null) - 29 load_type 7 - 30 load_type 8 - 31 spawn - 32 store_var 6 (_11) - 33 load_type 0 - 34 load_var2 2 6 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -26 (to 11) - - 490 38 load_type 7 - 39 load_type 8 - 40 load_var 2 (futures) - 41 call 501 ntypeargs=2 (baml.future.all_complete) - 42 await - - 491 43 call 864 ntypeargs=0 (testing.aggregate_reports) - 44 return -} - -function testing.run_children_sequential(children: testing.TestSetChild[], fail_fast: bool) -> testing.TestSetReport { - 110 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (named_results) - - 111 3 load_var 1 (children) - 4 load_type 1 - 5 load_const 2 ("iter") - 6 virtual_call nargs=1 ntypeargs=0 - 7 store_var 4 (_4) - 8 load_var 4 (_4) - 9 load_type 3 - 10 load_const 4 ("next") - 11 virtual_call nargs=1 ntypeargs=0 - 12 store_var 5 (_5) - 13 load_var 5 (_5) - 14 is_type 5 - 15 pop_jump_if_false +2 (to 17) - 16 jump +41 (to 57) - 17 load_var 5 (_5) - 18 store_var_load_var 6 (child) - - 112 19 load_field 1 (run) - 20 call_indirect - 21 store_var 7 (report) - - 113 22 load_type 0 - 23 load_var2 3 6 - 24 load_field 0 (name) - 25 load_var 7 (report) - 26 init_instance 0 (testing.NamedChildReport .name, .report) - 27 call 4 ntypeargs=1 (baml.Array.push) - 28 pop 1 - - 114 29 load_var 7 (report) - 30 store_var 9 (_17) - 31 load_var 9 (_17) - 32 narrow_bind 6 9 - 33 pop_jump_if_false +2 (to 35) - 34 jump +7 (to 41) - 35 load_var 7 (report) - 36 store_var 11 (r) - - 116 37 load_var 11 (r) - 38 load_field 0 (outcome) - 39 store_var 8 (outcome) - - 114 40 jump +6 (to 46) - 41 load_var 9 (_17) - 42 store_var 10 (r) - - 115 43 load_var 10 (r) - 44 load_field 0 (outcome) - 45 store_var 8 (outcome) - - 118 46 load_var 2 (fail_fast) - 47 jump_if_false +6 (to 53) - 48 pop 1 - 49 load_var 8 (outcome) - 50 load_const 7 ("pass") - 51 call 672 ntypeargs=0 (baml.ops.equals_equals) - 52 unary_op ! - 53 pop_jump_if_false -45 (to 8) - - 119 54 load_var 3 (named_results) - 55 call 864 ntypeargs=0 (testing.aggregate_reports) - 56 jump +3 (to 59) - - 124 57 load_var 3 (named_results) - 58 call 864 ntypeargs=0 (testing.aggregate_reports) - 59 return -} - -function testing.run_test(body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestReport { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - - 496 3 load_var 1 (body) - 4 make_closure 1952 1 - 5 store_var 3 (base_run) - - 527 6 load_var 2 (runner) - 7 load_const 0 (null) - 8 cmp_op == - 9 pop_jump_if_false +2 (to 11) - 10 jump +7 (to 17) - 11 load_var 2 (runner) - 12 store_var 4 (r) - - 530 13 load_var2 3 4 - 14 call_indirect - - 531 15 call_indirect - 16 jump +3 (to 19) - - 528 17 load_var 3 (base_run) - 18 call_indirect - 19 return -} - -function testing.run_testset(children: testing.TestSetChild[], runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> testing.TestSetReport { - 538 0 load_var 2 (runner) - 1 load_const 0 (null) - 2 cmp_op == - 3 pop_jump_if_false +2 (to 5) - 4 jump +6 (to 10) - 5 load_var 2 (runner) - 6 store_var 3 (r) - - 540 7 load_var2 1 3 - 8 call_indirect - 9 jump +3 (to 12) - - 539 10 load_var 1 (children) - 11 call 865 ntypeargs=0 (testing.run_children_parallel) - 12 return -} - -function testing.select_names(registry: testing.TestRegistry, include: string[], exclude: string[]) -> string[] { - 739 0 load_var 1 (registry) - 1 load_type 0 - 2 alloc_array 0 - 3 load_type 0 - 4 alloc_array 0 - 5 load_var2 2 3 - 6 call 876 ntypeargs=0 (testing.select_names_layered) - 7 return -} - -function testing.select_names_layered(registry: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - 700 0 load_type 0 - 1 alloc_array 0 - 2 store_var 7 (out) - - 701 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 8 (_8) - 10 load_var 8 (_8) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 9 (_9) - 15 load_var 9 (_9) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +14 (to 32) - 19 load_var 9 (_9) - 20 store_var_load_var 10 (t) - - 704 21 load_field 0 (name) - 22 load_var2 2 3 - 23 load_var2 4 5 - - 703 24 call 872 ntypeargs=0 (testing.leaf_selected_layered) - - 702 25 pop_jump_if_false -15 (to 10) - - 711 26 load_type 0 - 27 load_var2 7 10 - 28 load_field 0 (name) - 29 call 4 ntypeargs=1 (baml.Array.push) - 30 pop 1 - 31 jump -21 (to 10) - - 714 32 load_var 1 (registry) - 33 load_field 0 (collector) - 34 load_field 2 (testsets) - 35 load_type 6 - 36 load_const 7 ("iter") - 37 virtual_call nargs=1 ntypeargs=0 - 38 store_var 11 (_19) - 39 load_var 11 (_19) - 40 load_type 8 - 41 load_const 9 ("next") - 42 virtual_call nargs=1 ntypeargs=0 - 43 store_var 12 (_20) - 44 load_var 12 (_20) - 45 is_type 5 - 46 pop_jump_if_false +2 (to 48) - 47 jump +37 (to 84) - 48 load_var 12 (_20) - 49 store_var_load_var 13 (ts) - - 718 50 load_field 0 (name) - 51 load_var2 2 3 - 52 call 875 ntypeargs=0 (testing.subtree_may_be_selected) - 53 jump_if_false +6 (to 59) - 54 pop 1 - - 719 55 load_var 13 (ts) - 56 load_field 0 (name) - 57 load_var2 4 5 - 58 call 875 ntypeargs=0 (testing.subtree_may_be_selected) - - 717 59 pop_jump_if_false -20 (to 39) - - 721 60 load_var2 1 13 - - 723 61 load_var2 2 3 - 62 load_var2 4 5 - - 721 63 call 880 ntypeargs=0 (testing.collect_subtree_names_layered) - - 729 64 load_type 10 - 65 load_const 11 ("iter") - 66 virtual_call nargs=1 ntypeargs=0 - 67 store_var 14 (_31) - 68 load_var 14 (_31) - 69 load_type 12 - 70 load_const 13 ("next") - 71 virtual_call nargs=1 ntypeargs=0 - 72 store_var 15 (_32) - 73 load_var 15 (_32) - 74 is_type 5 - 75 pop_jump_if_false +2 (to 77) - 76 jump -37 (to 39) - 77 load_var 15 (_32) - 78 store_var 16 (name) - - 730 79 load_type 0 - 80 load_var2 7 16 - 81 call 4 ntypeargs=1 (baml.Array.push) - 82 pop 1 - 83 jump -15 (to 68) - - 734 84 load_var 7 (out) - 85 store_var 6 (_0) - 86 load_var 6 (_0) - 87 return -} - -function testing.subtree_excluded(prefix: string, excludes: string[]) -> bool { - 645 0 load_var 1 (prefix) - 1 load_const 0 ("::") - 2 bin_op + - 3 store_var 3 (descendant_prefix) - - 646 4 load_var 2 (excludes) - 5 load_type 1 - 6 load_const 2 ("iter") - 7 virtual_call nargs=1 ntypeargs=0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 load_type 3 - 11 load_const 4 ("next") - 12 virtual_call nargs=1 ntypeargs=0 - 13 store_var 5 (_5) - 14 load_var 5 (_5) - 15 is_type 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +29 (to 46) - 18 load_var 5 (_5) - 19 store_var 6 (pattern) - - 649 20 load_var 6 (pattern) - 21 load_const 6 ("*") - 22 call 155 ntypeargs=0 (baml.String.index_of) - 23 load_const 7 (null) - 24 call 672 ntypeargs=0 (baml.ops.equals_equals) - 25 jump_if_false +7 (to 32) - 26 pop 1 - 27 load_var2 3 6 - 28 call 155 ntypeargs=0 (baml.String.index_of) - 29 load_const 7 (null) - 30 call 672 ntypeargs=0 (baml.ops.equals_equals) - 31 unary_op ! - 32 pop_jump_if_false +2 (to 34) - 33 jump +11 (to 44) - - 654 34 load_var 6 (pattern) - 35 load_const 8 ("*") - 36 call 149 ntypeargs=0 (baml.String.ends_with) - 37 jump_if_false +4 (to 41) - 38 pop 1 - 39 load_var2 3 6 - 40 call 869 ntypeargs=0 (testing.glob_match) - 41 pop_jump_if_false -32 (to 9) - - 655 42 load_const 9 (true) - 43 jump +4 (to 47) - - 650 44 load_const 9 (true) - 45 jump +2 (to 47) - - 658 46 load_const 10 (false) - 47 return -} - -function testing.subtree_may_be_selected(prefix: string, include: string[], exclude: string[]) -> bool { - 677 0 load_var2 1 3 - 1 call 873 ntypeargs=0 (testing.subtree_excluded) - 2 pop_jump_if_false +2 (to 4) - 3 jump +34 (to 37) - - 680 4 load_var 2 (include) - 5 container_len - 6 store_var 4 (_6) - 7 load_var 4 (_6) - 8 load_const 0 (0) - 9 cmp_int_op == - 10 pop_jump_if_false +2 (to 12) - 11 jump +24 (to 35) - - 683 12 load_var 2 (include) - 13 load_type 1 - 14 load_const 2 ("iter") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 5 (_7) - 17 load_var 5 (_7) - 18 load_type 3 - 19 load_const 4 ("next") - 20 virtual_call nargs=1 ntypeargs=0 - 21 store_var 6 (_8) - 22 load_var 6 (_8) - 23 is_type 5 - 24 pop_jump_if_false +2 (to 26) - 25 jump +8 (to 33) - 26 load_var 6 (_8) - 27 store_var_load_var 7 (pattern) - - 684 28 load_var 1 (prefix) - 29 call 874 ntypeargs=0 (testing.pattern_may_match_descendant) - 30 pop_jump_if_false -13 (to 17) - - 685 31 load_const 6 (true) - 32 jump +6 (to 38) - - 688 33 load_const 7 (false) - 34 jump +4 (to 38) - - 681 35 load_const 6 (true) - 36 jump +2 (to 38) - - 678 37 load_const 7 (false) - 38 return -} - -function testing.test_child(name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestSetChild { - 0 load_var 2 - 1 make_cell - 2 store_var 2 - 3 load_var 3 - 4 make_cell - 5 store_var 3 - - 364 6 load_var2 1 2 - - 366 7 load_var 3 (runner) - 8 make_closure 1917 2 - 9 init_instance 0 (testing.TestSetChild .name, .run) - 10 store_var 4 (_0) - 11 load_var 4 (_0) - 12 return -} - -function testing.testset_child(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestSetChild { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - - 374 6 load_deref 2 - 7 load_field 0 (name) - - 375 8 load_var2 1 2 - 9 make_closure 1919 2 - 10 init_instance 0 (testing.TestSetChild .name, .run) - 11 store_var 3 (_0) - 12 load_var 3 (_0) - 13 return -} - -function testing.testset_child_selected(registry: testing.TestRegistry, ts: testing.TestSetRegistration, names: string[]) -> testing.TestSetChild { - 0 load_var 1 - 1 make_cell - 2 store_var 1 - 3 load_var 2 - 4 make_cell - 5 store_var 2 - 6 load_var 3 - 7 make_cell - 8 store_var 3 - - 390 9 load_deref 2 - 10 load_field 0 (name) - - 391 11 load_var2 1 2 - 12 load_var 3 (names) - 13 make_closure 1921 3 - 14 init_instance 0 (testing.TestSetChild .name, .run) - 15 store_var 4 (_0) - 16 load_var 4 (_0) - 17 return -} - -function testing.testset_children(registry: testing.TestRegistry) -> testing.TestSetChild[] { - 329 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (children) - - 330 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 4 (_4) - 10 load_var 4 (_4) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_5) - 15 load_var 5 (_5) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +15 (to 33) - 19 load_var 5 (_5) - 20 store_var_load_var 6 (t) - - 331 21 load_field 0 (name) - 22 load_var 6 (t) - 23 load_field 1 (body) - 24 load_var 6 (t) - 25 load_field 2 (runner) - 26 call 859 ntypeargs=0 (testing.test_child) - 27 store_var 7 (_10) - 28 load_type 0 - 29 load_var2 3 7 - 30 call 4 ntypeargs=1 (baml.Array.push) - 31 pop 1 - 32 jump -22 (to 10) - - 333 33 load_var 1 (registry) - 34 load_field 0 (collector) - 35 load_field 2 (testsets) - 36 load_type 6 - 37 load_const 7 ("iter") - 38 virtual_call nargs=1 ntypeargs=0 - 39 store_var 8 (_16) - 40 load_var 8 (_16) - 41 load_type 8 - 42 load_const 9 ("next") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 9 (_17) - 45 load_var 9 (_17) - 46 is_type 5 - 47 pop_jump_if_false +2 (to 49) - 48 jump +11 (to 59) - 49 load_var 9 (_17) - 50 store_var 10 (ts) - - 334 51 load_var2 1 10 - 52 call 860 ntypeargs=0 (testing.testset_child) - 53 store_var 11 (_22) - 54 load_type 0 - 55 load_var2 3 11 - 56 call 4 ntypeargs=1 (baml.Array.push) - 57 pop 1 - 58 jump -18 (to 40) - - 336 59 load_var 3 (children) - 60 store_var 2 (_0) - 61 load_var 2 (_0) - 62 return -} - -function testing.testset_children_selected(registry: testing.TestRegistry, names: string[]) -> testing.TestSetChild[] { - 340 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (children) - - 341 3 load_var 1 (registry) - 4 load_field 0 (collector) - 5 load_field 1 (tests) - 6 load_type 1 - 7 load_const 2 ("iter") - 8 virtual_call nargs=1 ntypeargs=0 - 9 store_var 5 (_5) - 10 load_var 5 (_5) - 11 load_type 3 - 12 load_const 4 ("next") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 6 (_6) - 15 load_var 6 (_6) - 16 is_type 5 - 17 pop_jump_if_false +2 (to 19) - 18 jump +20 (to 38) - 19 load_var 6 (_6) - 20 store_var_load_var 7 (t) - - 342 21 load_field 0 (name) - 22 load_var 2 (names) - 23 call 862 ntypeargs=0 (testing._name_selected) - 24 pop_jump_if_false -14 (to 10) - - 343 25 load_var 7 (t) - 26 load_field 0 (name) - 27 load_var 7 (t) - 28 load_field 1 (body) - 29 load_var 7 (t) - 30 load_field 2 (runner) - 31 call 859 ntypeargs=0 (testing.test_child) - 32 store_var 8 (_13) - 33 load_type 0 - 34 load_var2 4 8 - 35 call 4 ntypeargs=1 (baml.Array.push) - 36 pop 1 - 37 jump -27 (to 10) - - 348 38 load_var 1 (registry) - 39 load_field 0 (collector) - 40 load_field 2 (testsets) - 41 load_type 6 - 42 load_const 7 ("iter") - 43 virtual_call nargs=1 ntypeargs=0 - 44 store_var 9 (_19) - 45 load_var 9 (_19) - 46 load_type 8 - 47 load_const 9 ("next") - 48 virtual_call nargs=1 ntypeargs=0 - 49 store_var 10 (_20) - 50 load_var 10 (_20) - 51 is_type 5 - 52 pop_jump_if_false +2 (to 54) - 53 jump +16 (to 69) - 54 load_var 10 (_20) - 55 store_var_load_var 11 (ts) - - 354 56 load_field 0 (name) - 57 load_var 2 (names) - 58 call 863 ntypeargs=0 (testing._has_selected_descendant) - 59 pop_jump_if_false -14 (to 45) - - 355 60 load_var2 1 11 - 61 load_var 2 (names) - 62 call 861 ntypeargs=0 (testing.testset_child_selected) - 63 store_var 12 (_27) - 64 load_type 0 - 65 load_var2 4 12 - 66 call 4 ntypeargs=1 (baml.Array.push) - 67 pop 1 - 68 jump -23 (to 45) - - 360 69 load_var 4 (children) - 70 store_var 3 (_0) - 71 load_var 3 (_0) - 72 return -} - -function user.User.promote(self: User, bonus: int) -> Report { - 9 0 load_var 1 (self) - 1 copy 0 - 2 load_field 1 (age) - 3 load_const 0 (1) - 4 bin_op + - 5 store_field 1 (age) - - 10 6 load_var2 1 2 - 7 call 1373 ntypeargs=0 (user.score) - 8 store_var 4 (base) - - 11 9 load_var 4 (base) - 10 load_field 0 (score) - 11 load_var 2 (bonus) - 12 add_int - 13 store_var_load_var 5 (new_score) - - 14 14 load_var 4 (base) - 15 load_field 1 (label) - - 15 16 load_var 4 (base) - 17 load_field 2 (breakdown) - 18 init_instance 0 (user.Report .score, .label, .breakdown) - 19 store_var 3 (_0) - 20 load_var 3 (_0) - 21 return -} - -function user.http_status(code: int) -> string { - 95 0 load_const 0 ("HTTP ") - 1 store_var 2 (prefix) - - 96 2 load_var 1 (code) - 3 dense_tag 0 - 4 jump_table 0 ([to 23, to 20, to 17, to 14, to 11, to 8], default to 5) - - 103 5 load_const 1 ("Unknown") - 6 store_var 3 (label) - - 96 7 jump +18 (to 25) - - 102 8 load_const 2 ("Internal Server Error") - 9 store_var 3 (label) - - 96 10 jump +15 (to 25) - - 101 11 load_const 3 ("Not Found") - 12 store_var 3 (label) - - 96 13 jump +12 (to 25) - - 100 14 load_const 4 ("Bad Request") - 15 store_var 3 (label) - - 96 16 jump +9 (to 25) - - 99 17 load_const 5 ("No Content") - 18 store_var 3 (label) - - 96 19 jump +6 (to 25) - - 98 20 load_const 6 ("Created") - 21 store_var 3 (label) - - 96 22 jump +3 (to 25) - - 97 23 load_const 7 ("OK") - 24 store_var 3 (label) - - 105 25 load_var2 2 3 - 26 bin_op + - 27 return -} - -function user.score(input: User | ErrorInfo, threshold: int) -> Report { - 45 0 load_var 1 (input) - 1 store_var 4 (_4) - 2 load_var 4 (_4) - 3 narrow_bind 0 4 - 4 pop_jump_if_false +2 (to 6) - 5 jump +7 (to 12) - 6 load_var 1 (input) - 7 store_var 6 (e) - - 47 8 load_var 6 (e) - 9 load_field 1 (message) - 10 store_var 3 (name) - - 45 11 jump +6 (to 17) - 12 load_var 4 (_4) - 13 store_var 5 (u) - - 46 14 load_var 5 (u) - 15 load_field 0 (name) - 16 store_var 3 (name) - - 50 17 load_var 1 (input) - 18 store_var 8 (_8) - 19 load_var 8 (_8) - 20 narrow_bind 0 8 - 21 pop_jump_if_false +2 (to 23) - 22 jump +7 (to 29) - 23 load_var 1 (input) - 24 store_var_load_var 10 (e) - - 52 25 load_field 0 (code) - 26 unary_op - - 27 store_var 7 (age) - - 50 28 jump +6 (to 34) - 29 load_var 8 (_8) - 30 store_var 9 (u) - - 51 31 load_var 9 (u) - 32 load_field 1 (age) - 33 store_var 7 (age) - - 55 34 load_var 1 (input) - 35 store_var 12 (_13) - 36 load_var 12 (_13) - 37 narrow_bind 0 12 - 38 pop_jump_if_false +2 (to 40) - 39 jump +4 (to 43) - - 62 40 load_var 2 (threshold) - 41 store_var 11 (role_mult) - - 55 42 jump +17 (to 59) - 43 load_var 12 (_13) - 44 store_var_load_var 13 (u) - - 56 45 load_field 2 (role) - 46 discriminant - 47 jump_table 0 ([to 57, to 54, to 51, to 48], default to 115) - - 60 48 load_var 2 (threshold) - 49 store_var 11 (role_mult) - - 56 50 jump +9 (to 59) - - 59 51 load_var 2 (threshold) - 52 store_var 11 (role_mult) - - 56 53 jump +6 (to 59) - - 58 54 load_var 2 (threshold) - 55 store_var 11 (role_mult) - - 56 56 jump +3 (to 59) - - 57 57 load_var 2 (threshold) - 58 store_var 11 (role_mult) - - 65 59 load_var 7 (age) - 60 load_const 1 (2) - 61 mul_int - 62 load_var 11 (role_mult) - 63 add_int - 64 store_var_load_var 14 (base) - - 66 65 load_var 11 (role_mult) - 66 cmp_int_op > - 67 pop_jump_if_false +2 (to 69) - 68 jump +4 (to 72) - - 69 69 load_var 14 (base) - 70 store_var 15 (capped) - - 66 71 jump +3 (to 74) - - 67 72 load_var 11 (role_mult) - 73 store_var 15 (capped) - - 71 74 load_var2 15 11 - 75 add_int - 76 store_var_load_var 16 (total) - - 73 77 load_var 2 (threshold) - 78 cmp_int_op > - 79 load_const 2 (true) - 80 cmp_op == - 81 pop_jump_if_false +2 (to 83) - 82 jump +4 (to 86) - - 75 83 load_const 3 (" [LOW]") - 84 store_var 17 (suffix) - - 73 85 jump +3 (to 88) - - 74 86 load_const 4 (" [HIGH]") - 87 store_var 17 (suffix) - - 77 88 load_var2 3 17 - 89 bin_op + - 90 store_var 18 (label) - - 79 91 load_var2 14 15 - 92 load_var 16 (total) - 93 load_type 5 - 94 alloc_array 3 - 95 store_var 19 (scores) - - 80 96 load_var 19 (scores) - 97 load_const 6 (0) - 98 load_var 16 (total) - 99 store_array_element - - 81 100 load_var 19 (scores) - 101 load_const 6 (0) - 102 load_array_element - 103 store_var 20 (top) - - 83 104 load_var2 14 11 - 105 load_const 7 ("base") - 106 load_const 8 ("role") - 107 load_type 9 - 108 load_type 5 - 109 alloc_map 2 - 110 store_var 21 (breakdown) - - 86 111 load_var2 20 18 - - 88 112 load_var 21 (breakdown) - 113 init_instance 0 (user.Report .score, .label, .breakdown) - 114 return - 115 unreachable -} - -function vercel.AiGatewayImageClient.ai.Client.id(self: vercel.AiGatewayImageClient) -> string { - 105 0 load_var 1 (self) - 1 call 1335 ntypeargs=0 (vercel.internal._gw_images_client_id) - 2 return -} - -function vercel.AiGatewayImageClient.ai.Client.invoke(self: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 109 0 load_var2 1 2 - 1 call 1350 ntypeargs=0 (vercel.internal.gateway_images_invoke) - 2 jump +6 (to 8) - 3 load_var 3 (e) - 4 throw_if_panic - - 110 5 load_var 3 (e) - 6 call 968 ntypeargs=0 (ai.errors.normalize) - 7 throw - 8 return -} - -function vercel.AiGatewayImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, aspect_ratio: string | null, seed: int | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> vercel.AiGatewayImageClient { - 0 load_var 1 (model) - 1 load_const 0 () - 2 cmp_op == - 3 pop_jump_if_false +3 (to 6) - - 56 4 load_const 1 ("openai/gpt-image-1") - 5 store_var 1 (model) - 6 load_var 2 (api_key) - 7 load_const 0 () - 8 cmp_op == - 9 pop_jump_if_false +3 (to 12) - - 57 10 load_const 2 (null) - 11 store_var 2 (api_key) - 12 load_var 3 (base_url) - 13 load_const 0 () - 14 cmp_op == - 15 pop_jump_if_false +3 (to 18) - - 58 16 load_const 2 (null) - 17 store_var 3 (base_url) - 18 load_var 4 (n) - 19 load_const 0 () - 20 cmp_op == - 21 pop_jump_if_false +3 (to 24) - - 59 22 load_const 2 (null) - 23 store_var 4 (n) - 24 load_var 5 (size) - 25 load_const 0 () - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - - 60 28 load_const 2 (null) - 29 store_var 5 (size) - 30 load_var 6 (aspect_ratio) - 31 load_const 0 () - 32 cmp_op == - 33 pop_jump_if_false +3 (to 36) - - 61 34 load_const 2 (null) - 35 store_var 6 (aspect_ratio) - 36 load_var 7 (seed) - 37 load_const 0 () - 38 cmp_op == - 39 pop_jump_if_false +3 (to 42) - - 62 40 load_const 2 (null) - 41 store_var 7 (seed) - 42 load_var 8 (request_body) - 43 load_const 0 () - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - - 63 46 load_const 2 (null) - 47 store_var 8 (request_body) - 48 load_var 9 (headers) - 49 load_const 0 () - 50 cmp_op == - 51 pop_jump_if_false +3 (to 54) - - 64 52 load_const 2 (null) - 53 store_var 9 (headers) - 54 load_var 10 (query_params) - 55 load_const 0 () - 56 cmp_op == - 57 pop_jump_if_false +3 (to 60) - - 65 58 load_const 2 (null) - 59 store_var 10 (query_params) - - 67 60 load_var2 1 2 - 61 load_var2 3 4 - 62 load_var2 5 6 - 63 load_var2 7 8 - 64 load_var2 9 10 - 65 init_instance 0 (vercel.AiGatewayImageClient .model, .api_key, .base_url, .n, .size, .aspect_ratio, .seed, .request_body, .headers, .query_params) - 66 return -} - -function vercel.AiGatewayImageClient.resolved_api_key(self: vercel.AiGatewayImageClient) -> string { - 87 0 load_var 1 (self) - 1 load_field 1 (api_key) - 2 load_const 0 ("AI_GATEWAY_API_KEY") - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 store_var 2 (_4) - 5 load_var 2 (_4) - 6 narrow_bind 1 2 - 7 pop_jump_if_false +2 (to 9) - 8 jump +18 (to 26) - - 93 9 load_var 1 (self) - 10 load_field 1 (api_key) - 11 load_const 2 ("AI_GATEWAY_API_KEY") - 12 call 930 ntypeargs=0 (ai.wire.credential_sources) - 13 store_var 5 (_9) - 14 load_type 3 - 15 load_var 5 (_9) - 16 call 138 ntypeargs=1 (baml.String.from) - 17 store_var 4 (_8) - - 90 18 load_const 4 ("ai-gateway-images") - 19 load_const 5 (null) - - 93 20 load_const 6 ("no AI Gateway API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — ") - 21 load_var 4 (_8) - 22 bin_op + - 23 load_const 5 (null) - 24 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 25 throw - - 87 26 load_var 2 (_4) - 27 store_var 3 (key) - - 88 28 load_var 3 (key) - 29 return -} - -function vercel.AiGatewayImageClient.resolved_base_url(self: vercel.AiGatewayImageClient) -> string | null { - 100 0 load_var 1 (self) - 1 load_field 2 (base_url) - 2 load_const 0 (null) - 3 call 928 ntypeargs=0 (ai.wire.resolve_credential) - 4 return -} - -function vercel.internal._gw_images_client_id(c: vercel.AiGatewayImageClient) -> string { - 93 0 load_type 0 - 1 load_var 1 (c) - 2 load_field 0 (model) - 3 call 138 ntypeargs=1 (baml.String.from) - 4 store_var 4 (_3) - 5 load_const 1 ("ai-gateway-images/") - 6 load_var 4 (_3) - 7 bin_op + - 8 store_var 3 (id) - - 94 9 load_var 3 (id) - 10 store_var 2 (_0) - 11 load_var 2 (_0) - 12 return -} - -function vercel.internal._gw_images_drop_nulls(value: baml.json.json) -> baml.json.json { - 100 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +2 (to 6) - 5 jump +39 (to 44) - 6 load_var 1 (value) - 7 store_var 10 (_24) - 8 load_var 10 (_24) - 9 narrow_bind 1 10 - 10 pop_jump_if_false +2 (to 12) - 11 jump +3 (to 14) - - 122 12 load_var 1 (value) - - 100 13 jump +77 (to 90) - 14 load_var 10 (_24) - 15 store_var 11 (items) - - 116 16 load_type 2 - 17 alloc_array 0 - 18 store_var 12 (out) - - 117 19 load_var 11 (items) - 20 load_type 3 - 21 load_const 4 ("iter") - 22 virtual_call nargs=1 ntypeargs=0 - 23 store_var 13 (_28) - 24 load_var 13 (_28) - 25 load_type 5 - 26 load_const 6 ("next") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 14 (_29) - 29 load_var 14 (_29) - 30 is_type 7 - 31 pop_jump_if_false +2 (to 33) - 32 jump +10 (to 42) - 33 load_var 14 (_29) - 34 store_var_load_var 15 (item) - - 118 35 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - 36 store_var 16 (_34) - 37 load_type 2 - 38 load_var2 12 16 - 39 call 4 ntypeargs=1 (baml.Array.push) - 40 pop 1 - 41 jump -17 (to 24) - - 120 42 load_var 12 (out) - - 100 43 jump +47 (to 90) - 44 load_var 2 (_2) - 45 store_var 3 (object) - - 102 46 load_type 8 - 47 load_type 2 - 48 alloc_map 0 - 49 store_var 4 (out) - - 103 50 load_type 8 - 51 load_type 2 - 52 load_var 3 (object) - 53 call 35 ntypeargs=2 (baml.Map.keys) - 54 load_type 9 - 55 load_const 10 ("iter") - 56 virtual_call nargs=1 ntypeargs=0 - 57 store_var 5 (_8) - 58 load_var 5 (_8) - 59 load_type 11 - 60 load_const 12 ("next") - 61 virtual_call nargs=1 ntypeargs=0 - 62 store_var 6 (_9) - 63 load_var 6 (_9) - 64 is_type 7 - 65 pop_jump_if_false +2 (to 67) - 66 jump +23 (to 89) - 67 load_var 6 (_9) - 68 store_var 7 (key) - - 104 69 load_type 8 - 70 load_type 2 - 71 load_var2 3 7 - 72 call 38 ntypeargs=2 (baml.Map.get) - 73 store_var 8 (entry) - - 105 74 load_var 8 (entry) - 75 load_const 13 (null) - 76 cmp_op == - 77 pop_jump_if_false +2 (to 79) - 78 jump -20 (to 58) - - 108 79 load_var 8 (entry) - 80 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - 81 store_var 9 (_20) - 82 load_type 8 - 83 load_type 2 - 84 load_var2 4 7 - 85 load_var 9 (_20) - 86 call 37 ntypeargs=2 (baml.Map.set) - 87 pop 1 - 88 jump -30 (to 58) - - 113 89 load_var 4 (out) - 90 return -} - -function vercel.internal._gw_images_escape_query(raw: string) -> string { - 228 0 load_var 1 (raw) - 1 load_const 0 ("%") - 2 load_const 1 ("%25") - 3 call 160 ntypeargs=0 (baml.String.replace_all) - 4 load_const 2 (" ") - 5 load_const 3 ("%20") - 6 call 160 ntypeargs=0 (baml.String.replace_all) - 7 load_const 4 ("&") - 8 load_const 5 ("%26") - 9 call 160 ntypeargs=0 (baml.String.replace_all) - 10 load_const 6 ("+") - 11 load_const 7 ("%2B") - 12 call 160 ntypeargs=0 (baml.String.replace_all) - 13 load_const 8 ("=") - 14 load_const 9 ("%3D") - 15 call 160 ntypeargs=0 (baml.String.replace_all) - 16 load_const 10 ("?") - 17 load_const 11 ("%3F") - 18 call 160 ntypeargs=0 (baml.String.replace_all) - 19 load_const 12 ("#") - 20 load_const 13 ("%23") - 21 call 160 ntypeargs=0 (baml.String.replace_all) - - 239 22 store_var 2 (_0) - 23 load_var 2 (_0) - 24 return -} - -function vercel.internal._gw_images_file(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> vercel.internal.GwImagesFile { - 141 0 load_var 1 (media) - 1 load_const 0 (false) - 2 call 933 ntypeargs=0 (ai.wire.resolve_media) - 3 store_var 2 (resolved) - - 142 4 load_var 2 (resolved) - 5 load_field 1 (base64) - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 narrow_bind 1 3 - 9 pop_jump_if_false +2 (to 11) - 10 jump +22 (to 32) - - 150 11 load_var 2 (resolved) - 12 load_field 0 (url) - 13 store_var 5 (_9) - 14 load_var 5 (_9) - 15 narrow_bind 1 5 - 16 pop_jump_if_false +2 (to 18) - 17 jump +7 (to 24) - - 153 18 load_const 2 ("ai-gateway-images") - 19 load_const 3 (null) - 20 load_const 4 ("image input carried no base64 content, file, or URL") - 21 load_const 3 (null) - 22 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 23 throw - - 150 24 load_var 5 (_9) - 25 store_var 6 (location) - - 151 26 load_const 5 ("url") - 27 load_const 3 (null) - 28 load_const 3 (null) - 29 load_var 6 (location) - 30 init_instance 1 (vercel.internal.GwImagesFile .type, .mediaType, .data, .url) - 31 jump +9 (to 40) - - 142 32 load_var 3 (_4) - 33 store_var 4 (encoded) - - 143 34 load_const 6 ("file") - - 145 35 load_var 2 (resolved) - 36 load_field 2 (mime_type) - - 146 37 load_var 4 (encoded) - 38 load_const 3 (null) - 39 init_instance 2 (vercel.internal.GwImagesFile .type, .mediaType, .data, .url) - 40 return -} - -function vercel.internal._gw_images_find_output_format(value: baml.json.json | null) -> string | null { - 333 0 load_var 1 (value) - 1 store_var 2 (_2) - 2 load_var 2 (_2) - 3 narrow_bind 0 2 - 4 pop_jump_if_false +57 (to 61) - 5 load_var 2 (_2) - 6 store_var 3 (object) - - 334 7 load_type 1 - 8 load_type 2 - 9 load_var 3 (object) - 10 call 35 ntypeargs=2 (baml.Map.keys) - 11 load_type 3 - 12 load_const 4 ("iter") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 4 (_7) - 15 load_var 4 (_7) - 16 load_type 5 - 17 load_const 6 ("next") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 5 (_8) - 20 load_var 5 (_8) - 21 is_type 7 - 22 pop_jump_if_false +2 (to 24) - 23 jump +38 (to 61) - 24 load_var 5 (_8) - 25 store_var 6 (key) - - 335 26 load_type 1 - 27 load_type 2 - 28 load_var2 3 6 - 29 call 38 ntypeargs=2 (baml.Map.get) - 30 store_var 7 (entry) - - 336 31 load_var 6 (key) - 32 load_const 8 ("outputFormat") - 33 cmp_op == - 34 jump_if_false +2 (to 36) - 35 jump +5 (to 40) - 36 pop 1 - 37 load_var 6 (key) - 38 load_const 9 ("output_format") - 39 cmp_op == - 40 pop_jump_if_false +7 (to 47) - - 337 41 load_var 7 (entry) - 42 store_var 8 (_20) - 43 load_var 8 (_20) - 44 narrow_bind 10 8 - 45 pop_jump_if_false +2 (to 47) - 46 jump +11 (to 57) - - 341 47 load_var 7 (entry) - 48 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 49 store_var 10 (_24) - 50 load_var 10 (_24) - 51 narrow_bind 10 10 - 52 pop_jump_if_false -37 (to 15) - 53 load_var 10 (_24) - 54 store_var 11 (nested) - - 342 55 load_var 11 (nested) - 56 jump +6 (to 62) - - 337 57 load_var 8 (_20) - 58 store_var 9 (name) - - 338 59 load_var 9 (name) - 60 jump +2 (to 62) - - 346 61 load_const 11 (null) - 62 return -} - -function vercel.internal._gw_images_headers(c: vercel.AiGatewayImageClient) -> map { - 266 0 load_const 0 ("application/json") - 1 load_const 1 ("0.0.1") - 2 load_const 2 ("4") - - 270 3 load_var 1 (c) - 4 load_field 0 (model) - 5 load_const 3 ("content-type") - 6 load_const 4 ("ai-gateway-protocol-version") - 7 load_const 5 ("ai-image-model-specification-version") - 8 load_const 6 ("ai-model-id") - 9 load_type 7 - 10 load_type 7 - 11 alloc_map 4 - 12 store_var 3 (headers) - - 272 13 load_var 1 (c) - 14 load_field 8 (headers) - 15 store_var 4 (_5) - 16 load_var 4 (_5) - 17 narrow_bind 8 4 - 18 pop_jump_if_false +42 (to 60) - 19 load_var 4 (_5) - 20 store_var 5 (extra) - - 273 21 load_type 7 - 22 load_type 7 - 23 load_var 5 (extra) - 24 call 35 ntypeargs=2 (baml.Map.keys) - 25 load_type 9 - 26 load_const 10 ("iter") - 27 virtual_call nargs=1 ntypeargs=0 - 28 store_var 6 (_10) - 29 load_var 6 (_10) - 30 load_type 11 - 31 load_const 12 ("next") - 32 virtual_call nargs=1 ntypeargs=0 - 33 store_var 7 (_11) - 34 load_var 7 (_11) - 35 is_type 13 - 36 pop_jump_if_false +2 (to 38) - 37 jump +23 (to 60) - 38 load_var 7 (_11) - 39 store_var 8 (name) - - 274 40 load_var 8 (name) - 41 call 142 ntypeargs=0 (baml.String.to_lower_case) - 42 store_var 9 (_16) - 43 load_type 7 - 44 load_type 7 - 45 load_var2 5 8 - 46 call 38 ntypeargs=2 (baml.Map.get) - 47 store_var_load_var 10 (_18) - 48 load_const 14 (null) - 49 cmp_op == - 50 pop_jump_if_false +3 (to 53) - 51 load_const 15 ("") - 52 store_var 10 (_18) - 53 load_type 7 - 54 load_type 7 - 55 load_var2 3 9 - 56 load_var 10 (_18) - 57 call 37 ntypeargs=2 (baml.Map.set) - 58 pop 1 - 59 jump -30 (to 29) - - 277 60 load_var 1 (c) - 61 call 1331 ntypeargs=0 (vercel.AiGatewayImageClient.resolved_api_key) - 62 store_var 12 (_29) - 63 load_type 7 - 64 load_var 12 (_29) - 65 call 138 ntypeargs=1 (baml.String.from) - 66 store_var 11 (_28) - 67 load_type 7 - 68 load_type 7 - 69 load_var 3 (headers) - 70 load_const 16 ("authorization") - 71 load_const 17 ("Bearer ") - 72 load_var 11 (_28) - 73 bin_op + - 74 call 37 ntypeargs=2 (baml.Map.set) - 75 pop 1 - - 278 76 load_type 7 - 77 load_type 7 - 78 load_var 3 (headers) - 79 load_const 18 ("ai-gateway-auth-method") - 80 load_const 19 ("api-key") - 81 call 37 ntypeargs=2 (baml.Map.set) - 82 pop 1 - - 279 83 load_var 3 (headers) - 84 store_var 2 (_0) - 85 load_var 2 (_0) - 86 return -} - -function vercel.internal._gw_images_input(prompt: ai.Prompt, journal: ai.Journal) -> vercel.internal.GwImagesInput { - 171 0 load_type 0 - 1 alloc_array 0 - 2 store_var 4 (parts) - - 172 3 load_type 1 - 4 alloc_array 0 - 5 store_var 5 (files) - - 173 6 load_var 1 (prompt) - 7 call 910 ntypeargs=0 (ai.Prompt.messages) - 8 load_type 2 - 9 load_const 3 ("iter") - 10 virtual_call nargs=1 ntypeargs=0 - 11 store_var 6 (_6) - 12 load_var 6 (_6) - 13 load_type 4 - 14 load_const 5 ("next") - 15 virtual_call nargs=1 ntypeargs=0 - 16 store_var 7 (_7) - 17 load_var 7 (_7) - 18 is_type 6 - 19 pop_jump_if_false +2 (to 21) - 20 jump +75 (to 95) - 21 load_var 7 (_7) - 22 store_var_load_var 8 (message) - - 174 23 load_field 2 (parts) - 24 load_type 7 - 25 load_const 8 ("iter") - 26 virtual_call nargs=1 ntypeargs=0 - 27 store_var 9 (_12) - 28 load_var 9 (_12) - 29 load_type 9 - 30 load_const 10 ("next") - 31 virtual_call nargs=1 ntypeargs=0 - 32 store_var 10 (_13) - 33 load_var 10 (_13) - 34 is_type 6 - 35 pop_jump_if_false +2 (to 37) - 36 jump -24 (to 12) - 37 load_var 10 (_13) - 38 store_var 11 (part) - - 175 39 load_var 11 (part) - 40 store_var 12 (_17) - 41 load_var 12 (_17) - 42 narrow_bind 11 12 - 43 pop_jump_if_false +2 (to 45) - 44 jump +37 (to 81) - 45 load_var 11 (part) - 46 store_var 15 (_25) - 47 load_var 15 (_25) - 48 narrow_bind 12 15 - 49 pop_jump_if_false +2 (to 51) - 50 jump +22 (to 72) - 51 load_var 11 (part) - 52 store_var 18 (_31) - 53 load_var 18 (_31) - 54 narrow_bind 13 18 - 55 pop_jump_if_false +2 (to 57) - 56 jump +13 (to 69) - 57 load_var 11 (part) - 58 store_var 19 (_33) - 59 load_var 19 (_33) - 60 narrow_bind 14 19 - 61 pop_jump_if_false +2 (to 63) - 62 jump +4 (to 66) - - 194 63 load_const 15 ("pdf") - 64 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 65 throw - - 191 66 load_const 16 ("video") - 67 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 68 throw - - 188 69 load_const 17 ("audio") - 70 call 1337 ntypeargs=0 (vercel.internal._gw_images_media_rejected) - 71 throw - - 175 72 load_var 15 (_25) - 73 store_var_load_var 16 (image) - - 184 74 call 1338 ntypeargs=0 (vercel.internal._gw_images_file) - 75 store_var 17 (_28) - 76 load_type 1 - 77 load_var2 5 17 - 78 call 4 ntypeargs=1 (baml.Array.push) - 79 pop 1 - 80 jump -52 (to 28) - - 175 81 load_var 12 (_17) - 82 store_var 13 (text) - - 177 83 load_var 13 (text) - 84 call 144 ntypeargs=0 (baml.String.trim) - 85 store_var 14 (trimmed) - - 178 86 load_var 14 (trimmed) - 87 load_const 18 ("") - 88 cmp_op != - 89 pop_jump_if_false -61 (to 28) - - 179 90 load_type 0 - 91 load_var2 4 14 - 92 call 4 ntypeargs=1 (baml.Array.push) - 93 pop 1 - 94 jump -66 (to 28) - - 199 95 load_var 2 (journal) - 96 call 905 ntypeargs=0 (ai.Journal.entries) - 97 load_type 19 - 98 load_const 20 ("iter") - 99 virtual_call nargs=1 ntypeargs=0 - 100 store_var 20 (_37) - 101 load_var 20 (_37) - 102 load_type 21 - 103 load_const 22 ("next") - 104 virtual_call nargs=1 ntypeargs=0 - 105 store_var 21 (_38) - 106 load_var 21 (_38) - 107 is_type 6 - 108 pop_jump_if_false +2 (to 110) - 109 jump +22 (to 131) - 110 load_var 21 (_38) - 111 store_var 22 (event) - - 200 112 load_var 22 (event) - 113 store_var 23 (_42) - 114 load_var 23 (_42) - 115 narrow_bind 23 23 - 116 pop_jump_if_false -15 (to 101) - 117 load_var 23 (_42) - 118 store_var_load_var 24 (user) - - 201 119 load_field 0 (content) - 120 call 144 ntypeargs=0 (baml.String.trim) - 121 store_var 25 (trimmed) - - 202 122 load_var 25 (trimmed) - 123 load_const 24 ("") - 124 cmp_op != - 125 pop_jump_if_false -24 (to 101) - - 203 126 load_type 0 - 127 load_var2 4 25 - 128 call 4 ntypeargs=1 (baml.Array.push) - 129 pop 1 - 130 jump -29 (to 101) - - 207 131 load_type 0 - 132 load_var 4 (parts) - 133 load_const 25 ("\n\n") - 134 call 15 ntypeargs=1 (baml.Array.join) - 135 store_var 26 (joined) - - 208 136 load_var 26 (joined) - 137 load_const 26 ("") - 138 cmp_op == - 139 pop_jump_if_false +2 (to 141) - 140 jump +6 (to 146) - - 216 141 load_var2 26 5 - 142 init_instance 0 (vercel.internal.GwImagesInput .text, .files) - 143 store_var 3 (_0) - 144 load_var 3 (_0) - 145 return - - 209 146 load_const 27 ("ai-gateway-images") - 147 load_const 28 (null) - 148 load_const 29 ("Images API request requires a text prompt") - 149 load_const 28 (null) - 150 init_instance 1 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 151 throw -} - -function vercel.internal._gw_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - 127 0 load_type 0 - 1 load_var 1 (kind) - 2 call 138 ntypeargs=1 (baml.String.from) - 3 store_var 4 (_4) - 4 load_const 1 ("Images API only supports text and image prompts; found ") - 5 load_var 4 (_4) - 6 bin_op + - 7 load_const 2 (" input") - 8 bin_op + - 9 store_var 3 (detail) - - 128 10 load_const 3 ("ai-gateway-images") - 11 load_const 4 (null) - - 131 12 load_var 3 (detail) - 13 load_const 4 (null) - 14 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 15 store_var 2 (_0) - 16 load_var 2 (_0) - 17 return -} - -function vercel.internal._gw_images_mime(format: string | null) -> string { - 350 0 load_var 1 (format) - 1 store_var_load_var 3 (_4) - 2 load_const 0 (null) - 3 cmp_op == - 4 pop_jump_if_false +3 (to 7) - 5 load_const 1 ("png") - 6 store_var 3 (_4) - 7 load_var 3 (_4) - 8 call 142 ntypeargs=0 (baml.String.to_lower_case) - 9 store_var 2 (normalized) - - 351 10 load_var 2 (normalized) - 11 load_const 2 ("jpeg") - 12 cmp_op == - 13 pop_jump_if_false +2 (to 15) - 14 jump +24 (to 38) - 15 load_var 2 (normalized) - 16 load_const 3 ("jpg") - 17 cmp_op == - 18 pop_jump_if_false +2 (to 20) - 19 jump +17 (to 36) - 20 load_var 2 (normalized) - 21 load_const 4 ("webp") - 22 cmp_op == - 23 pop_jump_if_false +2 (to 25) - 24 jump +10 (to 34) - 25 load_var 2 (normalized) - 26 load_const 5 ("gif") - 27 cmp_op == - 28 pop_jump_if_false +2 (to 30) - 29 jump +3 (to 32) - - 355 30 load_const 6 ("image/png") - - 351 31 jump +8 (to 39) - - 354 32 load_const 7 ("image/gif") - - 351 33 jump +6 (to 39) - - 353 34 load_const 8 ("image/webp") - - 351 35 jump +4 (to 39) - - 352 36 load_const 9 ("image/jpeg") - - 351 37 jump +2 (to 39) - - 352 38 load_const 10 ("image/jpeg") - 39 return -} - -function vercel.internal._gw_images_trim_slash(url: string) -> string { - 220 0 load_var 1 (url) - 1 load_const 0 ("/") - 2 call 149 ntypeargs=0 (baml.String.ends_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +3 (to 7) - - 223 5 load_var 1 (url) - 6 jump +10 (to 16) - - 221 7 load_var 1 (url) - 8 call 139 ntypeargs=0 (baml.String.length) - 9 store_var 2 (_4) - 10 load_var 1 (url) - 11 load_const 1 (0) - 12 load_var 2 (_4) - 13 load_const 2 (1) - 14 sub_int - 15 call 153 ntypeargs=0 (baml.String.slice) - 16 return -} - -function vercel.internal._gw_images_value(encoded: string, fallback_mime: string) -> image { - 365 0 load_var 1 (encoded) - 1 load_const 0 ("data:") - 2 call 148 ntypeargs=0 (baml.String.starts_with) - 3 pop_jump_if_false +2 (to 5) - 4 jump +4 (to 8) - - 381 5 load_var2 1 2 - 6 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 7 jump +58 (to 65) - - 366 8 load_var 1 (encoded) - 9 load_const 1 (";base64,") - 10 call 155 ntypeargs=0 (baml.String.index_of) - 11 store_var 3 (_5) - 12 load_var 3 (_5) - 13 narrow_bind 2 3 - 14 pop_jump_if_false +2 (to 16) - 15 jump +31 (to 46) - - 371 16 load_var 1 (encoded) - 17 call 139 ntypeargs=0 (baml.String.length) - 18 load_const 3 (48) - 19 cmp_int_op > - 20 pop_jump_if_false +2 (to 22) - 21 jump +4 (to 25) - - 374 22 load_var 1 (encoded) - 23 store_var 8 (preview) - - 371 24 jump +12 (to 36) - - 372 25 load_var 1 (encoded) - 26 load_const 2 (0) - 27 load_const 3 (48) - 28 call 153 ntypeargs=0 (baml.String.slice) - 29 store_var 9 (_19) - 30 load_type 4 - 31 load_var 9 (_19) - 32 call 138 ntypeargs=1 (baml.String.from) - 33 load_const 5 ("...") - 34 bin_op + - 35 store_var 8 (preview) - - 378 36 load_type 4 - 37 load_var 8 (preview) - 38 call 138 ntypeargs=1 (baml.String.from) - 39 store_var 10 (_23) - - 376 40 load_const 6 ("ai-gateway-images") - - 378 41 load_const 7 ("images[] carried a data: URL with no ;base64, marker: ") - 42 load_var 10 (_23) - 43 bin_op + - 44 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) - 45 throw - - 366 46 load_var 3 (_5) - 47 store_var 4 (marker) - - 367 48 load_var 1 (encoded) - 49 load_const 8 (5) - 50 load_var 4 (marker) - 51 call 153 ntypeargs=0 (baml.String.slice) - 52 store_var 5 (mime) - - 368 53 load_var 4 (marker) - 54 load_const 9 (8) - 55 add_int - 56 store_var 6 (_10) - 57 load_var 1 (encoded) - 58 call 139 ntypeargs=0 (baml.String.length) - 59 store_var 7 (_12) - 60 load_var2 1 6 - 61 load_var 7 (_12) - 62 call 153 ntypeargs=0 (baml.String.slice) - - 369 63 load_var 5 (mime) - 64 call 349 ntypeargs=0 (baml.media.Image.from_base64) - 65 return -} - -function vercel.internal._gw_images_with_query(url: string, params: map | null) -> string { - 243 0 load_type 0 - 1 alloc_array 0 - 2 store_var 3 (pairs) - - 244 3 load_var 2 (params) - 4 store_var 4 (_4) - 5 load_var 4 (_4) - 6 narrow_bind 1 4 - 7 pop_jump_if_false +54 (to 61) - 8 load_var 4 (_4) - 9 store_var 5 (configured) - - 245 10 load_type 0 - 11 load_type 0 - 12 load_var 5 (configured) - 13 call 35 ntypeargs=2 (baml.Map.keys) - 14 load_type 2 - 15 load_const 3 ("iter") - 16 virtual_call nargs=1 ntypeargs=0 - 17 store_var 6 (_9) - 18 load_var 6 (_9) - 19 load_type 4 - 20 load_const 5 ("next") - 21 virtual_call nargs=1 ntypeargs=0 - 22 store_var 7 (_10) - 23 load_var 7 (_10) - 24 is_type 6 - 25 pop_jump_if_false +2 (to 27) - 26 jump +35 (to 61) - 27 load_var 7 (_10) - 28 store_var_load_var 8 (key) - - 247 29 call 1341 ntypeargs=0 (vercel.internal._gw_images_escape_query) - 30 store_var 10 (_18) - 31 load_type 0 - 32 load_var 10 (_18) - 33 call 138 ntypeargs=1 (baml.String.from) - 34 store_var 9 (_17) - 35 load_type 0 - 36 load_type 0 - 37 load_var2 5 8 - 38 call 38 ntypeargs=2 (baml.Map.get) - 39 store_var_load_var 13 (_24) - 40 load_const 7 (null) - 41 cmp_op == - 42 pop_jump_if_false +3 (to 45) - 43 load_const 8 ("") - 44 store_var 13 (_24) - 45 load_var 13 (_24) - 46 call 1341 ntypeargs=0 (vercel.internal._gw_images_escape_query) - 47 store_var 12 (_22) - 48 load_type 0 - 49 load_var 12 (_22) - 50 call 138 ntypeargs=1 (baml.String.from) - 51 store_var 11 (_21) - - 246 52 load_type 0 - 53 load_var2 3 9 - - 247 54 load_const 9 ("=") - 55 bin_op + - 56 load_var 11 (_21) - 57 bin_op + - - 246 58 call 4 ntypeargs=1 (baml.Array.push) - 59 pop 1 - 60 jump -42 (to 18) - - 251 61 load_var 3 (pairs) - 62 container_len - 63 store_var 14 (_33) - 64 load_var 14 (_33) - 65 load_const 10 (0) - 66 cmp_int_op == - 67 pop_jump_if_false +2 (to 69) - 68 jump +33 (to 101) - - 254 69 load_var 1 (url) - 70 load_const 11 ("?") - 71 call 147 ntypeargs=0 (baml.String.includes) - 72 pop_jump_if_false +2 (to 74) - 73 jump +4 (to 77) - - 257 74 load_const 12 ("?") - 75 store_var 15 (separator) - - 254 76 jump +3 (to 79) - - 255 77 load_const 13 ("&") - 78 store_var 15 (separator) - - 259 79 load_type 0 - 80 load_var 1 (url) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 16 (_37) - 83 load_type 0 - 84 load_var 15 (separator) - 85 call 138 ntypeargs=1 (baml.String.from) - 86 store_var 17 (_39) - 87 load_type 0 - 88 load_var 3 (pairs) - 89 load_const 14 ("&") - 90 call 15 ntypeargs=1 (baml.Array.join) - 91 store_var 19 (_43) - 92 load_type 0 - 93 load_var 19 (_43) - 94 call 138 ntypeargs=1 (baml.String.from) - 95 store_var 18 (_42) - 96 load_var2 16 17 - 97 bin_op + - 98 load_var 18 (_42) - 99 bin_op + - 100 jump +2 (to 102) - - 252 101 load_var 1 (url) - 102 return -} - -function vercel.internal.gateway_images_invoke(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - 457 0 load_var2 1 2 - 1 call 1344 ntypeargs=0 (vercel.internal.gateway_images_render) - 2 store_var 3 (req) - - 458 3 load_type 0 - 4 load_var 3 (req) - 5 load_const 1 ("ai-gateway-images") - 6 call 931 ntypeargs=1 (ai.wire.send_as) - 7 store_var 4 (resp) - - 459 8 load_var2 1 4 - 9 call 1349 ntypeargs=0 (vercel.internal.gateway_images_parse) - 10 return -} - -function vercel.internal.gateway_images_parse(c: vercel.AiGatewayImageClient, resp: vercel.internal.GwImagesResponse) -> ai.ModelTurn { - 412 0 load_var 2 (resp) - 1 load_field 1 (warnings) - 2 store_var_load_var 4 (_4) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_type 1 - 7 alloc_array 0 - 8 store_var 4 (_4) - 9 load_var 4 (_4) - 10 store_var_load_var 3 (warnings) - - 413 11 load_type 2 - 12 load_const 3 ("iter") - 13 virtual_call nargs=1 ntypeargs=0 - 14 store_var 5 (_8) - 15 load_var 5 (_8) - 16 load_type 4 - 17 load_const 5 ("next") - 18 virtual_call nargs=1 ntypeargs=0 - 19 store_var 6 (_9) - 20 load_var 6 (_9) - 21 is_type 6 - 22 pop_jump_if_false +2 (to 24) - 23 jump +16 (to 39) - 24 load_var 6 (_9) - 25 store_var_load_var 7 (warning) - - 414 26 call 1348 ntypeargs=0 (vercel.internal.gateway_images_warning_text) - 27 store_var 8 (_13) - 28 load_const 7 ("$baml_log") - 29 load_const 8 ("warn") - 30 load_var 8 (_13) - 31 load_const 9 ("level") - 32 load_const 10 ("data") - 33 load_type 11 - 34 load_type 12 - 35 alloc_map 2 - 36 send_event - 37 pop 1 - 38 jump -23 (to 15) - - 416 39 load_var 2 (resp) - 40 load_field 2 (providerMetadata) - 41 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 42 store_var_load_var 10 (_16) - 43 load_const 0 (null) - 44 cmp_op == - 45 pop_jump_if_false +5 (to 50) - - 417 46 load_var 1 (c) - 47 load_field 7 (request_body) - 48 call 1345 ntypeargs=0 (vercel.internal._gw_images_find_output_format) - 49 store_var 10 (_16) - - 416 50 load_var 10 (_16) - 51 store_var_load_var 9 (requested) - - 418 52 call 1346 ntypeargs=0 (vercel.internal._gw_images_mime) - 53 store_var 11 (fallback_mime) - - 419 54 load_var 2 (resp) - 55 load_field 0 (images) - 56 store_var_load_var 13 (_24) - 57 load_const 0 (null) - 58 cmp_op == - 59 pop_jump_if_false +4 (to 63) - 60 load_type 11 - 61 alloc_array 0 - 62 store_var 13 (_24) - 63 load_var 13 (_24) - 64 store_var 12 (images) - - 420 65 load_type 13 - 66 alloc_array 0 - 67 store_var 14 (content) - - 421 68 load_var 12 (images) - 69 load_type 14 - 70 load_const 15 ("iter") - 71 virtual_call nargs=1 ntypeargs=0 - 72 store_var 15 (_29) - 73 load_var 15 (_29) - 74 load_type 16 - 75 load_const 17 ("next") - 76 virtual_call nargs=1 ntypeargs=0 - 77 store_var 16 (_30) - 78 load_var 16 (_30) - 79 is_type 6 - 80 pop_jump_if_false +2 (to 82) - 81 jump +19 (to 100) - 82 load_var 16 (_30) - 83 store_var 17 (encoded) - - 422 84 load_var 17 (encoded) - 85 call 144 ntypeargs=0 (baml.String.trim) - 86 load_const 18 ("") - 87 cmp_op != - 88 pop_jump_if_false -15 (to 73) - - 424 89 load_var2 17 11 - 90 call 1347 ntypeargs=0 (vercel.internal._gw_images_value) - 91 load_const 19 () - 92 load_const 19 () - 93 call 904 ntypeargs=0 (ai.content.Media.new) - 94 store_var 18 (_37) - - 423 95 load_type 13 - 96 load_var2 14 18 - 97 call 4 ntypeargs=1 (baml.Array.push) - 98 pop 1 - 99 jump -26 (to 73) - - 428 100 load_var 14 (content) - 101 container_len - 102 store_var 19 (_43) - 103 load_var 19 (_43) - 104 load_const 20 (0) - 105 cmp_int_op == - 106 pop_jump_if_false +2 (to 108) - 107 jump +41 (to 148) - - 434 108 load_var 2 (resp) - 109 load_field 3 (usage) - 110 store_var 21 (_47) - 111 load_var 21 (_47) - 112 narrow_bind 21 21 - 113 pop_jump_if_false +2 (to 115) - 114 jump +4 (to 118) - - 442 115 load_const 0 (null) - 116 store_var 20 (usage) - - 434 117 jump +25 (to 142) - 118 load_var 21 (_47) - 119 store_var_load_var 22 (reported) - - 436 120 load_field 0 (inputTokens) - 121 store_var_load_var 24 (_50) - 122 load_const 0 (null) - 123 cmp_op == - 124 pop_jump_if_false +3 (to 127) - 125 load_const 20 (0) - 126 store_var 24 (_50) - 127 load_var 24 (_50) - 128 store_var 23 (_49) - - 437 129 load_var 22 (reported) - 130 load_field 1 (outputTokens) - 131 store_var_load_var 25 (_54) - 132 load_const 0 (null) - 133 cmp_op == - 134 pop_jump_if_false +3 (to 137) - 135 load_const 20 (0) - 136 store_var 25 (_54) - - 435 137 load_var2 23 25 - - 437 138 load_const 0 (null) - 139 load_const 0 (null) - 140 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) - 141 store_var 20 (usage) - - 445 142 load_var 14 (content) - 143 load_const 20 (ai.content.StopReason.Complete) - 144 alloc_variant 774 (ai.content.StopReason) - - 447 145 load_var 20 (usage) - 146 init_instance 1 (ai.ModelTurn .content, .stop_reason, .usage) - 147 return - - 429 148 load_const 22 ("ai-gateway-images") - 149 load_const 23 ("response contained no images in images[]") - 150 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) - 151 throw -} - -function vercel.internal.gateway_images_render(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - 287 0 load_var 2 (input) - 1 load_field 2 (toolbox) - 2 call 924 ntypeargs=0 (ai.tools.Toolbox.is_empty) - 3 unary_op ! - 4 pop_jump_if_false +2 (to 6) - 5 jump +94 (to 99) - - 295 6 load_var 2 (input) - 7 load_field 1 (journal) - 8 store_var 5 (_8) - 9 load_var 1 (c) - 10 call 1335 ntypeargs=0 (vercel.internal._gw_images_client_id) - 11 store_var 6 (_9) - 12 load_var2 5 6 - 13 call 935 ntypeargs=0 (ai.wire.sanitize_for_client) - 14 store_var 4 (journal) - - 297 15 load_const 0 ("") - 16 load_var 2 (input) - 17 load_field 0 (prompt) - 18 call_indirect - 19 load_var 4 (journal) - 20 call 1339 ntypeargs=0 (vercel.internal._gw_images_input) - 21 store_var 7 (lowered) - - 298 22 load_var 7 (lowered) - 23 load_field 1 (files) - 24 container_len - 25 store_var 9 (_16) - 26 load_var 9 (_16) - 27 load_const 1 (0) - 28 cmp_int_op == - 29 pop_jump_if_false +2 (to 31) - 30 jump +5 (to 35) - - 301 31 load_var 7 (lowered) - 32 load_field 1 (files) - 33 store_var 8 (files) - - 298 34 jump +3 (to 37) - - 299 35 load_const 2 (null) - 36 store_var 8 (files) - - 304 37 load_var 7 (lowered) - 38 load_field 0 (text) - 39 store_var 11 (_19) - - 305 40 load_var 1 (c) - 41 load_field 3 (n) - 42 store_var_load_var 12 (_21) - 43 load_const 2 (null) - 44 cmp_op == - 45 pop_jump_if_false +3 (to 48) - 46 load_const 3 (1) - 47 store_var 12 (_21) - - 303 48 load_var2 11 12 - - 306 49 load_var 1 (c) - 50 load_field 4 (size) - - 307 51 load_var 1 (c) - 52 load_field 5 (aspect_ratio) - - 308 53 load_var 1 (c) - 54 load_field 6 (seed) - - 309 55 load_var 8 (files) - 56 init_instance 0 (vercel.internal.GwImagesRequest .prompt, .n, .size, .aspectRatio, .seed, .files) - 57 store_var 10 (request) - - 311 58 load_type 4 - 59 load_var 10 (request) - 60 call 355 ntypeargs=1 (baml.json.to_json) - 61 call 1336 ntypeargs=0 (vercel.internal._gw_images_drop_nulls) - - 312 62 load_var 1 (c) - 63 load_field 7 (request_body) - 64 call 934 ntypeargs=0 (ai.wire.merge_request_body) - 65 store_var 13 (merged) - - 314 66 load_var 1 (c) - 67 call 1332 ntypeargs=0 (vercel.AiGatewayImageClient.resolved_base_url) - 68 store_var_load_var 16 (_40) - 69 load_const 2 (null) - 70 cmp_op == - 71 pop_jump_if_false +3 (to 74) - 72 load_const 5 ("https://ai-gateway.vercel.sh/v4/ai") - 73 store_var 16 (_40) - 74 load_var 16 (_40) - 75 call 1340 ntypeargs=0 (vercel.internal._gw_images_trim_slash) - 76 store_var 15 (_38) - 77 load_type 6 - 78 load_var 15 (_38) - 79 call 138 ntypeargs=1 (baml.String.from) - 80 load_const 7 ("/image-model") - 81 bin_op + - - 315 82 load_var 1 (c) - 83 load_field 9 (query_params) - - 313 84 call 1342 ntypeargs=0 (vercel.internal._gw_images_with_query) - 85 store_var 14 (url) - - 320 86 load_var 1 (c) - 87 call 1343 ntypeargs=0 (vercel.internal._gw_images_headers) - 88 store_var 17 (_46) - - 321 89 load_var 13 (merged) - 90 call 351 ntypeargs=0 (baml.json.stringify) - 91 store_var 18 (_47) - - 317 92 load_const 8 ("POST") - - 319 93 load_var2 14 17 - 94 load_var 18 (_47) - 95 init_instance 1 (baml.http.Request .method, .url, .headers, .body) - 96 store_var 3 (_0) - 97 load_var 3 (_0) - 98 return - - 288 99 load_const 9 ("ai-gateway-images") - 100 load_const 2 (null) - 101 load_const 10 ("the gateway image endpoint has no tool calling; run tools with a chat client instead") - 102 load_const 2 (null) - 103 init_instance 2 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) - 104 throw -} - -function vercel.internal.gateway_images_warning_text(warning: vercel.internal.GwImagesWarning) -> string { - 388 0 load_var 1 (warning) - 1 load_field 1 (feature) - 2 store_var_load_var 3 (_3) - 3 load_const 0 (null) - 4 cmp_op == - 5 pop_jump_if_false +4 (to 9) - 6 load_var 1 (warning) - 7 load_field 3 (setting) - 8 store_var 3 (_3) - 9 load_var 3 (_3) - 10 store_var 2 (subject) - - 389 11 load_var 1 (warning) - 12 load_field 2 (details) - 13 store_var_load_var 5 (_7) - 14 load_const 0 (null) - 15 cmp_op == - 16 pop_jump_if_false +4 (to 20) - 17 load_var 1 (warning) - 18 load_field 4 (message) - 19 store_var 5 (_7) - 20 load_var 5 (_7) - 21 store_var 4 (detail) - - 390 22 load_var 1 (warning) - 23 load_field 0 (type) - 24 store_var_load_var 8 (_14) - 25 load_const 0 (null) - 26 cmp_op == - 27 pop_jump_if_false +3 (to 30) - 28 load_const 1 ("other") - 29 store_var 8 (_14) - 30 load_type 2 - 31 load_var 8 (_14) - 32 call 138 ntypeargs=1 (baml.String.from) - 33 store_var 7 (_12) - 34 load_const 3 ("ai-gateway-images: ") - 35 load_var 7 (_12) - 36 bin_op + - 37 load_const 4 (" warning") - 38 bin_op + - 39 store_var 6 (head) - - 391 40 load_var 2 (subject) - 41 store_var 10 (_19) - 42 load_var 10 (_19) - 43 narrow_bind 5 10 - 44 pop_jump_if_false +2 (to 46) - 45 jump +4 (to 49) - - 394 46 load_var 6 (head) - 47 store_var 9 (named) - - 391 48 jump +17 (to 65) - 49 load_var 10 (_19) - 50 store_var 11 (subject_name) - - 392 51 load_type 2 - 52 load_var 6 (head) - 53 call 138 ntypeargs=1 (baml.String.from) - 54 store_var 12 (_22) - 55 load_type 2 - 56 load_var 11 (subject_name) - 57 call 138 ntypeargs=1 (baml.String.from) - 58 store_var 13 (_25) - 59 load_var 12 (_22) - 60 load_const 6 (" for ") - 61 bin_op + - 62 load_var 13 (_25) - 63 bin_op + - 64 store_var 9 (named) - - 396 65 load_var 4 (detail) - 66 store_var 14 (_28) - 67 load_var 14 (_28) - 68 narrow_bind 5 14 - 69 pop_jump_if_false +2 (to 71) - 70 jump +3 (to 73) - - 399 71 load_var 9 (named) - - 396 72 jump +16 (to 88) - 73 load_var 14 (_28) - 74 store_var 15 (text) - - 397 75 load_type 2 - 76 load_var 9 (named) - 77 call 138 ntypeargs=1 (baml.String.from) - 78 store_var 16 (_31) - 79 load_type 2 - 80 load_var 15 (text) - 81 call 138 ntypeargs=1 (baml.String.from) - 82 store_var 17 (_34) - 83 load_var 16 (_31) - 84 load_const 7 (": ") - 85 bin_op + - 86 load_var 17 (_34) - 87 bin_op + - 88 return -} diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_textual.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_textual.snap deleted file mode 100644 index d85459c893d..00000000000 --- a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_textual.snap +++ /dev/null @@ -1,35251 +0,0 @@ ---- -source: crates/baml_tests/tests/bytecode_format/main.rs ---- -function ai.Agent.Runner.run(self: ai.Agent<#0>, spec: ai.FunctionSpec<#0>) -> ai.RunResult<#0> { - load_var ?1 - make_cell - store_var ?1 - load_var ?2 - make_cell - store_var ?2 - load_var ?5 - make_cell - store_var ?5 - load_var ?20 - make_cell - store_var ?20 - load_deref ?1 - load_field .client - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_deref ?2 - load_field .default_client - store_var _4 - - L0: - load_var _4 - store_var selected - load_type #0 - load_deref ?2 - call ai.Journal.new - store_deref ?5 - load_type #0 - load_deref ?1 - load_deref ?5 - load_const 0 - call ai.Agent._emit_from - store_var seen - load_const 0 - store_var steps - load_const 0 - load_const 0 - load_const null - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var total - load_type string - load_type int - alloc_map 0 - store_var fail_counts - - L1: - load_var steps - load_deref ?1 - load_field .max_steps - cmp_int_op < - pop_jump_if_false L2 - jump L3 - - L2: - load_var steps - init_instance ai.errors.StepBudgetExceeded .steps - throw - - L3: - load_type #0 - load_deref ?1 - load_var selected - load_deref ?2 - load_deref ?5 - load_var total - load_const 2 - call ai.Agent._attempt_turn - store_var turn - load_var steps - load_const 1 - add_int - store_var steps - load_type #0 - load_deref ?1 - load_deref ?5 - load_var seen - call ai.Agent._emit_from - store_var seen - load_var turn - call ai.ModelTurn.tool_uses - store_var calls - load_var calls - container_len - store_var _29 - load_var _29 - load_const 0 - cmp_int_op > - pop_jump_if_false L4 - jump L10 - - L4: - load_var turn - call ai.ModelTurn.terminal_text - store_var_load_var _98 - load_const null - cmp_op == - pop_jump_if_false L5 - load_const "" - store_var _98 - - L5: - load_var _98 - store_var candidate - load_type #0 - load_deref ?1 - load_var turn - call ai.Agent._has_media_output - pop_jump_if_false L6 - jump L7 - - L6: - load_type #0 - load_var candidate - call baml.sap.parse - store_var value - jump L8 - load_var e - throw_if_panic - load_var selected - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _112 - load_var2 37 32 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L7: - load_var selected - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _106 - load_type #0 - load_deref ?1 - load_var2 10 35 - call ai.Agent._media_value - store_var value - - L8: - load_type #0 - load_var value - call baml.json.to_json - jump L9 - load_var e - throw_if_panic - load_type baml.json.JsonSerializationError - load_var e - call baml.String.from - store_var _121 - load_var2 38 39 - load_type string - alloc_array 1 - init_instance baml.errors.UnknownError .data, .message - throw - - L9: - call baml.json.stringify - store_var _126 - load_deref ?5 - load_var _126 - init_instance ai.events.FinalProduced .value_json - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - call ai.Journal.append_all - pop 1 - load_type #0 - load_deref ?1 - load_deref ?5 - load_var seen - call ai.Agent._emit_from - store_var seen - load_var value - load_deref ?5 - load_var total - load_type #0 - init_instance<1> ai.RunResult .value, .journal, .usage - return - - L10: - load_deref ?5 - call ai.Journal.entries - container_len - store_var before - load_type ai.content.ToolUse - load_type future - load_type never - load_var calls - load_type #0 - load_var2 1 2 - load_var j - make_closure ., captures=3, ntypeargs=1 - call baml.Array.map - store_var futures - load_type void - load_type ai.errors.ToolFailedError - load_var futures - call baml.future.all - await - pop 1 - load_type #0 - load_deref ?1 - load_deref ?5 - load_var seen - call ai.Agent._emit_from - store_var seen - load_deref ?5 - call ai.Journal.entries - store_var entries - load_var before - store_var i - - L11: - load_var i - store_var _48 - load_var entries - container_len - store_var _49 - load_var2 17 18 - cmp_int_op < - pop_jump_if_false L1 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 15 16 - call baml.Array.at - store_var _53 - load_var _53 - narrow_bind ai.events.ToolFailed, slot=19 - pop_jump_if_false L13 - load_var _53 - store_deref ?20 - load_type ai.content.ToolUse - load_type never - load_var calls - load_type #0 - load_var f - make_closure ., captures=1, ntypeargs=1 - call baml.Array.find - store_var _59 - load_var _59 - narrow_bind ai.content.ToolUse, slot=21 - pop_jump_if_false L13 - load_var _59 - store_var known - load_type string - load_var known - load_field .name - call baml.String.from - store_var _63 - load_type string - load_deref ?20 - load_field .message - call baml.String.from - store_var _66 - load_var _63 - load_const "|" - bin_op + - load_var _66 - bin_op + - store_var key - load_type string - load_type int - load_var2 9 23 - call baml.Map.get - store_var_load_var _71 - load_const null - cmp_op == - pop_jump_if_false L12 - load_const 0 - store_var _71 - - L12: - load_var _71 - load_const 1 - add_int - store_var n - load_type string - load_type int - load_var2 9 23 - load_var n - call baml.Map.set - pop 1 - load_var n - load_const 3 - cmp_int_op >= - pop_jump_if_false L13 - jump L14 - - L13: - load_var i - load_const 1 - add_int - store_var i - jump L11 - - L14: - load_var known - load_field .id - store_var _85 - load_var known - load_field .name - store_var _86 - load_type int - load_var n - call baml.String.from - store_var _90 - load_type string - load_deref ?20 - load_field .message - call baml.String.from - store_var _93 - load_var2 28 29 - load_const "the same tool call failed " - load_var _90 - bin_op + - load_const " times; stopping the run: " - bin_op + - load_var _93 - bin_op + - load_const null - init_instance ai.errors.ToolFailedError .id, .name, .message, .cause - throw -} - -function ai.Agent._attempt_turn(self: ai.Agent<#0>, c: ai.Client, spec: ai.FunctionSpec<#0>, j: ai.Journal, total: ai.events.Usage, attempts_left: int) -> ai.ModelTurn { - load_var spec - load_field .prompt_template - store_var _9 - load_type #0 - load_var spec - call ai.FunctionSpec.tools - store_var _10 - load_type #0 - load_var spec - call ai.FunctionSpec.output_type - store_var _12 - load_var2 2 8 - load_var2 4 9 - load_var _12 - init_instance ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type - load_type ai.Client - load_const "invoke" - virtual_call nargs=2 ntypeargs=0 - store_var turn - load_var turn - load_field .usage - store_var _15 - load_var _15 - narrow_bind ai.events.Usage, slot=11 - pop_jump_if_false L3 - load_var _15 - store_var u - load_var total - copy 0 - load_field .input_tokens - load_var u - load_field .input_tokens - bin_op + - store_field .input_tokens - load_var total - copy 0 - load_field .output_tokens - load_var u - load_field .output_tokens - bin_op + - store_field .output_tokens - load_var u - load_field .cached_input_tokens - store_var _20 - load_var _20 - narrow_bind int, slot=13 - pop_jump_if_false L1 - load_var _20 - store_var ci - load_var total - load_field .cached_input_tokens - store_var_load_var _23 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const 0 - store_var _23 - - L0: - load_var2 5 15 - load_var ci - bin_op + - store_field .cached_input_tokens - - L1: - load_var u - load_field .reasoning_tokens - store_var _28 - load_var _28 - narrow_bind int, slot=16 - pop_jump_if_false L3 - load_var _28 - store_var rt - load_var total - load_field .reasoning_tokens - store_var_load_var _31 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const 0 - store_var _31 - - L2: - load_var2 5 18 - load_var rt - bin_op + - store_field .reasoning_tokens - - L3: - load_var turn - load_field .content - store_var _37 - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _38 - load_var2 20 21 - init_instance ai.events.AssistantMessage .content, .client_id - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - store_var batch - load_var turn - call ai.ModelTurn.tool_uses - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _40 - - L4: - load_var _40 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _41 - load_var _41 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L6 - - L5: - load_var _41 - store_var u - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 19 24 - load_field .id - load_var u - load_field .name - load_var u - load_field .args - init_instance ai.events.ToolRequested .id, .name, .args - call baml.Array.push - pop 1 - jump L4 - - L6: - load_var turn - load_field .usage - store_var _52 - load_var _52 - narrow_bind ai.events.Usage, slot=25 - pop_jump_if_false L7 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 19 25 - call baml.Array.push - pop 1 - - L7: - load_var turn - call ai.ModelTurn.terminal_text - store_var_load_var _58 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const "" - store_var _58 - - L8: - load_var _58 - store_var candidate - load_var turn - call ai.ModelTurn.tool_uses - container_len - store_var _65 - load_var _65 - load_const 0 - cmp_int_op > - jump_if_false L9 - jump L10 - - L9: - pop 1 - load_var turn - load_field .stop_reason - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - call baml.ops.equals_equals - - L10: - jump_if_false L11 - jump L12 - - L11: - pop 1 - load_var turn - load_field .stop_reason - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - call baml.ops.equals_equals - - L12: - jump_if_false L13 - jump L14 - - L13: - pop 1 - load_type #0 - load_var2 1 7 - load_var candidate - call ai.Agent._parses - - L14: - pop_jump_if_false L15 - jump L18 - - L15: - load_var attempts_left - load_const 1 - cmp_int_op > - pop_jump_if_false L16 - jump L17 - - L16: - load_var2 4 19 - call ai.Journal.append_all - pop 1 - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _93 - load_var2 31 26 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L17: - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var batch - load_const "The reply did not match the required schema. Answer again with only the corrected value." - init_instance ai.events.UserMessage .content - call baml.Array.push - pop 1 - load_var2 4 19 - call ai.Journal.append_all - pop 1 - load_type #0 - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_const 1 - sub_int - call ai.Agent._attempt_turn - jump L21 - - L18: - load_var2 4 19 - call ai.Journal.append_all - pop 1 - load_var turn - load_field .stop_reason - discriminant - load_const StopReason.MaxTokens - cmp_int_op == - pop_jump_if_false L19 - jump L23 - - L19: - load_var turn - load_field .stop_reason - discriminant - load_const StopReason.Refused - cmp_int_op == - pop_jump_if_false L20 - jump L22 - - L20: - load_var turn - - L21: - return - - L22: - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _81 - load_var _81 - load_const "the model declined to answer" - load_const null - init_instance ai.errors.Refused .provider, .reason, .raw_body - throw - - L23: - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _78 - load_var2 29 26 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function ai.Agent._emit_from(self: ai.Agent<#0>, j: ai.Journal, seen: int) -> int { - load_var j - call ai.Journal.entries - store_var entries - load_var seen - store_var i - - L0: - load_var i - store_var _7 - load_var entries - container_len - store_var _8 - load_var2 6 7 - cmp_int_op < - pop_jump_if_false L1 - jump L2 - - L1: - load_var entries - container_len - return - - L2: - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 4 5 - call baml.Array.at - store_var _12 - load_var _12 - narrow_bind ai.events.RunStarted, slot=8 - pop_jump_if_false L3 - jump L10 - - L3: - load_var _12 - narrow_bind ai.events.UserMessage, slot=8 - pop_jump_if_false L4 - jump L10 - - L4: - load_var _12 - narrow_bind ai.events.AssistantMessage, slot=8 - pop_jump_if_false L5 - jump L10 - - L5: - load_var _12 - narrow_bind ai.events.ToolRequested, slot=8 - pop_jump_if_false L6 - jump L10 - - L6: - load_var _12 - narrow_bind ai.events.ToolCompleted, slot=8 - pop_jump_if_false L7 - jump L10 - - L7: - load_var _12 - narrow_bind ai.events.ToolFailed, slot=8 - pop_jump_if_false L8 - jump L10 - - L8: - load_var _12 - narrow_bind ai.events.Usage, slot=8 - pop_jump_if_false L9 - jump L10 - - L9: - load_var _12 - narrow_bind ai.events.FinalProduced, slot=8 - pop_jump_if_false L11 - - L10: - load_var2 8 1 - load_field .on_event - call_indirect - pop 1 - - L11: - load_var i - load_const 1 - add_int - store_var i - jump L0 -} - -function ai.Agent._has_media_output(self: ai.Agent<#0>, turn: ai.ModelTurn) -> bool { - load_type #0 - call ai.internal._media_shape - store_var shape - load_var shape - load_const ":" - call baml.String.split - store_var _8 - load_type string - load_var _8 - load_const 0 - call baml.Array.at - store_var_load_var _6 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _6 - - L0: - load_var _6 - store_var_load_var form - load_const "" - cmp_op == - pop_jump_if_false L1 - jump L7 - - L1: - load_var form - load_const "mixed" - cmp_op == - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var form - load_const "mixedlist" - cmp_op == - - L3: - pop_jump_if_false L4 - jump L6 - - L4: - load_var shape - load_const ":" - call baml.String.split - store_var _24 - load_type string - load_var _24 - load_const 1 - call baml.Array.at - store_var_load_var _22 - load_const null - cmp_op == - pop_jump_if_false L5 - load_const "" - store_var _22 - - L5: - load_var2 2 9 - call ai.internal._media_of_kind - container_len - store_var _19 - load_var _19 - load_const 0 - cmp_int_op > - jump L8 - - L6: - load_var turn - call ai.internal._media_mixed_parts - container_len - store_var _17 - load_var _17 - load_const 0 - cmp_int_op > - jump L8 - - L7: - load_const false - - L8: - return -} - -function ai.Agent._media_value(self: ai.Agent<#0>, turn: ai.ModelTurn, provider: string) -> #0 { - load_type #0 - store_var t - load_var t - call ai.internal._media_shape - store_var shape - load_var shape - load_const ":" - call baml.String.split - store_var _10 - load_type string - load_var _10 - load_const 0 - call baml.Array.at - store_var_load_var _8 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _8 - - L0: - load_var _8 - store_var form - load_var shape - load_const ":" - call baml.String.split - store_var _16 - load_type string - load_var _16 - load_const 1 - call baml.Array.at - store_var_load_var _14 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "" - store_var _14 - - L1: - load_var _14 - store_var kind - load_var form - load_const "mixedlist" - cmp_op == - pop_jump_if_false L2 - jump L22 - - L2: - load_var form - load_const "mixed" - cmp_op == - pop_jump_if_false L3 - jump L14 - - L3: - load_var form - load_const "list" - cmp_op == - pop_jump_if_false L4 - jump L13 - - L4: - load_var2 2 9 - call ai.internal._media_of_kind - store_var parts - load_var2 2 9 - load_var provider - call ai.internal._media_reject_mixed - pop 1 - load_var parts - container_len - store_var _57 - load_var _57 - load_const 1 - cmp_int_op != - pop_jump_if_false L5 - jump L9 - - L5: - load_const null - store_var only - load_var parts - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _97 - - L6: - load_var _97 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _98 - load_var _98 - is_type baml.iter.Done - pop_jump_if_false L7 - jump L8 - - L7: - load_var _98 - store_var only - jump L6 - - L8: - load_var only - store_var payload - jump L23 - - L9: - load_var form - load_const "one" - cmp_op == - pop_jump_if_false L10 - jump L11 - - L10: - load_type string - load_var kind - call baml.String.from - store_var _83 - load_var t - call baml.TypeValue.baml.ToString.to_string - store_var _87 - load_type string - load_var _87 - call baml.String.from - store_var _86 - load_var parts - container_len - store_var _90 - load_type int - load_var _90 - call baml.String.from - store_var _89 - load_type string - load_var kind - call baml.String.from - store_var _92 - load_const "Expected zero or one " - load_var _83 - bin_op + - load_const " output for " - bin_op + - load_var _86 - bin_op + - load_const ", got " - bin_op + - load_var _89 - bin_op + - load_const ". Use " - bin_op + - load_var _92 - bin_op + - load_const "[] for multiple outputs." - bin_op + - store_var _59 - jump L12 - - L11: - load_type string - load_var kind - call baml.String.from - store_var _67 - load_var parts - container_len - store_var _71 - load_type int - load_var _71 - call baml.String.from - store_var _70 - load_type string - load_var kind - call baml.String.from - store_var _73 - load_const "Expected exactly one " - load_var _67 - bin_op + - load_const " output, got " - bin_op + - load_var _70 - bin_op + - load_const ". Use " - bin_op + - load_var _73 - bin_op + - load_const "[] for multiple outputs." - bin_op + - store_var _59 - - L12: - load_var2 3 24 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L13: - load_var2 2 9 - load_var provider - call ai.internal._media_reject_mixed - pop 1 - load_var2 2 9 - call ai.internal._media_of_kind - store_var payload - jump L23 - - L14: - load_var turn - call ai.internal._media_mixed_parts - store_var items - load_var items - container_len - store_var _25 - load_var _25 - load_const 1 - cmp_int_op == - pop_jump_if_false L15 - jump L18 - - L15: - load_var items - call ai.internal._media_all_text - pop_jump_if_false L16 - jump L17 - - L16: - load_var t - call baml.TypeValue.baml.ToString.to_string - store_var _42 - load_type string - load_var _42 - call baml.String.from - store_var _41 - load_var items - container_len - store_var _45 - load_type int - load_var _45 - call baml.String.from - store_var _44 - load_var provider - load_const "Expected one text or image output for " - load_var _41 - bin_op + - load_const ", got " - bin_op + - load_var _44 - bin_op + - load_const " parts. Use (image | string)[] to preserve mixed outputs." - bin_op + - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L17: - load_var items - call ai.internal._media_join_text - store_var payload - jump L23 - - L18: - load_const null - store_var only - load_var items - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L19: - load_var _28 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L20 - jump L21 - - L20: - load_var _29 - store_var only - jump L19 - - L21: - load_var only - store_var payload - jump L23 - - L22: - load_var turn - call ai.internal._media_mixed_parts - store_var payload - - L23: - load_type #0 - load_var payload - call baml.json.from_json - jump L24 - load_var e - throw_if_panic - load_type string - load_var kind - call baml.String.from - store_var _111 - load_var t - call baml.TypeValue.baml.ToString.to_string - store_var _115 - load_type string - load_var _115 - call baml.String.from - store_var _114 - load_type baml.json.JsonDecodeError - load_var e - call baml.String.from - store_var _118 - load_type string - load_var _118 - call baml.String.from - store_var _117 - load_var provider - load_const "the " - load_var _111 - bin_op + - load_const " output did not fit " - bin_op + - load_var _114 - bin_op + - load_const ": " - bin_op + - load_var _117 - bin_op + - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L24: - return -} - -function ai.Agent._parses(self: ai.Agent<#0>, turn: ai.ModelTurn, candidate: string) -> bool { - load_type #0 - load_var2 1 2 - call ai.Agent._has_media_output - pop_jump_if_false L0 - jump L2 - - L0: - load_type #0 - load_var candidate - call baml.sap.parse - pop 1 - jump L1 - load_var e - throw_if_panic - load_const false - jump L3 - - L1: - load_const true - jump L3 - - L2: - load_const true - - L3: - return -} - -function ai.Agent._run_one_tool(self: ai.Agent<#0>, tb: ai.tools.Toolbox, call: ai.content.ToolUse, j: ai.Journal) -> void { - load_var2 2 3 - load_field .name - call ai.tools.Toolbox.get - store_var _7 - load_var _7 - narrow_bind ai.tools.Tool, slot=5 - pop_jump_if_false L0 - jump L1 - - L0: - load_var call - load_field .id - store_var _42 - load_type string - load_var call - load_field .name - call baml.String.from - store_var _44 - load_var2 4 18 - load_const "tool is not in the active toolbox: " - load_var _44 - bin_op + - init_instance ai.events.ToolFailed .id, .message - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - call ai.Journal.append_all - pop 1 - load_const null - jump L10 - - L1: - load_var _7 - store_var t - load_var2 6 3 - load_field .args - call ai.tools.Tool.call - store_var outcome - jump L8 - load_var e - throw_if_panic - load_var call - load_field .id - store_var _15 - load_type unknown - load_var e - call baml.String.from - store_var _16 - load_var2 4 9 - load_var _16 - init_instance ai.events.ToolFailed .id, .message - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - call ai.Journal.append_all - pop 1 - load_var t - load_field .on_error - store_var_load_var _20 - load_const null - cmp_op == - pop_jump_if_false L2 - load_var self - load_field .tool_errors - store_var _20 - - L2: - load_var _20 - load_const ai.tools.ErrorMode.Raise - alloc_variant ai.tools.ErrorMode - call baml.ops.equals_equals - pop_jump_if_false L3 - jump L4 - - L3: - load_const null - store_var outcome - jump L8 - - L4: - load_var e - store_var _24 - load_var _24 - narrow_bind ai.errors.Failure, slot=13 - pop_jump_if_false L5 - jump L6 - - L5: - load_const null - store_var classified - jump L7 - - L6: - load_var _24 - store_var classified - - L7: - load_var call - load_field .id - store_var _27 - load_var call - load_field .name - store_var _28 - load_type unknown - load_var e - call baml.String.from - store_var _29 - load_var2 14 15 - load_var2 16 12 - init_instance ai.errors.ToolFailedError .id, .name, .message, .cause - throw - - L8: - load_var outcome - store_var _32 - load_var _32 - narrow_bind string, slot=17 - pop_jump_if_false L9 - load_var2 4 3 - load_field .id - load_var _32 - init_instance ai.events.ToolCompleted .id, .output - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - call ai.Journal.append_all - pop 1 - - L9: - load_const null - - L10: - return -} - -function ai.Agent.new(max_steps: int, client: ai.Client | null, tool_errors: ai.tools.ErrorMode, on_event: ((ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced) -> null throws never) | null) -> ai.Agent<#0> { - load_var max_steps - load_const - cmp_op == - pop_jump_if_false L0 - load_const 12 - store_var max_steps - - L0: - load_var client - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var client - - L1: - load_var tool_errors - load_const - cmp_op == - pop_jump_if_false L2 - load_const ai.tools.ErrorMode.Report - alloc_variant ai.tools.ErrorMode - store_var tool_errors - - L2: - load_var on_event - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var on_event - - L3: - load_var on_event - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L4 - load_type #0 - make_closure ., captures=0, ntypeargs=1 - store_var _10 - - L4: - load_var2 1 2 - load_var2 3 5 - load_type #0 - init_instance<1> ai.Agent .max_steps, .client, .tool_errors, .on_event - return -} - -function ai.Context.output_format_with(self: ai.Context, prefix: string | null, or_splitter: string | null, enum_value_prefix: string | null, hoisted_class_prefix: string | null, always_hoist_enums: bool | null, quote_class_fields: bool | null, hoist_classes: string[] | null, map_style: string | null, render_null_as: string | null) -> string { -} - -function ai.FunctionSpec.arguments(self: ai.FunctionSpec<#0>) -> map { - load_var self - load_field .args - return -} - -function ai.FunctionSpec.name(self: ai.FunctionSpec<#0>) -> string { - load_var self - load_field .spec_name - return -} - -function ai.FunctionSpec.output_type(self: ai.FunctionSpec<#0>) -> type { - load_type #0 - store_var output_type - load_var output_type - call ai.internal.validate_output_type - pop 1 - load_var output_type - return -} - -function ai.FunctionSpec.prompt(self: ai.FunctionSpec<#0>, output_format: string) -> ai.Prompt { - load_var output_format - load_const - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var output_format - - L0: - load_var2 2 1 - load_field .prompt_template - call_indirect - return -} - -function ai.FunctionSpec.tools(self: ai.FunctionSpec<#0>) -> ai.tools.Toolbox { - load_var self - load_field .toolbox - return -} - -function ai.Journal.append_all(self: ai.Journal, events: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[]) -> void { - load_var events - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var self - load_field .log - load_var _4 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_const null - return -} - -function ai.Journal.entries(self: ai.Journal) -> (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[] { - load_var self - load_field .log - return -} - -function ai.Journal.new(spec: ai.FunctionSpec<#0>) -> ai.Journal { - load_type #0 - load_var spec - call ai.FunctionSpec.name - store_var _4 - load_type #0 - load_var spec - call ai.FunctionSpec.arguments - store_var _6 - load_var2 2 3 - init_instance ai.events.RunStarted .spec_name, .arguments - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 1 - init_instance ai.Journal .log - return -} - -function ai.ModelTurn.media(self: ai.ModelTurn) -> (baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf)[] { - load_type baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf - alloc_array 0 - store_var out - load_var self - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var _9 - load_var _9 - narrow_bind ai.content.Media, slot=5 - pop_jump_if_false L0 - load_type baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf - load_var2 2 5 - load_field .media - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var out - return -} - -function ai.ModelTurn.terminal_text(self: ai.ModelTurn) -> string | null { - load_const null - store_var out - load_var self - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var _9 - load_var _9 - narrow_bind ai.content.Text, slot=5 - pop_jump_if_false L0 - load_var _9 - load_field .text - store_var out - jump L0 - - L2: - load_var out - return -} - -function ai.ModelTurn.tool_uses(self: ai.ModelTurn) -> ai.content.ToolUse[] { - load_type ai.content.ToolUse - alloc_array 0 - store_var out - load_var self - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var _9 - load_var _9 - narrow_bind ai.content.ToolUse, slot=5 - pop_jump_if_false L0 - load_type ai.content.ToolUse - load_var2 2 5 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var out - return -} - -function ai.Prompt.baml.ToString.to_string(self: ai.Prompt) -> string { - load_var self - call ai.Prompt.text - return -} - -function ai.Prompt.messages(self: ai.Prompt) -> ai.PromptMessage[] { -} - -function ai.Prompt.text(self: ai.Prompt) -> string { -} - -function ai.clients.Backoff.delay_ms(self: ai.clients.Backoff, attempt: int, f: ai.errors.Failure) -> int { - load_var f - store_var _5 - load_var _5 - narrow_bind ai.errors.RateLimited, slot=4 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_var _5 - load_field .retry_after_ms - - L2: - store_var _7 - load_var _7 - narrow_bind int, slot=5 - pop_jump_if_false L3 - jump L9 - - L3: - load_var self - load_field .initial_ms - store_var d - load_const 1 - store_var i - - L4: - load_var2 7 2 - cmp_int_op < - pop_jump_if_false L5 - jump L8 - - L5: - load_var2 6 1 - load_field .max_ms - cmp_int_op > - pop_jump_if_false L6 - jump L7 - - L6: - load_var d - jump L10 - - L7: - load_var self - load_field .max_ms - jump L10 - - L8: - load_var2 6 1 - load_field .multiplier - mul_int - store_var d - load_var i - load_const 1 - add_int - store_var i - jump L4 - - L9: - load_var _7 - - L10: - return -} - -function ai.clients.Backoff.new(initial_ms: int, multiplier: int, max_ms: int) -> ai.clients.Backoff { - load_var initial_ms - load_const - cmp_op == - pop_jump_if_false L0 - load_const 250 - store_var initial_ms - - L0: - load_var multiplier - load_const - cmp_op == - pop_jump_if_false L1 - load_const 2 - store_var multiplier - - L1: - load_var max_ms - load_const - cmp_op == - pop_jump_if_false L2 - load_const 10000 - store_var max_ms - - L2: - load_var2 1 2 - load_var max_ms - init_instance ai.clients.Backoff .initial_ms, .multiplier, .max_ms - return -} - -function ai.clients.Fallback._try(self: ai.clients.Fallback, input: ai.ModelTurnInput, index: int) -> ai.ModelTurn { - load_type ai.Client - load_var self - load_field .members - load_var index - call baml.Array.at - store_var _7 - load_var _7 - narrow_bind ai.Client, slot=4 - pop_jump_if_false L0 - jump L1 - - L0: - load_const "Fallback needs at least one member" - init_instance baml.errors.InvalidArgument .message - throw - - L1: - load_var2 4 2 - load_type ai.Client - load_const "invoke" - virtual_call nargs=2 ntypeargs=0 - jump L7 - load_var e - store_var _10 - load_var _10 - narrow_bind ai.errors.Failure, slot=6 - pop_jump_if_false L2 - jump L3 - - L2: - load_var e - throw_if_panic - load_var e - rethrow - - L3: - load_var _10 - store_var f - load_var index - load_const 1 - add_int - store_var _14 - load_var self - load_field .members - container_len - store_var _15 - load_var2 8 9 - cmp_int_op < - jump_if_false L4 - pop 1 - load_var f - load_type ai.errors.Failure - load_const "retry_safety" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - load_var _17 - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - call baml.ops.equals_equals - - L4: - pop_jump_if_false L5 - jump L6 - - L5: - load_var e - rethrow - - L6: - load_var2 1 2 - load_var index - load_const 1 - add_int - call ai.clients.Fallback._try - - L7: - return -} - -function ai.clients.Fallback.root.Client.id(self: ai.clients.Fallback) -> string { - load_type ai.Client - load_var self - load_field .members - load_const 0 - call baml.Array.at - store_var _5 - load_var _5 - narrow_bind ai.Client, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const "fallback" - store_var _0 - jump L2 - - L1: - load_var _5 - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _0 - - L2: - load_var _0 - return -} - -function ai.clients.Fallback.root.Client.invoke(self: ai.clients.Fallback, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - load_const 0 - call ai.clients.Fallback._try - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function ai.clients.Retry._attempt(self: ai.clients.Retry, input: ai.ModelTurnInput, remaining: int) -> ai.ModelTurn { - load_var self - load_field .inner - load_var input - load_type ai.Client - load_const "invoke" - virtual_call nargs=2 ntypeargs=0 - jump L7 - load_var e - store_var _6 - load_var _6 - narrow_bind ai.errors.Failure, slot=5 - pop_jump_if_false L0 - jump L1 - - L0: - load_var e - throw_if_panic - load_var e - rethrow - - L1: - load_var _6 - store_var f - load_var remaining - load_const 1 - cmp_int_op > - jump_if_false L2 - pop 1 - load_var f - load_type ai.errors.Failure - load_const "retry_safety" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - load_var _11 - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - call baml.ops.equals_equals - - L2: - jump_if_false L3 - pop 1 - load_var2 6 1 - load_field .retry_if - call_indirect - - L3: - pop_jump_if_false L4 - jump L5 - - L4: - load_var e - rethrow - - L5: - load_var self - load_field .backoff - load_var self - load_field .max_attempts - load_var remaining - sub_int - load_const 1 - add_int - load_var f - call ai.clients.Backoff.delay_ms - call baml.time.Duration.from_milliseconds - sys_op baml.sys.sleep - pop 1 - jump L6 - load_var se - throw_if_panic - - L6: - load_var2 1 2 - load_var remaining - load_const 1 - sub_int - call ai.clients.Retry._attempt - - L7: - return -} - -function ai.clients.Retry.new(inner: ai.Client, max_attempts: int, retry_if: ((ai.errors.Failure) -> bool throws never) | null, backoff: ai.clients.Backoff | null) -> ai.clients.Retry { - load_var max_attempts - load_const - cmp_op == - pop_jump_if_false L0 - load_const 3 - store_var max_attempts - - L0: - load_var retry_if - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var retry_if - - L1: - load_var backoff - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var backoff - - L2: - load_var retry_if - store_var_load_var _9 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const ai.clients.default_retry_judgment - store_var _9 - - L3: - load_var _9 - store_var _8 - load_var backoff - store_var_load_var _12 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const - load_const - load_const - call ai.clients.Backoff.new - store_var _12 - - L4: - load_var2 1 2 - load_var2 5 7 - init_instance ai.clients.Retry .inner, .max_attempts, .retry_if, .backoff - return -} - -function ai.clients.Retry.root.Client.id(self: ai.clients.Retry) -> string { - load_var self - load_field .inner - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _0 - load_var _0 - return -} - -function ai.clients.Retry.root.Client.invoke(self: ai.clients.Retry, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - load_var self - load_field .max_attempts - call ai.clients.Retry._attempt - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function ai.clients.RoundRobin.new(members: ai.Client[]) -> ai.clients.RoundRobin { - load_var members - container_len - store_var _3 - load_var _3 - load_const 0 - cmp_int_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var members - load_const 0 - init_instance ai.clients.RoundRobin .members, .counter - return - - L1: - load_const "RoundRobin needs at least one member" - init_instance baml.errors.InvalidArgument .message - throw -} - -function ai.clients.RoundRobin.root.Client.id(self: ai.clients.RoundRobin) -> string { - load_type ai.Client - load_var self - load_field .members - load_const 0 - call baml.Array.at - store_var _5 - load_var _5 - narrow_bind ai.Client, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const "round-robin" - store_var _0 - jump L2 - - L1: - load_var _5 - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _0 - - L2: - load_var _0 - return -} - -function ai.clients.RoundRobin.root.Client.invoke(self: ai.clients.RoundRobin, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - load_field .counter - store_var _5 - load_var self - load_field .members - container_len - store_var _6 - load_var2 1 1 - load_field .counter - load_const 1 - bin_op + - store_field .counter - load_type ai.Client - load_var self - load_field .members - load_var2 5 6 - mod_int - call baml.Array.at - store_var _13 - load_var _13 - narrow_bind ai.Client, slot=7 - pop_jump_if_false L0 - jump L1 - - L0: - load_const "RoundRobin needs at least one member" - init_instance baml.errors.InvalidArgument .message - throw - - L1: - load_var2 7 2 - load_type ai.Client - load_const "invoke" - virtual_call nargs=2 ntypeargs=0 - store_var _0 - jump L2 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L2: - load_var _0 - return -} - -function ai.clients.default_retry_judgment(f: ai.errors.Failure) -> bool { - load_var f - store_var _2 - load_var _2 - narrow_bind ai.errors.Refused, slot=2 - pop_jump_if_false L0 - jump L5 - - L0: - load_var f - store_var _3 - load_var _3 - narrow_bind ai.errors.InvalidRequest, slot=3 - pop_jump_if_false L1 - jump L4 - - L1: - load_var f - store_var _4 - load_var _4 - narrow_bind ai.errors.ParseFailed, slot=4 - pop_jump_if_false L2 - jump L3 - - L2: - load_const true - jump L6 - - L3: - load_const false - jump L6 - - L4: - load_const false - jump L6 - - L5: - load_const false - - L6: - return -} - -function ai.clients.resolve(selector: ai.Client | string | baml.env.Ref) -> ai.Client { - load_var selector - store_var _2 - load_var _2 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L5 - - L0: - load_var selector - store_var _5 - load_var _5 - narrow_bind baml.env.Ref, slot=3 - pop_jump_if_false L1 - jump L2 - - L1: - load_var selector - jump L6 - - L2: - load_var _5 - store_var named - load_var named - call baml.env.Ref.get - store_var _8 - load_var _8 - narrow_bind string, slot=5 - pop_jump_if_false L3 - jump L4 - - L3: - load_type string - load_var named - load_field .name - call baml.String.from - store_var _18 - call ai.internal._shorthand_prefixes - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_type string - load_var named - load_field .name - call baml.String.from - store_var _24 - load_const "ai.clients" - load_const null - load_const "client selector env." - load_var _18 - bin_op + - load_const " is not set: point it at a \"provider/model\" string (valid prefixes are " - bin_op + - load_var _21 - bin_op + - load_const "), or give the client: position a value with a fallback — env." - bin_op + - load_var _24 - bin_op + - load_const ".get() ?? \"openai/gpt-4o-mini\"" - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L4: - load_var _8 - call ai.internal._from_shorthand - jump L6 - - L5: - load_var _2 - call ai.internal._from_shorthand - - L6: - return -} - -function ai.content.Media.kind(self: ai.content.Media) -> string { - load_var self - load_field .media - store_var _2 - load_var _2 - store_var _3 - load_var _3 - narrow_bind baml.media.Image, slot=3 - pop_jump_if_false L0 - jump L5 - - L0: - load_var _2 - store_var _4 - load_var _4 - narrow_bind baml.media.Audio, slot=4 - pop_jump_if_false L1 - jump L4 - - L1: - load_var _2 - store_var _5 - load_var _5 - narrow_bind baml.media.Video, slot=5 - pop_jump_if_false L2 - jump L3 - - L2: - load_const "pdf" - jump L6 - - L3: - load_const "video" - jump L6 - - L4: - load_const "audio" - jump L6 - - L5: - load_const "image" - - L6: - return -} - -function ai.content.Media.new(value: image | audio | video | pdf, provider_id: string | null, revised_prompt: string | null) -> ai.content.Media { - load_var provider_id - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var provider_id - - L0: - load_var revised_prompt - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var revised_prompt - - L1: - load_type image | audio | video | pdf - load_var value - call baml.json.to_json - store_var envelope - jump L2 - load_var e - throw_if_panic - load_type baml.json.JsonSerializationError - load_var e - call baml.String.from - store_var _12 - load_type string - load_var _12 - call baml.String.from - store_var _11 - load_const "media output could not be encoded: " - load_var _11 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L2: - load_type baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf - load_var envelope - call baml.json.from_json - store_var part - jump L3 - load_var e - throw_if_panic - load_type baml.json.JsonDecodeError - load_var e - call baml.String.from - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_const "media output could not be decoded: " - load_var _21 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L3: - load_var2 8 2 - load_var revised_prompt - init_instance ai.content.Media .media, .provider_id, .revised_prompt - return -} - -function ai.errors.InvalidRequest.Failure.retry_safety(self: ai.errors.InvalidRequest) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.NetworkFailure.Failure.retry_safety(self: ai.errors.NetworkFailure) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.ParseFailed.Failure.retry_safety(self: ai.errors.ParseFailed) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.RateLimited.Failure.retry_safety(self: ai.errors.RateLimited) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.Refused.Failure.retry_safety(self: ai.errors.Refused) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.StepBudgetExceeded.Failure.retry_safety(self: ai.errors.StepBudgetExceeded) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Unsafe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.StreamingUnsupported.Failure.retry_safety(self: ai.errors.StreamingUnsupported) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Safe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.ToolFailedError.Failure.retry_safety(self: ai.errors.ToolFailedError) -> ai.errors.RetrySafety { - load_const ai.errors.RetrySafety.Unsafe - alloc_variant ai.errors.RetrySafety - return -} - -function ai.errors.classify_http(provider: string, status_code: int, body: string, headers: map | null) -> ai.errors.Failure { - load_var headers - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var headers - - L0: - load_var status_code - load_const 429 - cmp_int_op == - pop_jump_if_false L1 - jump L6 - - L1: - load_var status_code - load_const 408 - cmp_int_op == - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var status_code - load_const 500 - cmp_int_op >= - - L3: - pop_jump_if_false L4 - jump L5 - - L4: - load_type int - load_var status_code - call baml.String.from - store_var _14 - load_var2 1 2 - load_const "http " - load_var _14 - bin_op + - load_var body - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - jump L7 - - L5: - load_type int - load_var status_code - call baml.String.from - store_var _11 - load_var provider - load_const "http " - load_var _11 - bin_op + - load_var body - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L7 - - L6: - load_var headers - call ai.internal._retry_after_ms - store_var _7 - load_var2 1 5 - load_var body - init_instance ai.errors.RateLimited .provider, .retry_after_ms, .raw_body - - L7: - return -} - -function ai.errors.normalize(error: unknown) -> ai.errors.Failure | baml.errors.UnknownError { - load_var error - store_var _2 - load_var _2 - narrow_bind ai.errors.Failure, slot=2 - pop_jump_if_false L0 - jump L3 - - L0: - load_var error - store_var _4 - load_var _4 - narrow_bind baml.errors.UnknownError, slot=3 - pop_jump_if_false L1 - jump L2 - - L1: - load_type unknown - load_var error - call baml.String.from - store_var _7 - load_var2 1 4 - load_type string - alloc_array 1 - init_instance baml.errors.UnknownError .data, .message - jump L4 - - L2: - load_var _4 - jump L4 - - L3: - load_var _2 - - L4: - return -} - -function ai.internal._aws_resolve_region(region: string | null, profile: string | null) -> string | null { -} - -function ai.internal._aws_sign_request(request: baml.http.Request, service: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null) -> baml.http.Request { -} - -function ai.internal._configured(value: string) -> string | null { - load_var value - call baml.String.trim - load_const "" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var value - jump L2 - - L1: - load_const null - - L2: - return -} - -function ai.internal._flush_orphaned_calls(out: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[], pending: string[]) -> void { - load_var pending - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 1 4 - load_const "No result provided" - init_instance ai.events.ToolFailed .id, .message - call baml.Array.push - pop 1 - jump L0 - - L2: - load_type string - load_var pending - call baml.Array.clear - pop 1 - load_const null - return -} - -function ai.internal._from_shorthand(shorthand: string) -> ai.Client { - load_var shorthand - load_const "/" - call baml.String.index_of - store_var _3 - load_var _3 - narrow_bind int, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_type string - load_var shorthand - call baml.String.from - store_var _62 - call ai.internal._shorthand_prefixes - store_var _65 - load_type string - load_var _65 - call baml.String.from - store_var _64 - load_const "ai.clients" - load_const null - load_const "client \"" - load_var _62 - bin_op + - load_const "\" is not a \"provider/model\" string (no \"/\"); valid prefixes are " - bin_op + - load_var _64 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L1: - load_var _3 - store_var index - load_var shorthand - load_const 0 - load_var index - call baml.String.slice - store_var prefix - load_var index - load_const 1 - add_int - store_var _8 - load_var shorthand - call baml.String.length - store_var _10 - load_var2 1 6 - load_var _10 - call baml.String.slice - store_var model - load_var prefix - load_const "openai" - cmp_op == - pop_jump_if_false L2 - jump L25 - - L2: - load_var prefix - load_const "openai-chat" - cmp_op == - pop_jump_if_false L3 - jump L24 - - L3: - load_var prefix - load_const "openai-images" - cmp_op == - pop_jump_if_false L4 - jump L23 - - L4: - load_var prefix - load_const "azure" - cmp_op == - pop_jump_if_false L5 - jump L22 - - L5: - load_var prefix - load_const "ollama" - cmp_op == - pop_jump_if_false L6 - jump L21 - - L6: - load_var prefix - load_const "openrouter" - cmp_op == - pop_jump_if_false L7 - jump L20 - - L7: - load_var prefix - load_const "anthropic" - cmp_op == - pop_jump_if_false L8 - jump L19 - - L8: - load_var prefix - load_const "google" - cmp_op == - pop_jump_if_false L9 - jump L18 - - L9: - load_var prefix - load_const "vertex" - cmp_op == - pop_jump_if_false L10 - jump L17 - - L10: - load_var prefix - load_const "bedrock" - cmp_op == - pop_jump_if_false L11 - jump L16 - - L11: - load_var prefix - load_const "ai-gateway-images" - cmp_op == - pop_jump_if_false L12 - jump L15 - - L12: - load_var prefix - load_const "claude-code" - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_const null - jump L26 - - L14: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - call claude_code.ClaudeCodeClient.new - jump L26 - - L15: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call vercel.AiGatewayImageClient.new - jump L26 - - L16: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call aws.BedrockClient.new - jump L26 - - L17: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call google.VertexClient.new - jump L26 - - L18: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call google.GoogleClient.new - jump L26 - - L19: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call anthropic.AnthropicClient.new - jump L26 - - L20: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.OpenRouterClient.new - jump L26 - - L21: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.OllamaClient.new - jump L26 - - L22: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.AzureClient.new - jump L26 - - L23: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.ImageClient.new - jump L26 - - L24: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.ChatClient.new - jump L26 - - L25: - load_var model - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.ResponsesClient.new - - L26: - store_var _36 - load_var _36 - narrow_bind ai.Client, slot=8 - pop_jump_if_false L27 - jump L28 - - L27: - load_type string - load_var prefix - call baml.String.from - store_var _47 - load_type string - load_var shorthand - call baml.String.from - store_var _50 - call ai.internal._shorthand_prefixes - store_var _53 - load_type string - load_var _53 - call baml.String.from - store_var _52 - load_type string - load_var model - call baml.String.from - store_var _55 - load_const "ai.clients" - load_const null - load_const "no builtin provider for prefix \"" - load_var _47 - bin_op + - load_const "\" in client \"" - bin_op + - load_var _50 - bin_op + - load_const "\"; valid prefixes are " - bin_op + - load_var _52 - bin_op + - load_const " (for any other OpenAI-compatible endpoint, build openai.GenericClient.new(base_url = ..., model = \"" - bin_op + - load_var _55 - bin_op + - load_const "\"))" - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L28: - load_var _36 - return -} - -function ai.internal._gcp_access_token(credentials_json: string | null, scope: string) -> string { -} - -function ai.internal._gcp_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._gcp_quota_project_id(credentials_json: string | null) -> string | null { -} - -function ai.internal._header(headers: map, lower: string, canonical: string) -> string | null { - load_type string - load_type string - load_var2 1 2 - call baml.Map.get - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_type string - load_type string - load_var2 1 3 - call baml.Map.get - store_var _4 - - L0: - load_var _4 - return -} - -function ai.internal._int_header(headers: map, lower: string, canonical: string) -> int | null { - load_var2 1 2 - load_var canonical - call ai.internal._header - store_var _5 - load_var _5 - narrow_bind string, slot=4 - pop_jump_if_false L3 - load_var _5 - call baml.String.trim - call baml.Int.parse - store_var parsed - jump L2 - load_var e - is_type baml.errors.ParseError - pop_jump_if_false L0 - jump L1 - - L0: - load_var e - rethrow - - L1: - load_const null - store_var parsed - - L2: - load_var parsed - store_var _11 - load_var _11 - narrow_bind int, slot=7 - pop_jump_if_false L3 - load_var _11 - store_var_load_var value - load_const 0 - cmp_int_op >= - pop_jump_if_false L3 - jump L4 - - L3: - load_const null - jump L5 - - L4: - load_var value - - L5: - return -} - -function ai.internal._media_all_text(items: baml.json.json[]) -> bool { - load_var items - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _2 - - L0: - load_var _2 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - load_var _3 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L5 - - L1: - load_var _3 - is_type string - pop_jump_if_false L2 - jump L3 - - L2: - load_const false - jump L4 - - L3: - load_const true - - L4: - unary_op ! - pop_jump_if_false L0 - load_const false - jump L6 - - L5: - load_const true - - L6: - return -} - -function ai.internal._media_envelope(m: ai.content.Media) -> baml.json.json { - load_type baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf - load_var m - load_field .media - call baml.json.to_json - jump L0 - load_var e - throw_if_panic - load_type baml.json.JsonSerializationError - load_var e - call baml.String.from - store_var _8 - load_var2 2 3 - load_type string - alloc_array 1 - init_instance baml.errors.UnknownError .data, .message - throw - - L0: - return -} - -function ai.internal._media_join_text(items: baml.json.json[]) -> baml.json.json { - load_const "" - store_var out - load_var items - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _4 - store_var _8 - load_var _8 - narrow_bind string, slot=5 - pop_jump_if_false L0 - load_var2 2 5 - bin_op + - store_var out - jump L0 - - L2: - load_var out - return -} - -function ai.internal._media_mime_type(explicit: string | null, source_value: string, kind: string) -> string { - load_var explicit - store_var _4 - load_var _4 - narrow_bind string, slot=4 - pop_jump_if_false L0 - jump L45 - - L0: - load_var source_value - call baml.String.to_lower_case - store_var source - load_var source - load_const ".jpg" - call baml.String.includes - jump_if_false L1 - jump L2 - - L1: - pop 1 - load_var source - load_const ".jpeg" - call baml.String.includes - - L2: - pop_jump_if_false L3 - jump L44 - - L3: - load_var source - load_const ".png" - call baml.String.includes - pop_jump_if_false L4 - jump L43 - - L4: - load_var source - load_const ".webp" - call baml.String.includes - pop_jump_if_false L5 - jump L42 - - L5: - load_var source - load_const ".gif" - call baml.String.includes - pop_jump_if_false L6 - jump L41 - - L6: - load_var source - load_const ".svg" - call baml.String.includes - pop_jump_if_false L7 - jump L40 - - L7: - load_var source - load_const ".wav" - call baml.String.includes - pop_jump_if_false L8 - jump L39 - - L8: - load_var source - load_const ".mp3" - call baml.String.includes - pop_jump_if_false L9 - jump L38 - - L9: - load_var source - load_const ".flac" - call baml.String.includes - pop_jump_if_false L10 - jump L37 - - L10: - load_var source - load_const ".ogg" - call baml.String.includes - pop_jump_if_false L11 - jump L36 - - L11: - load_var source - load_const ".webm" - call baml.String.includes - pop_jump_if_false L12 - jump L33 - - L12: - load_var source - load_const ".mov" - call baml.String.includes - pop_jump_if_false L13 - jump L32 - - L13: - load_var source - load_const ".mp4" - call baml.String.includes - pop_jump_if_false L14 - jump L29 - - L14: - load_var source - load_const ".avi" - call baml.String.includes - pop_jump_if_false L15 - jump L28 - - L15: - load_var source - load_const ".mkv" - call baml.String.includes - pop_jump_if_false L16 - jump L25 - - L16: - load_var source - load_const ".pdf" - call baml.String.includes - pop_jump_if_false L17 - jump L24 - - L17: - load_var kind - load_const "audio" - cmp_op == - pop_jump_if_false L18 - jump L23 - - L18: - load_var kind - load_const "video" - cmp_op == - pop_jump_if_false L19 - jump L22 - - L19: - load_var kind - load_const "pdf" - cmp_op == - pop_jump_if_false L20 - jump L21 - - L20: - load_const "image/png" - jump L46 - - L21: - load_const "application/pdf" - jump L46 - - L22: - load_const "video/mp4" - jump L46 - - L23: - load_const "audio/mpeg" - jump L46 - - L24: - load_const "application/pdf" - jump L46 - - L25: - load_var kind - load_const "audio" - cmp_op == - pop_jump_if_false L26 - jump L27 - - L26: - load_const "video/x-matroska" - jump L46 - - L27: - load_const "audio/x-matroska" - jump L46 - - L28: - load_const "video/x-msvideo" - jump L46 - - L29: - load_var kind - load_const "audio" - cmp_op == - pop_jump_if_false L30 - jump L31 - - L30: - load_const "video/mp4" - jump L46 - - L31: - load_const "audio/mp4" - jump L46 - - L32: - load_const "video/quicktime" - jump L46 - - L33: - load_var kind - load_const "audio" - cmp_op == - pop_jump_if_false L34 - jump L35 - - L34: - load_const "video/webm" - jump L46 - - L35: - load_const "audio/webm" - jump L46 - - L36: - load_const "audio/ogg" - jump L46 - - L37: - load_const "audio/flac" - jump L46 - - L38: - load_const "audio/mpeg" - jump L46 - - L39: - load_const "audio/wav" - jump L46 - - L40: - load_const "image/svg+xml" - jump L46 - - L41: - load_const "image/gif" - jump L46 - - L42: - load_const "image/webp" - jump L46 - - L43: - load_const "image/png" - jump L46 - - L44: - load_const "image/jpeg" - jump L46 - - L45: - load_var _4 - - L46: - return -} - -function ai.internal._media_mixed_parts(turn: ai.ModelTurn) -> baml.json.json[] { - load_type baml.json.json - alloc_array 0 - store_var items - load_var turn - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _5 - store_var b - load_var b - store_var _9 - load_var _9 - narrow_bind ai.content.Text, slot=6 - pop_jump_if_false L2 - jump L3 - - L2: - load_var b - store_var _17 - load_var _17 - narrow_bind ai.content.Media, slot=8 - pop_jump_if_false L0 - load_var _17 - store_var m - load_var m - call ai.content.Media.kind - load_const "image" - cmp_op == - pop_jump_if_false L0 - load_var m - call ai.internal._media_envelope - store_var _22 - load_type baml.json.json - load_var2 2 10 - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var _9 - store_var_load_var t - load_field .text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_type baml.json.json - load_var2 2 7 - load_field .text - call baml.Array.push - pop 1 - jump L0 - - L4: - load_var items - return -} - -function ai.internal._media_of_kind(turn: ai.ModelTurn, kind: string) -> baml.json.json[] { - load_type baml.json.json - alloc_array 0 - store_var out - load_var turn - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _6 - store_var _10 - load_var _10 - narrow_bind ai.content.Media, slot=6 - pop_jump_if_false L0 - load_var _10 - store_var m - load_var m - call ai.content.Media.kind - load_var kind - cmp_op == - pop_jump_if_false L0 - load_var m - call ai.internal._media_envelope - store_var _15 - load_type baml.json.json - load_var2 3 8 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var out - return -} - -function ai.internal._media_reject_mixed(turn: ai.ModelTurn, kind: string, provider: string) -> void { - load_const 0 - store_var unexpected - load_var turn - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - - L0: - load_var _6 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var _7 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _7 - store_var b - load_var b - store_var _11 - load_var _11 - narrow_bind ai.content.Media, slot=8 - pop_jump_if_false L2 - jump L3 - - L2: - load_var b - store_var _16 - load_var _16 - narrow_bind ai.content.Text, slot=9 - pop_jump_if_false L0 - load_var _16 - load_field .text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_var unexpected - load_const 1 - add_int - store_var unexpected - jump L0 - - L3: - load_var _11 - call ai.content.Media.kind - load_var kind - cmp_op != - pop_jump_if_false L0 - load_var unexpected - load_const 1 - add_int - store_var unexpected - jump L0 - - L4: - load_var unexpected - load_const 0 - cmp_int_op > - pop_jump_if_false L5 - jump L6 - - L5: - load_const null - return - - L6: - load_type string - load_var kind - call baml.String.from - store_var _31 - load_type int - load_var unexpected - call baml.String.from - store_var _33 - load_type string - load_var kind - call baml.String.from - store_var _36 - load_var provider - load_const "Expected only " - load_var _31 - bin_op + - load_const " output parts, got " - bin_op + - load_var _33 - bin_op + - load_const " non-" - bin_op + - load_var _36 - bin_op + - load_const " part(s). Use a text/image union return type to preserve mixed outputs." - bin_op + - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function ai.internal._media_shape(t: type) -> string { - load_var t - load_type image - call baml.ops.equals_equals - pop_jump_if_false L0 - jump L27 - - L0: - load_var t - load_type audio - call baml.ops.equals_equals - pop_jump_if_false L1 - jump L26 - - L1: - load_var t - load_type video - call baml.ops.equals_equals - pop_jump_if_false L2 - jump L25 - - L2: - load_var t - load_type pdf - call baml.ops.equals_equals - pop_jump_if_false L3 - jump L24 - - L3: - load_var t - load_type image | null - call baml.ops.equals_equals - pop_jump_if_false L4 - jump L23 - - L4: - load_var t - load_type audio | null - call baml.ops.equals_equals - pop_jump_if_false L5 - jump L22 - - L5: - load_var t - load_type video | null - call baml.ops.equals_equals - pop_jump_if_false L6 - jump L21 - - L6: - load_var t - load_type pdf | null - call baml.ops.equals_equals - pop_jump_if_false L7 - jump L20 - - L7: - load_var t - load_type image[] - call baml.ops.equals_equals - jump_if_false L8 - jump L9 - - L8: - pop 1 - load_var t - load_type image[] | null - call baml.ops.equals_equals - - L9: - pop_jump_if_false L10 - jump L19 - - L10: - load_var t - load_type (string | image)[] - call baml.ops.equals_equals - jump_if_false L11 - jump L12 - - L11: - pop 1 - load_var t - load_type (string | image)[] | null - call baml.ops.equals_equals - - L12: - pop_jump_if_false L13 - jump L18 - - L13: - load_var t - load_type string | image - call baml.ops.equals_equals - jump_if_false L14 - jump L15 - - L14: - pop 1 - load_var t - load_type string | image | null - call baml.ops.equals_equals - - L15: - pop_jump_if_false L16 - jump L17 - - L16: - load_const "" - jump L28 - - L17: - load_const "mixed:image" - jump L28 - - L18: - load_const "mixedlist:image" - jump L28 - - L19: - load_const "list:image" - jump L28 - - L20: - load_const "opt:pdf" - jump L28 - - L21: - load_const "opt:video" - jump L28 - - L22: - load_const "opt:audio" - jump L28 - - L23: - load_const "opt:image" - jump L28 - - L24: - load_const "one:pdf" - jump L28 - - L25: - load_const "one:video" - jump L28 - - L26: - load_const "one:audio" - jump L28 - - L27: - load_const "one:image" - - L28: - return -} - -function ai.internal._merge_json(base: baml.json.json, patch: baml.json.json) -> baml.json.json { - load_var patch - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_var patch - jump L10 - - L1: - load_var _3 - store_var patch_object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_var base - store_var _6 - load_var _6 - narrow_bind map, slot=6 - pop_jump_if_false L4 - load_var _6 - store_var base_object - load_type string - load_type baml.json.json - load_var base_object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - - L2: - load_var _11 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var _12 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L4 - - L3: - load_var _12 - store_var key - load_type string - load_type baml.json.json - load_var2 7 10 - call baml.Map.get - store_var _18 - load_type string - load_type baml.json.json - load_var2 5 10 - load_var _18 - call baml.Map.set - pop 1 - jump L2 - - L4: - load_type string - load_type baml.json.json - load_var patch_object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _27 - - L5: - load_var _27 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - load_var _28 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L9 - - L6: - load_var _28 - store_var key - load_type string - load_type baml.json.json - load_var2 4 14 - call baml.Map.get - store_var value - load_var value - load_const null - cmp_op == - pop_jump_if_false L7 - jump L8 - - L7: - load_type string - load_type baml.json.json - load_var2 5 14 - call baml.Map.get - load_var value - call ai.internal._merge_json - store_var _43 - load_type string - load_type baml.json.json - load_var2 5 14 - load_var _43 - call baml.Map.set - pop 1 - jump L5 - - L8: - load_type string - load_type baml.json.json - load_var2 5 14 - call baml.Map.delete - pop 1 - jump L5 - - L9: - load_var out - - L10: - return -} - -function ai.internal._proxy(conn: ai.mcp.McpConnection, name: string) -> (map) -> string throws unknown { - load_var ?1 - make_cell - store_var ?1 - load_var ?2 - make_cell - store_var ?2 - load_var2 1 2 - make_closure ., 2 - return -} - -function ai.internal._redact_after(text: string, marker: string) -> string { - load_const "" - store_var out - load_var text - store_var rest - - L0: - load_const true - pop_jump_if_false L1 - jump L2 - - L1: - load_var out - jump L4 - - L2: - load_var2 4 2 - call baml.String.index_of - store_var _6 - load_var _6 - narrow_bind int, slot=5 - pop_jump_if_false L3 - jump L5 - - L3: - load_var2 3 4 - bin_op + - - L4: - return - - L5: - load_var _6 - store_var _9 - load_var marker - call baml.String.length - load_var _9 - add_int - store_var head - load_var rest - load_const 0 - load_var head - call baml.String.slice - store_var _11 - load_var2 3 8 - bin_op + - store_var out - load_var out - load_const "REDACTED" - bin_op + - store_var out - load_var rest - call baml.String.length - store_var _15 - load_var2 4 6 - load_var _15 - call baml.String.slice - store_var tail - load_var tail - call ai.internal._redact_value_end - store_var _16 - load_var tail - call baml.String.length - store_var _18 - load_var2 9 11 - load_var _18 - call baml.String.slice - store_var rest - jump L0 -} - -function ai.internal._redact_value_end(tail: string) -> int { - load_var tail - call baml.String.length - store_var cut - load_const "&" - load_const " " - load_const "\"" - load_const "'" - load_const ")" - load_const "," - load_const "\n" - load_const "\t" - load_type string - alloc_array 8 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 1 4 - call baml.String.index_of - store_var _11 - load_var _11 - narrow_bind int, slot=5 - pop_jump_if_false L0 - load_var _11 - store_var_load_var at - load_var cut - cmp_int_op < - pop_jump_if_false L0 - load_var at - store_var cut - jump L0 - - L2: - load_var cut - return -} - -function ai.internal._resolve_media_content(url: string | null, file: string | null, inline: string, mime: string, fetch_url: bool) -> ai.wire.ResolvedMedia { - load_var file - store_var _6 - load_var _6 - narrow_bind string, slot=6 - pop_jump_if_false L0 - jump L22 - - L0: - load_var inline - load_const "" - cmp_op != - pop_jump_if_false L1 - jump L21 - - L1: - load_var url - store_var _40 - load_var _40 - narrow_bind string, slot=18 - pop_jump_if_false L2 - jump L3 - - L2: - load_const "media has no URL, file, or base64 content" - init_instance baml.errors.InvalidArgument .message - throw - - L3: - load_var _40 - store_var media_url - load_var media_url - load_const "data:" - call baml.String.starts_with - pop_jump_if_false L4 - jump L15 - - L4: - load_var fetch_url - unary_op ! - jump_if_false L5 - jump L6 - - L5: - pop 1 - load_var media_url - load_const "gs://" - call baml.String.starts_with - - L6: - pop_jump_if_false L7 - jump L14 - - L7: - load_const 30 - call baml.time.Duration.from_seconds - store_var _69 - load_var2 19 31 - call baml.http.fetch - store_var response - jump L8 - load_var e - throw_if_panic - load_type string - load_var media_url - call baml.String.from - store_var _74 - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _78 - load_type string - load_var _78 - call baml.String.from - store_var _77 - load_const "media" - load_const "media URL " - load_var _74 - bin_op + - load_const " could not be fetched: " - bin_op + - load_var _77 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L8: - load_var response - call baml.http.Response.ok - unary_op ! - pop_jump_if_false L9 - jump L13 - - L9: - load_type string - load_type string - load_var response - load_field .headers - load_const "content-type" - call baml.Map.get - store_var_load_var _94 - load_const null - cmp_op == - pop_jump_if_false L10 - load_var mime - store_var _94 - - L10: - load_var _94 - store_var response_mime - load_var response - sys_op baml.http.Response.bytes - jump L11 - load_var e - throw_if_panic - load_type string - load_var media_url - call baml.String.from - store_var _106 - load_type baml.errors.Io - load_var e - call baml.String.from - store_var _110 - load_type string - load_var _110 - call baml.String.from - store_var _109 - load_const "media" - load_const "media URL " - load_var _106 - bin_op + - load_const " body could not be read: " - bin_op + - load_var _109 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L11: - call baml.Uint8Array.to_base64 - store_var _113 - load_var response_mime - load_const ";" - call baml.String.split - store_var _118 - load_type string - load_var _118 - load_const 0 - call baml.Array.at - store_var_load_var _116 - load_const null - cmp_op == - pop_jump_if_false L12 - load_var mime - store_var _116 - - L12: - load_var _116 - call baml.String.trim - store_var _114 - load_const null - load_var2 43 44 - init_instance ai.wire.ResolvedMedia .url, .base64, .mime_type - jump L25 - - L13: - load_type string - load_var media_url - call baml.String.from - store_var _87 - load_type int - load_var response - load_field .status_code - call baml.String.from - store_var _90 - load_const "media" - load_const "media URL " - load_var _87 - bin_op + - load_const " returned HTTP " - bin_op + - load_var _90 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L14: - load_var media_url - load_const null - load_var mime - init_instance ai.wire.ResolvedMedia .url, .base64, .mime_type - jump L25 - - L15: - load_var media_url - load_const ";base64," - call baml.String.index_of - store_var _44 - load_var _44 - narrow_bind int, slot=20 - pop_jump_if_false L16 - jump L20 - - L16: - load_var media_url - call baml.String.length - load_const 48 - cmp_int_op > - pop_jump_if_false L17 - jump L18 - - L17: - load_var media_url - store_var preview - jump L19 - - L18: - load_var media_url - load_const 0 - load_const 48 - call baml.String.slice - store_var _56 - load_type string - load_var _56 - call baml.String.from - load_const "..." - bin_op + - store_var preview - - L19: - load_type string - load_var preview - call baml.String.from - store_var _60 - load_const "media carries a data: URL with no ;base64, marker, which has no payload to send: " - load_var _60 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L20: - load_var _44 - store_var_load_var separator - load_const 8 - add_int - store_var _47 - load_var media_url - call baml.String.length - store_var _49 - load_var2 19 23 - load_var _49 - call baml.String.slice - store_var _46 - load_var media_url - load_const 5 - load_var separator - call baml.String.slice - store_var _50 - load_const null - load_var2 22 25 - init_instance ai.wire.ResolvedMedia .url, .base64, .mime_type - jump L25 - - L21: - load_const null - load_var2 3 4 - init_instance ai.wire.ResolvedMedia .url, .base64, .mime_type - jump L25 - - L22: - load_var _6 - store_var_load_var path - load_const "r" - sys_op baml.fs.open - store_var handle - jump L23 - load_var e - throw_if_panic - load_type string - load_var path - call baml.String.from - store_var _15 - load_type baml.errors.InvalidArgument | baml.errors.Io - load_var e - call baml.String.from - store_var _19 - load_type string - load_var _19 - call baml.String.from - store_var _18 - load_const "media file " - load_var _15 - bin_op + - load_const " could not be opened: " - bin_op + - load_var _18 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L23: - load_var handle - sys_op baml.fs.File.bytes - call baml.Uint8Array.to_base64 - store_var data - jump L24 - load_var e - throw_if_panic - load_var handle - sys_op baml.fs.File.close - pop 1 - load_type string - load_var path - call baml.String.from - store_var _30 - load_type baml.errors.InvalidArgument | baml.errors.Io - load_var e - call baml.String.from - store_var _34 - load_type string - load_var _34 - call baml.String.from - store_var _33 - load_const "media file " - load_var _30 - bin_op + - load_const " could not be read: " - bin_op + - load_var _33 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L24: - load_var handle - sys_op baml.fs.File.close - pop 1 - load_const null - load_var2 13 4 - init_instance ai.wire.ResolvedMedia .url, .base64, .mime_type - - L25: - return -} - -function ai.internal._resolve_pending_call(pending: string[], id: string) -> void { - load_type string - load_var2 1 2 - call baml.Array.index_of - store_var _5 - load_var _5 - narrow_bind int, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_type string - load_var2 1 3 - call baml.Array.remove_at - pop 1 - load_const null - - L2: - return -} - -function ai.internal._retry_after_ms(headers: map | null) -> int | null { - load_var headers - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L1 - load_var _2 - store_var_load_var h - load_const "retry-after-ms" - load_const "Retry-After-Ms" - call ai.internal._int_header - store_var _6 - load_var _6 - narrow_bind int, slot=4 - pop_jump_if_false L0 - jump L3 - - L0: - load_var h - load_const "retry-after" - load_const "Retry-After" - call ai.internal._int_header - store_var _10 - load_var _10 - narrow_bind int, slot=5 - pop_jump_if_false L1 - jump L2 - - L1: - load_const null - jump L4 - - L2: - load_var _10 - load_const 1000 - mul_int - jump L4 - - L3: - load_var _6 - - L4: - return -} - -function ai.internal._schema_for_signature(handler: baml.AnyFunction) -> map { - load_var handler - call baml.reflect.signature - store_var sig - load_type string - load_type unknown - alloc_map 0 - store_var props - load_type string - alloc_array 0 - store_var required - load_var sig - load_field .args - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - - L0: - load_var _6 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var _7 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _7 - store_var a - load_var a - load_field .name - store_var _12 - load_var a - load_field .type - sys_op baml.json.schema - store_var _13 - load_type string - load_type unknown - load_var2 3 8 - load_var _13 - call baml.Map.set - pop 1 - load_type string - load_var2 4 7 - load_field .name - call baml.Array.push - pop 1 - jump L0 - - L2: - load_const "object" - load_var2 3 4 - load_const false - load_const "type" - load_const "properties" - load_const "required" - load_const "additionalProperties" - load_type string - load_type unknown - alloc_map 4 - return -} - -function ai.internal._shorthand_prefixes() -> string { - load_type string - load_const "openai" - load_const "openai-chat" - load_const "openai-images" - load_const "azure" - load_const "ollama" - load_const "openrouter" - load_const "anthropic" - load_const "google" - load_const "vertex" - load_const "bedrock" - load_const "ai-gateway-images" - load_const "claude-code" - load_type string - alloc_array 12 - load_const ", " - call baml.Array.join - return -} - -function ai.internal._wire_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], keep_reasoning: bool) -> (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[] { - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var out - load_var content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _5 - store_var block - load_var block - store_var _9 - load_var _9 - narrow_bind ai.content.Text, slot=7 - pop_jump_if_false L2 - jump L5 - - L2: - load_var block - store_var _17 - load_var _17 - narrow_bind ai.content.Reasoning, slot=9 - pop_jump_if_false L3 - jump L4 - - L3: - load_var block - store_var _22 - load_var _22 - narrow_bind ai.content.ToolUse, slot=11 - pop_jump_if_false L0 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 11 - call baml.Array.push - pop 1 - jump L0 - - L4: - load_var _17 - store_var reasoning - load_var keep_reasoning - pop_jump_if_false L0 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 10 - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _9 - store_var_load_var text - load_field .text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 8 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var out - return -} - -function ai.internal.assemble_prompt(parts: string[], values: unknown[]) -> ai.Prompt { -} - -function ai.internal.build_output_format(return_type: type) -> ai.OutputFormat { -} - -function ai.internal.get_return_type(function_name: string) -> type { -} - -function ai.internal.make_role(name: string) -> ai.Role { - load_var name - load_type string - load_type unknown - alloc_map 0 - init_instance ai.Role .name, .metadata - return -} - -function ai.internal.render_output_format(return_type: type) -> string { -} - -function ai.internal.validate_output_type(return_type: type) -> void { - load_var return_type - call baml.TypeValue._validate_renderable - pop 1 - load_var return_type - call baml.TypeValue.as_enum - store_var _4 - load_var _4 - narrow_bind baml.reflect.enum.Type, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L3 - - L1: - load_var _4 - call baml.reflect.enum.Type.values - container_len - store_var _7 - load_var _7 - load_const 0 - cmp_int_op == - pop_jump_if_false L2 - jump L4 - - L2: - load_const null - - L3: - return - - L4: - load_var return_type - call baml.TypeValue.baml.ToString.to_string - store_var _11 - load_const "empty enum `" - load_var _11 - bin_op + - load_const "` cannot be rendered as an LLM output schema" - bin_op + - store_var_load_var message - load_const "E0159" - load_const null - load_var message - init_instance baml.reflect.Diagnostic .code, .span, .message - load_type baml.reflect.Diagnostic - alloc_array 1 - init_instance baml.reflect.errors.CompilationError .message, .diagnostics - throw -} - -function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, params: map) -> baml.json.json { - load_var self - load_field .next_id - store_var id - load_var self - copy 0 - load_field .next_id - load_const 1 - bin_op + - store_field .next_id - load_var2 4 2 - load_var params - call ai.mcp.rpc_line - store_var _6 - load_var2 1 5 - call ai.mcp.McpConnection._send - pop 1 - - L0: - load_const true - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var self - load_field .server_name - call baml.String.from - store_var _66 - load_type string - load_var method - call baml.String.from - store_var _70 - load_const "mcp/" - load_var _66 - bin_op + - load_const "no response for " - load_var _70 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L2: - load_var self - load_field .p - load_field .stdout - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var next - jump L3 - load_var e - throw_if_panic - load_type string - load_var self - load_field .server_name - call baml.String.from - store_var _13 - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _18 - load_type string - load_var _18 - call baml.String.from - store_var _17 - load_const "mcp/" - load_var _13 - bin_op + - load_const "reading from the MCP server failed: " - load_var _17 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L3: - load_var next - store_var _21 - load_var _21 - narrow_bind string, slot=11 - pop_jump_if_false L4 - jump L5 - - L4: - load_type string - load_var self - load_field .server_name - call baml.String.from - store_var _58 - load_type string - load_var method - call baml.String.from - store_var _62 - load_const "mcp/" - load_var _58 - bin_op + - load_const "the MCP server stream ended before answering " - load_var _62 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L5: - load_var _21 - call baml.String.trim - store_var trimmed - load_var trimmed - call baml.String.length - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_var trimmed - call baml.json.parse - store_var msg - jump L6 - load_var e - throw_if_panic - load_const null - store_var msg - - L6: - load_type int - load_var msg - load_const ".id" - load_const 1 - unary_op - - call baml.json.path_or - load_var id - cmp_int_op == - pop_jump_if_false L0 - load_type baml.json.json - load_var msg - load_const ".error" - load_const null - call baml.json.path_or - store_var err - load_var err - load_const null - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L7 - jump L8 - - L7: - load_type baml.json.json - load_var msg - load_const ".result" - load_const null - call baml.json.path_or - return - - L8: - load_type string - load_var self - load_field .server_name - call baml.String.from - store_var _43 - load_type int | null - load_var err - load_const ".code" - load_const null - call baml.json.path_or - store_var _46 - load_type string - load_var err - load_const ".message" - load_const "MCP error" - call baml.json.path_or - store_var _49 - load_var err - call baml.json.stringify - store_var _52 - load_const "mcp/" - load_var _43 - bin_op + - load_var2 17 18 - load_var _52 - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> void { - load_type string - load_var line - load_const "\n" - load_type string - alloc_array 2 - load_const "" - call baml.Array.join - store_var framed - load_var self - load_field .p - load_var framed - sys_op baml.sys.Process.write_stdin - pop 1 - jump L0 - load_var e - throw_if_panic - load_type string - load_var self - load_field .server_name - call baml.String.from - store_var _12 - load_type baml.errors.Io - load_var e - call baml.String.from - store_var _17 - load_type string - load_var _17 - call baml.String.from - store_var _16 - load_const "mcp/" - load_var _12 - bin_op + - load_const "writing to the MCP server failed: " - load_var _16 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L0: - load_const null - return -} - -function ai.mcp.McpConnection.call_tool(self: ai.mcp.McpConnection, name: string, args: map) -> string { - load_var self - load_const "tools/call" - load_var2 2 3 - load_const "name" - load_const "arguments" - load_type string - load_type unknown - alloc_map 2 - call ai.mcp.McpConnection._request - store_var result - load_type string - alloc_array 0 - store_var texts - load_type baml.json.json[] - load_var result - load_const ".content" - load_type baml.json.json - alloc_array 0 - call baml.json.path_or - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - - L0: - load_var _12 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _13 - load_var _13 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _13 - store_var item - load_type string - load_var item - load_const ".type" - load_const "" - call baml.json.path_or - load_const "text" - cmp_op == - pop_jump_if_false L0 - load_type string - load_var item - load_const ".text" - load_const "" - call baml.json.path_or - store_var _22 - load_type string - load_var2 5 9 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_type string - load_var texts - load_const "\n" - call baml.Array.join - store_var joined - load_type bool - load_var result - load_const ".isError" - load_const false - call baml.json.path_or - pop_jump_if_false L3 - jump L4 - - L3: - load_var joined - return - - L4: - load_type string - load_var name - call baml.String.from - store_var _35 - load_type string - load_var joined - call baml.String.from - store_var _37 - load_const "mcp tool " - load_var _35 - bin_op + - load_const " failed: " - bin_op + - load_var _37 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw -} - -function ai.mcp.McpConnection.close(self: ai.mcp.McpConnection) -> void { - load_var self - load_field .p - sys_op baml.sys.Process.close - pop 1 - load_const null - return -} - -function ai.mcp.McpConnection.connect(name: string, command: string, args: string[], timeout_ms: int) -> ai.mcp.McpConnection { - load_var timeout_ms - load_const - cmp_op == - pop_jump_if_false L0 - load_const 30000 - store_var timeout_ms - - L0: - load_var2 2 3 - load_const null - load_const null - load_var timeout_ms - load_const null - load_const true - init_instance baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open - sys_op baml.sys.start_process - store_var p - jump L1 - load_var e - throw_if_panic - load_type string - load_var name - call baml.String.from - store_var _11 - load_type baml.errors.Io - load_var e - call baml.String.from - store_var _15 - load_type string - load_var _15 - call baml.String.from - store_var _14 - load_const "mcp/" - load_var _11 - bin_op + - load_const "the MCP server could not start: " - load_var _14 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L1: - load_var2 1 5 - load_const 1 - init_instance ai.mcp.McpConnection .server_name, .p, .next_id - store_var conn - load_var conn - load_const "initialize" - load_const "2025-06-18" - load_type string - load_type unknown - alloc_map 0 - load_const "baml-mcp" - load_const "0.1" - load_const "name" - load_const "version" - load_type string - load_type string - alloc_map 2 - load_const "protocolVersion" - load_const "capabilities" - load_const "clientInfo" - load_type string - load_type unknown - alloc_map 3 - call ai.mcp.McpConnection._request - pop 1 - load_const null - load_const "notifications/initialized" - load_const null - call ai.mcp.rpc_line - store_var _26 - load_var2 10 11 - call ai.mcp.McpConnection._send - pop 1 - load_var conn - return -} - -function ai.mcp.McpConnection.tools(self: ai.mcp.McpConnection) -> ai.tools.Tool[] { - load_var self - load_const "tools/list" - load_type string - load_type unknown - alloc_map 0 - call ai.mcp.McpConnection._request - store_var result - load_type ai.tools.Tool - alloc_array 0 - store_var out - load_type baml.json.json[] - load_var result - load_const ".tools" - load_type baml.json.json - alloc_array 0 - call baml.json.path_or - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var t - load_type string - load_var t - load_const ".name" - load_const "" - call baml.json.path_or - store_var tool_name - load_type baml.json.json - load_var t - load_const ".inputSchema" - load_type string - load_type baml.json.json - alloc_map 0 - call baml.json.path_or - store_var _19 - load_type map - load_var _19 - call baml.json.from_json - store_var schema - jump L2 - load_var e - throw_if_panic - load_type string - load_type unknown - alloc_map 0 - store_var schema - - L2: - load_type string - load_var t - load_const ".description" - load_const "" - call baml.json.path_or - store_var _28 - load_var schema - store_var _31 - load_var2 1 7 - call ai.internal._proxy - store_var _32 - load_var2 7 12 - load_var2 13 14 - load_const - call ai.tools.raw_tool - store_var _26 - load_type ai.tools.Tool - load_var2 3 11 - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var out - return -} - -function ai.mcp.rpc_line(id: int | null, method: string, params: map | null) -> string { - load_const "2.0" - load_var method - load_const "jsonrpc" - load_const "method" - load_type string - load_type unknown - alloc_map 2 - store_var m - load_var id - store_var _5 - load_var _5 - narrow_bind int, slot=5 - pop_jump_if_false L0 - load_type string - load_type unknown - load_var m - load_const "id" - load_var _5 - call baml.Map.set - pop 1 - - L0: - load_var params - store_var _11 - load_var _11 - narrow_bind map, slot=6 - pop_jump_if_false L1 - load_type string - load_type unknown - load_var m - load_const "params" - load_var _11 - call baml.Map.set - pop 1 - - L1: - load_type map - load_var m - call baml.json.to_json - call baml.json.stringify - return -} - -function ai.prompt(body: ((string) -> ai.Role throws never, ai.Context) -> baml.TaggedString throws never) -> (ai.Context) -> ai.Prompt throws never { - load_var ?1 - make_cell - store_var ?1 - load_var body - make_closure ., 1 - return -} - -function ai.stream.Stream.final(self: ai.stream.Stream<#0, #1>) -> #1 { - L0: - load_var self - load_field ._finished - unary_op ! - pop_jump_if_false L1 - jump L2 - - L1: - load_var self - load_field ._text - load_var self - load_field ._cache - load_type #0 - load_type #1 - sys_op baml.sap.__parse_final - return - - L2: - load_var self - load_field ._next_text - call_indirect - store_var _4 - load_var _4 - load_const null - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_var2 1 1 - load_field ._text - load_var _4 - bin_op + - store_field ._text - jump L0 - - L4: - load_var self - load_const true - store_field ._finished - jump L0 -} - -function ai.stream.Stream.next(self: ai.stream.Stream<#0, #1>) -> #0 | ai.stream.Done { - L0: - load_const true - pop_jump_if_false L1 - jump L2 - - L1: - load_const "unreachable" - call baml.sys.panic - jump L8 - - L2: - load_var self - load_field ._finished - pop_jump_if_false L3 - jump L7 - - L3: - load_var self - load_field ._next_text - call_indirect - store_var _3 - load_var _3 - load_const null - cmp_op == - pop_jump_if_false L4 - jump L6 - - L4: - load_var2 1 1 - load_field ._text - load_var _3 - bin_op + - store_field ._text - load_var self - load_field ._text - load_var self - load_field ._cache - load_type #0 - load_type #1 - sys_op baml.sap.__parse_partial - store_var parsed - load_var parsed - is_type baml.sap.NoYield - pop_jump_if_false L5 - jump L0 - - L5: - load_var parsed - jump L8 - - L6: - load_var self - load_const true - store_field ._finished - alloc_instance ai.stream.Done - jump L8 - - L7: - alloc_instance ai.stream.Done - - L8: - return -} - -function ai.stream.TurnStream._check_terminal(self: ai.stream.TurnStream) -> void { - load_var self - load_field ._require_terminal - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L3 - - L1: - load_var _3 - store_var provider - load_var self - load_field ._saw_terminal - unary_op ! - pop_jump_if_false L2 - jump L4 - - L2: - load_const null - - L3: - return - - L4: - load_var self - load_field ._text - load_const "" - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_var self - load_field ._text - store_var partial - jump L7 - - L6: - load_const null - store_var partial - - L7: - load_var self - load_field ._text - call baml.String.length - store_var _15 - load_type int - load_var _15 - call baml.String.from - store_var _14 - load_var provider - load_const "stream ended before the provider's terminal event: the connection closed after " - load_var _14 - bin_op + - load_const " characters of assistant text with no end-of-turn event, so the turn is truncated" - bin_op + - load_var partial - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw -} - -function ai.stream.TurnStream._finish(self: ai.stream.TurnStream) -> void { - load_var self - load_const true - store_field ._done - load_var self - load_field ._sse - store_var _3 - load_var _3 - narrow_bind baml.http.SseStream, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_var _3 - sys_op baml.http.SseStream.close - pop 1 - load_const null - - L2: - return -} - -function ai.stream.TurnStream.final_turn(self: ai.stream.TurnStream) -> ai.ModelTurn { - L0: - load_const true - pop_jump_if_false L1 - load_var self - call ai.stream.TurnStream.next - store_var _3 - load_var _3 - narrow_bind ai.stream.Done, slot=2 - pop_jump_if_false L0 - - L1: - load_var self - call ai.stream.TurnStream._check_terminal - pop 1 - load_var self - load_field ._input_tokens - load_const null - call baml.ops.equals_equals - unary_op ! - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var self - load_field ._output_tokens - load_const null - call baml.ops.equals_equals - unary_op ! - - L3: - pop_jump_if_false L4 - jump L5 - - L4: - load_const null - store_var usage - jump L8 - - L5: - load_var self - load_field ._input_tokens - store_var_load_var _13 - load_const null - cmp_op == - pop_jump_if_false L6 - load_const 0 - store_var _13 - - L6: - load_var _13 - store_var _12 - load_var self - load_field ._output_tokens - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const 0 - store_var _17 - - L7: - load_var2 4 6 - load_const null - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L8: - load_var self - load_field ._stop_reason - store_var_load_var _24 - load_const null - cmp_op == - pop_jump_if_false L9 - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var _24 - - L9: - load_var self - load_field ._text - init_instance ai.content.Text .text - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 1 - load_var2 7 3 - init_instance ai.ModelTurn .content, .stop_reason, .usage - return -} - -function ai.stream.TurnStream.from_chunks(chunks: string[]) -> ai.stream.TurnStream { - load_const null - load_const null - load_var chunks - load_const 0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - load_const 0 - load_const "" - load_const null - load_const null - load_const null - load_const false - load_const null - load_const false - init_instance ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal - return -} - -function ai.stream.TurnStream.from_sse(sse: baml.http.SseStream, decode: (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown, require_terminal: string | null) -> ai.stream.TurnStream { - load_var require_terminal - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var require_terminal - - L0: - load_var2 1 2 - load_type string - alloc_array 0 - load_const 0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - load_const 0 - load_const "" - load_const null - load_const null - load_const null - load_const false - load_var require_terminal - load_const false - init_instance ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done, ._require_terminal, ._saw_terminal - return -} - -function ai.stream.TurnStream.next(self: ai.stream.TurnStream) -> string | ai.stream.Done { - L0: - load_const true - pop_jump_if_false L1 - jump L2 - - L1: - load_const "unreachable" - call baml.sys.panic - jump L21 - - L2: - load_var self - load_field ._done - pop_jump_if_false L3 - jump L20 - - L3: - load_var self - load_field ._pcursor - store_var _4 - load_var self - load_field ._pending - container_len - store_var _5 - load_var2 2 3 - cmp_int_op < - pop_jump_if_false L4 - jump L13 - - L4: - load_var self - load_field ._sse - store_var _33 - load_var _33 - narrow_bind baml.http.SseStream, slot=15 - pop_jump_if_false L5 - jump L8 - - L5: - load_type string - load_var self - load_field ._chunks - load_var self - load_field ._cursor - call baml.Array.at - store_var _59 - load_var _59 - narrow_bind string, slot=20 - pop_jump_if_false L6 - jump L7 - - L6: - load_var self - call ai.stream.TurnStream._finish - pop 1 - alloc_instance ai.stream.Done - jump L21 - - L7: - load_var _59 - store_var c - load_var self - copy 0 - load_field ._cursor - load_const 1 - bin_op + - store_field ._cursor - load_type string - load_var self - load_field ._text - call baml.String.from - store_var _61 - load_type string - load_var c - call baml.String.from - store_var _64 - load_var2 1 22 - load_var _64 - bin_op + - store_field ._text - load_var c - jump L21 - - L8: - load_var _33 - sys_op baml.http.SseStream.next - store_var _35 - load_var _35 - load_const null - cmp_op == - pop_jump_if_false L9 - jump L12 - - L9: - load_var self - load_field ._decode - store_var _41 - load_var _41 - narrow_bind (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown, slot=17 - pop_jump_if_false L0 - load_var2 16 17 - call_indirect - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _46 - - L10: - load_var _46 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _47 - load_var _47 - is_type baml.iter.Done - pop_jump_if_false L11 - jump L0 - - L11: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var self - load_field ._pending - load_var _47 - call baml.Array.push - pop 1 - jump L10 - - L12: - load_var self - call ai.stream.TurnStream._finish - pop 1 - load_var self - call ai.stream.TurnStream._check_terminal - pop 1 - alloc_instance ai.stream.Done - jump L21 - - L13: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var self - load_field ._pending - load_var self - load_field ._pcursor - call baml.Array.at - store_var e - load_var self - copy 0 - load_field ._pcursor - load_const 1 - bin_op + - store_field ._pcursor - load_var e - store_var _11 - load_var _11 - narrow_bind ai.stream.TextDelta, slot=5 - pop_jump_if_false L14 - jump L19 - - L14: - load_var e - store_var _19 - load_var _19 - narrow_bind ai.stream.TurnMeta, slot=9 - pop_jump_if_false L15 - jump L16 - - L15: - load_var e - store_var _30 - load_var _30 - narrow_bind ai.stream.TurnDone, slot=14 - pop_jump_if_false L0 - load_var self - load_const true - store_field ._saw_terminal - load_var self - call ai.stream.TurnStream._finish - pop 1 - alloc_instance ai.stream.Done - jump L21 - - L16: - load_var _19 - store_var_load_var m - load_field .stop_reason - store_var _22 - load_var _22 - narrow_bind ai.content.StopReason, slot=11 - pop_jump_if_false L17 - load_var2 1 11 - store_field ._stop_reason - - L17: - load_var m - load_field .input_tokens - store_var _25 - load_var _25 - narrow_bind int, slot=12 - pop_jump_if_false L18 - load_var2 1 12 - store_field ._input_tokens - - L18: - load_var m - load_field .output_tokens - store_var _28 - load_var _28 - narrow_bind int, slot=13 - pop_jump_if_false L0 - load_var2 1 13 - store_field ._output_tokens - jump L0 - - L19: - load_var _11 - store_var d - load_type string - load_var self - load_field ._text - call baml.String.from - store_var _13 - load_type string - load_var d - load_field .text - call baml.String.from - store_var _16 - load_var2 1 7 - load_var _16 - bin_op + - store_field ._text - load_var d - load_field .text - jump L21 - - L20: - alloc_instance ai.stream.Done - - L21: - return -} - -function ai.stream.decode_sse_batch(batch: string) -> ai.stream.SseEvent[] { - load_type ai.stream.SseEvent[] - load_var batch - call baml.json.from_string - return -} - -function ai.stream.from_spec(spec: ai.FunctionSpec<#1>, client: ai.stream.StreamingClient | null) -> ai.stream.Stream<#0, #1> { - load_var ?10 - make_cell - store_var ?10 - load_var client - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var client - - L0: - load_type #1 - load_var spec - call ai.FunctionSpec.tools - call ai.tools.Toolbox.is_empty - unary_op ! - pop_jump_if_false L1 - jump L7 - - L1: - load_var client - store_var _16 - load_var _16 - narrow_bind ai.stream.StreamingClient, slot=6 - pop_jump_if_false L2 - jump L5 - - L2: - load_var spec - load_field .default_client - store_var _19 - load_var _19 - narrow_bind ai.stream.StreamingClient, slot=7 - pop_jump_if_false L3 - jump L4 - - L3: - load_var spec - load_field .default_client - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _22 - load_var _22 - init_instance ai.errors.StreamingUnsupported .client_id - throw - - L4: - load_var _19 - store_var selected - jump L6 - - L5: - load_var _16 - store_var selected - - L6: - load_var selected - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var provider - load_var spec - load_field .prompt_template - store_var _28 - load_type #1 - load_var spec - call ai.Journal.new - store_var _29 - load_type #1 - load_var spec - call ai.FunctionSpec.tools - store_var _31 - load_type #1 - load_var spec - call ai.FunctionSpec.output_type - store_var _33 - load_var2 5 11 - load_var2 12 13 - load_var _33 - init_instance ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type - load_type ai.stream.StreamingClient - load_const "invoke_stream" - virtual_call nargs=2 ntypeargs=0 - store_deref ?10 - load_type #0 - load_type #1 - call baml.sap.__new_parse_cache - store_var _36 - load_type #0 - load_type #1 - load_var turns - make_closure ., captures=1, ntypeargs=2 - load_var _36 - load_const "" - load_const false - load_type #0 - load_type #1 - init_instance<2> ai.stream.Stream ._next_text, ._cache, ._text, ._finished - return - - L7: - load_type #1 - load_var spec - call ai.FunctionSpec.name - store_var _12 - load_type string - load_var _12 - call baml.String.from - store_var _11 - load_const "streaming does not run the tool loop yet: " - load_var _11 - bin_op + - load_const " has a non-empty toolbox" - bin_op + - init_instance baml.errors.InvalidArgument .message - throw -} - -function ai.tools.Tool.call(self: ai.tools.Tool, args: map) -> string { - load_var self - load_field .raw_handler - store_var _4 - load_var _4 - narrow_bind (map) -> string throws unknown, slot=3 - pop_jump_if_false L0 - jump L6 - - L0: - load_var self - load_field .handler - store_var _8 - load_var _8 - narrow_bind baml.AnyFunction, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var self - load_field .name - call baml.String.from - store_var _34 - load_const "tool " - load_var _34 - bin_op + - load_const " has no handler" - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L2: - load_type unknown - load_type unknown - load_var2 4 2 - call baml.reflect.call_any - store_var value - jump L5 - load_var e - store_var _15 - load_var _15 - narrow_bind baml.reflect.InvalidArgumentError, slot=7 - pop_jump_if_false L3 - jump L4 - - L3: - load_var e - rethrow - - L4: - load_var _15 - store_var bad - load_type string - load_var self - load_field .name - call baml.String.from - store_var _21 - load_type baml.reflect.InvalidArgumentError - load_var bad - call baml.String.from - store_var _25 - load_type string - load_var _25 - call baml.String.from - store_var _24 - load_const "invalid arguments for " - load_var _21 - bin_op + - load_const ": " - bin_op + - load_var _24 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L5: - load_type unknown - load_var value - call baml.json.to_json - call baml.json.stringify - jump L7 - - L6: - load_var2 2 3 - call_indirect - - L7: - return -} - -function ai.tools.Toolbox.get(self: ai.tools.Toolbox, name: string) -> ai.tools.Tool | null { - load_var ?2 - make_cell - store_var ?2 - load_type ai.tools.Tool - load_type never - load_var self - load_field .entries - load_var name - make_closure ., 1 - call baml.Array.find - return -} - -function ai.tools.Toolbox.is_empty(self: ai.tools.Toolbox) -> bool { - load_var self - load_field .entries - container_len - store_var _2 - load_var _2 - load_const 0 - cmp_int_op == - return -} - -function ai.tools.Toolbox.list(self: ai.tools.Toolbox) -> ai.tools.Tool[] { - load_var self - load_field .entries - return -} - -function ai.tools.Toolbox.new(tools: ai.tools.Tool[]) -> ai.tools.Toolbox { - load_type string - alloc_array 0 - store_var names - load_var tools - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _4 - store_var t - load_type string - load_var2 2 5 - load_field .name - call baml.Array.includes - pop_jump_if_false L2 - jump L3 - - L2: - load_type string - load_var2 2 5 - load_field .name - call baml.Array.push - pop 1 - jump L0 - - L3: - load_type string - load_var t - load_field .name - call baml.String.from - store_var _13 - load_const "duplicate tool name: " - load_var _13 - bin_op + - init_instance baml.errors.InvalidArgument .message - throw - - L4: - load_var tools - init_instance ai.tools.Toolbox .entries - return -} - -function ai.tools.raw_tool(name: string, description: string, input_schema: map, handler: (map) -> string throws unknown, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - load_var on_error - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var on_error - - L0: - load_var name - load_const "__baml_return_output" - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 1 2 - load_var input_schema - load_const null - load_var2 4 5 - init_instance ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error - return - - L2: - load_const "the tool name __baml_return_output is reserved" - init_instance baml.errors.InvalidArgument .message - throw -} - -function ai.tools.tool(handler: baml.AnyFunction, name: string | null, description: string | null, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { - load_var name - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var name - - L0: - load_var description - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var description - - L1: - load_var on_error - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var on_error - - L2: - load_var handler - call baml.reflect.signature - store_var sig - load_var name - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L3 - load_var sig - load_field .name - store_var _10 - - L3: - load_var _10 - store_var _12 - load_var _12 - narrow_bind string, slot=7 - pop_jump_if_false L4 - jump L5 - - L4: - load_const "anonymous tool needs a name" - init_instance baml.errors.InvalidArgument .message - throw - - L5: - load_var _12 - store_var_load_var n - load_const "__baml_return_output" - cmp_op == - pop_jump_if_false L6 - jump L9 - - L6: - load_var description - store_var_load_var _21 - load_const null - cmp_op == - pop_jump_if_false L7 - load_var sig - load_field .docstring - store_var _21 - - L7: - load_var _21 - store_var_load_var _19 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const "" - store_var _19 - - L8: - load_var _19 - store_var _18 - load_var handler - call ai.internal._schema_for_signature - store_var _24 - load_var2 8 9 - load_var2 12 1 - load_const null - load_var on_error - init_instance ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error - return - - L9: - load_const "the tool name __baml_return_output is reserved" - init_instance baml.errors.InvalidArgument .message - throw -} - -function ai.wire.credential_sources(cred: string | baml.env.Ref | null, canonical_env: string | null) -> string { - load_type string - alloc_array 0 - store_var names - load_var cred - store_var _4 - load_var _4 - narrow_bind baml.env.Ref, slot=4 - pop_jump_if_false L0 - load_type string - load_var2 3 4 - load_field .name - call baml.Array.push - pop 1 - - L0: - load_var canonical_env - store_var _9 - load_var _9 - narrow_bind string, slot=5 - pop_jump_if_false L1 - load_type string - load_var2 3 5 - call baml.Array.push - pop 1 - - L1: - load_var names - container_len - store_var _15 - load_var _15 - load_const 0 - cmp_int_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_type string - load_var names - load_const ", " - call baml.Array.join - jump L4 - - L3: - load_const "(no environment variable was named)" - - L4: - return -} - -function ai.wire.merge_request_body(base: baml.json.json, overrides: baml.json.json | null) -> baml.json.json { - load_var overrides - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var2 1 2 - call ai.internal._merge_json - jump L2 - - L1: - load_var base - - L2: - return -} - -function ai.wire.redact_url_secrets(text: string) -> string { - load_var text - load_const "key=" - call ai.internal._redact_after - load_const "token=" - call ai.internal._redact_after - load_const "secret=" - call ai.internal._redact_after - return -} - -function ai.wire.render_output_format(t: type) -> string { - load_var t - call ai.internal.validate_output_type - pop 1 - load_var t - sys_op ai.internal.render_output_format - return -} - -function ai.wire.resolve_credential(cred: string | baml.env.Ref | null, env_fallback: string | null) -> string | null { - load_var cred - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L4 - - L0: - load_var cred - store_var _7 - load_var _7 - narrow_bind baml.env.Ref, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_const null - jump L5 - - L2: - load_var _7 - call baml.env.Ref.get - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _10 - - L3: - load_var _10 - call ai.internal._configured - jump L5 - - L4: - load_var _4 - call ai.internal._configured - - L5: - store_var _13 - load_var _13 - narrow_bind string, slot=6 - pop_jump_if_false L6 - jump L10 - - L6: - load_var env_fallback - store_var _15 - load_var _15 - narrow_bind string, slot=7 - pop_jump_if_false L7 - jump L8 - - L7: - load_const null - jump L11 - - L8: - load_var _15 - sys_op baml.env.get - store_var_load_var _18 - load_const null - cmp_op == - pop_jump_if_false L9 - load_const "" - store_var _18 - - L9: - load_var _18 - call ai.internal._configured - jump L11 - - L10: - load_var _13 - - L11: - return -} - -function ai.wire.resolve_media(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> ai.wire.ResolvedMedia { - load_var media - store_var _3 - load_var _3 - narrow_bind baml.media.Image, slot=3 - pop_jump_if_false L0 - jump L11 - - L0: - load_var media - store_var _18 - load_var _18 - narrow_bind baml.media.Audio, slot=12 - pop_jump_if_false L1 - jump L8 - - L1: - load_var media - store_var _33 - load_var _33 - narrow_bind baml.media.Video, slot=21 - pop_jump_if_false L2 - jump L5 - - L2: - load_var media - call baml.media.Pdf.file - store_var_load_var _52 - load_const null - cmp_op == - pop_jump_if_false L3 - load_var media - call baml.media.Pdf.url - store_var _52 - - L3: - load_var _52 - store_var_load_var _50 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const "" - store_var _50 - - L4: - load_var _50 - store_var source - load_var media - call baml.media.Pdf.url - store_var _56 - load_var media - call baml.media.Pdf.file - store_var _57 - load_var media - call baml.media.Pdf.base64 - store_var _58 - load_var media - call baml.media.Pdf.mime_type - load_var source - load_const "pdf" - call ai.internal._media_mime_type - store_var _59 - load_var2 33 34 - load_var2 35 36 - load_var fetch_url - call ai.internal._resolve_media_content - jump L14 - - L5: - load_var _33 - store_var video - load_var video - call baml.media.Video.file - store_var_load_var _38 - load_const null - cmp_op == - pop_jump_if_false L6 - load_var video - call baml.media.Video.url - store_var _38 - - L6: - load_var _38 - store_var_load_var _36 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const "" - store_var _36 - - L7: - load_var _36 - store_var source - load_var video - call baml.media.Video.url - store_var _42 - load_var video - call baml.media.Video.file - store_var _43 - load_var video - call baml.media.Video.base64 - store_var _44 - load_var video - call baml.media.Video.mime_type - load_var source - load_const "video" - call ai.internal._media_mime_type - store_var _45 - load_var2 26 27 - load_var2 28 29 - load_var fetch_url - call ai.internal._resolve_media_content - jump L14 - - L8: - load_var _18 - store_var audio - load_var audio - call baml.media.Audio.file - store_var_load_var _23 - load_const null - cmp_op == - pop_jump_if_false L9 - load_var audio - call baml.media.Audio.url - store_var _23 - - L9: - load_var _23 - store_var_load_var _21 - load_const null - cmp_op == - pop_jump_if_false L10 - load_const "" - store_var _21 - - L10: - load_var _21 - store_var source - load_var audio - call baml.media.Audio.url - store_var _27 - load_var audio - call baml.media.Audio.file - store_var _28 - load_var audio - call baml.media.Audio.base64 - store_var _29 - load_var audio - call baml.media.Audio.mime_type - load_var source - load_const "audio" - call ai.internal._media_mime_type - store_var _30 - load_var2 17 18 - load_var2 19 20 - load_var fetch_url - call ai.internal._resolve_media_content - jump L14 - - L11: - load_var _3 - store_var image - load_var image - call baml.media.Image.file - store_var_load_var _8 - load_const null - cmp_op == - pop_jump_if_false L12 - load_var image - call baml.media.Image.url - store_var _8 - - L12: - load_var _8 - store_var_load_var _6 - load_const null - cmp_op == - pop_jump_if_false L13 - load_const "" - store_var _6 - - L13: - load_var _6 - store_var source - load_var image - call baml.media.Image.url - store_var _12 - load_var image - call baml.media.Image.file - store_var _13 - load_var image - call baml.media.Image.base64 - store_var _14 - load_var image - call baml.media.Image.mime_type - load_var source - load_const "image" - call ai.internal._media_mime_type - store_var _15 - load_var2 8 9 - load_var2 10 11 - load_var fetch_url - call ai.internal._resolve_media_content - - L14: - return -} - -function ai.wire.sanitize_for_client(j: ai.Journal, client_id: string) -> ai.Journal { - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - alloc_array 0 - store_var out - load_type string - alloc_array 0 - store_var pending - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - - L0: - load_var _6 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var _7 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L12 - - L1: - load_var _7 - store_var event - load_var event - store_var _11 - load_var _11 - narrow_bind ai.events.AssistantMessage, slot=8 - pop_jump_if_false L2 - jump L9 - - L2: - load_var event - store_var _38 - load_var _38 - narrow_bind ai.events.UserMessage, slot=15 - pop_jump_if_false L3 - jump L8 - - L3: - load_var event - store_var _46 - load_var _46 - narrow_bind ai.events.ToolCompleted, slot=17 - pop_jump_if_false L4 - jump L7 - - L4: - load_var event - store_var _54 - load_var _54 - narrow_bind ai.events.ToolFailed, slot=19 - pop_jump_if_false L5 - jump L6 - - L5: - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 3 7 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var _54 - store_var failed - load_var2 4 20 - load_field .id - call ai.internal._resolve_pending_call - pop 1 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 3 20 - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var _46 - store_var completed - load_var2 4 18 - load_field .id - call ai.internal._resolve_pending_call - pop 1 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 3 18 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var _38 - store_var user - load_var2 3 4 - call ai.internal._flush_orphaned_calls - pop 1 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 3 16 - call baml.Array.push - pop 1 - jump L0 - - L9: - load_var _11 - store_var assistant - load_var2 3 4 - call ai.internal._flush_orphaned_calls - pop 1 - load_var assistant - load_field .content - load_var assistant - load_field .client_id - load_var client_id - cmp_op == - call ai.internal._wire_blocks - store_var blocks - load_var blocks - container_len - store_var _21 - load_var _21 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_type ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced - load_var2 3 10 - load_var assistant - load_field .client_id - init_instance ai.events.AssistantMessage .content, .client_id - call baml.Array.push - pop 1 - load_var blocks - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L10: - load_var _28 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L11 - jump L0 - - L11: - load_var _29 - store_var _33 - load_var _33 - narrow_bind ai.content.ToolUse, slot=14 - pop_jump_if_false L10 - load_type string - load_var2 4 14 - load_field .id - call baml.Array.push - pop 1 - jump L10 - - L12: - load_var2 3 4 - call ai.internal._flush_orphaned_calls - pop 1 - load_var out - init_instance ai.Journal .log - return -} - -function ai.wire.send_as(req: baml.http.Request, provider: string) -> #0 { - load_var req - load_const - call baml.http.send - store_var resp - jump L0 - load_var e - throw_if_panic - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - call ai.wire.redact_url_secrets - store_var _8 - load_type string - load_var _8 - call baml.String.from - store_var _7 - load_var provider - load_const "transport failed before a response arrived: " - load_var _7 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L0: - load_var resp - sys_op baml.http.Response.text - store_var text - jump L1 - load_var e - throw_if_panic - load_var provider - load_const "the response body could not be read completely" - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L1: - load_var resp - call baml.http.Response.ok - unary_op ! - pop_jump_if_false L2 - jump L4 - - L2: - load_type #0 - load_var text - call baml.json.from_string - jump L3 - load_var e - throw_if_panic - load_var2 2 7 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L3: - return - - L4: - load_var2 2 3 - load_field .status_code - load_var2 7 3 - load_field .headers - call ai.errors.classify_http - throw -} - -function anthropic.AnthropicClient.ai.Client.id(self: anthropic.AnthropicClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "anthropic/" - load_var _2 - bin_op + - return -} - -function anthropic.AnthropicClient.ai.Client.invoke(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call anthropic.internal.invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function anthropic.AnthropicClient.ai.stream.StreamingClient.invoke_stream(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var2 1 2 - call anthropic.internal.invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function anthropic.AnthropicClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, max_tokens: int, temperature: float | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, thinking: anthropic.ThinkingConfig | null, tool_choice: anthropic.ToolChoice | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> anthropic.AnthropicClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "claude-haiku-4-5" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L3 - load_const 8192 - store_var max_tokens - - L3: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var temperature - - L4: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var top_p - - L5: - load_var top_k - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var top_k - - L6: - load_var stop_sequences - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var stop_sequences - - L7: - load_var thinking - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var thinking - - L8: - load_var tool_choice - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var tool_choice - - L9: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var request_body - - L10: - load_var headers - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var headers - - L11: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var query_params - - L12: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var query_params - init_instance anthropic.AnthropicClient .model, .api_key, .base_url, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .headers, .query_params - return -} - -function anthropic.AnthropicClient.resolved_api_key(self: anthropic.AnthropicClient) -> string { - load_var self - load_field .api_key - load_const "ANTHROPIC_API_KEY" - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .api_key - load_const "ANTHROPIC_API_KEY" - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "anthropic needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — " - load_var _8 - bin_op + - call anthropic.internal._reject - throw - - L1: - load_var _4 - return -} - -function anthropic.AnthropicClient.resolved_base_url(self: anthropic.AnthropicClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function anthropic.ThinkingConfig.disabled() -> anthropic.ThinkingConfig { - load_const "disabled" - load_const null - init_instance anthropic.ThinkingConfig .type, .budget_tokens - return -} - -function anthropic.ThinkingConfig.enabled(budget_tokens: int) -> anthropic.ThinkingConfig { - load_const "enabled" - load_var budget_tokens - init_instance anthropic.ThinkingConfig .type, .budget_tokens - return -} - -function anthropic.ToolChoice.any(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - load_var disable_parallel_tool_use - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var disable_parallel_tool_use - - L0: - load_const "any" - load_const null - load_var disable_parallel_tool_use - init_instance anthropic.ToolChoice .type, .name, .disable_parallel_tool_use - return -} - -function anthropic.ToolChoice.auto(disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - load_var disable_parallel_tool_use - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var disable_parallel_tool_use - - L0: - load_const "auto" - load_const null - load_var disable_parallel_tool_use - init_instance anthropic.ToolChoice .type, .name, .disable_parallel_tool_use - return -} - -function anthropic.ToolChoice.none() -> anthropic.ToolChoice { - load_const "none" - load_const null - load_const null - init_instance anthropic.ToolChoice .type, .name, .disable_parallel_tool_use - return -} - -function anthropic.ToolChoice.tool(name: string, disable_parallel_tool_use: bool | null) -> anthropic.ToolChoice { - load_var disable_parallel_tool_use - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var disable_parallel_tool_use - - L0: - load_const "tool" - load_var2 1 2 - init_instance anthropic.ToolChoice .type, .name, .disable_parallel_tool_use - return -} - -function anthropic.internal.AnthStreamState.new() -> anthropic.internal.AnthStreamState { - load_const "" - load_const "" - load_type anthropic.internal.AnthStreamToolCall - alloc_array 0 - load_const null - load_const null - load_const null - load_const null - load_const null - init_instance anthropic.internal.AnthStreamState .thinking, .signature, .tool_calls, .cache_read_input_tokens, .cache_creation_input_tokens, .reasoning_tokens, .stop_reason_raw, .model - return -} - -function anthropic.internal.AnthStreamState.tool_uses(self: anthropic.internal.AnthStreamState) -> ai.content.ToolUse[] { - load_type ai.content.ToolUse - alloc_array 0 - store_var out - load_var self - load_field .tool_calls - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L5 - - L1: - load_var _5 - store_var call - load_type string - load_type unknown - alloc_map 0 - store_var empty - load_var call - load_field .args_json - call baml.String.trim - load_const "" - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_type map - load_var call - load_field .args_json - call baml.json.from_string - store_var args - jump L4 - load_var e - throw_if_panic - load_var empty - store_var args - jump L4 - - L3: - load_var empty - store_var args - - L4: - load_type ai.content.ToolUse - load_var2 2 5 - load_field .id - load_var call - load_field .name - load_var args - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var out - return -} - -function anthropic.internal._anth_apply_cache_control(blocks: (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[], cache_control: baml.json.json | null) -> void { - load_var cache_control - load_const null - cmp_op == - pop_jump_if_false L0 - jump L11 - - L0: - load_var blocks - container_len - store_var _6 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var2 1 3 - load_const 1 - sub_int - call baml.Array.at - store_var _8 - load_var _8 - narrow_bind anthropic.internal.AnthTextBlock, slot=4 - pop_jump_if_false L1 - jump L4 - - L1: - load_var _8 - narrow_bind anthropic.internal.AnthMediaBlock, slot=4 - pop_jump_if_false L2 - jump L4 - - L2: - load_var _8 - narrow_bind anthropic.internal.AnthToolUseBlock, slot=4 - pop_jump_if_false L3 - jump L4 - - L3: - load_var _8 - narrow_bind anthropic.internal.AnthToolResultBlock, slot=4 - pop_jump_if_false L11 - - L4: - load_var _8 - store_var last - load_var last - store_var _10 - load_var _10 - narrow_bind anthropic.internal.AnthTextBlock, slot=6 - pop_jump_if_false L5 - jump L10 - - L5: - load_var last - store_var _12 - load_var _12 - narrow_bind anthropic.internal.AnthMediaBlock, slot=7 - pop_jump_if_false L6 - jump L9 - - L6: - load_var last - store_var _14 - load_var _14 - narrow_bind anthropic.internal.AnthToolUseBlock, slot=8 - pop_jump_if_false L7 - jump L8 - - L7: - load_var2 5 2 - store_field .cache_control - jump L11 - - L8: - load_var2 8 2 - store_field .cache_control - jump L11 - - L9: - load_var2 7 2 - store_field .cache_control - jump L11 - - L10: - load_var2 6 2 - store_field .cache_control - - L11: - load_const null - return -} - -function anthropic.internal._anth_drop_nulls(j: baml.json.json) -> baml.json.json { - load_var j - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var j - store_var _27 - load_var _27 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var j - jump L14 - - L2: - load_type baml.json.json - alloc_array 0 - store_var out - load_var _27 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _31 - - L3: - load_var _31 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _32 - load_var _32 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _32 - call anthropic.internal._anth_drop_nulls - store_var _37 - load_type baml.json.json - load_var2 11 14 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - jump L14 - - L6: - load_var _2 - store_var obj - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var obj - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L7: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L13 - - L8: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var value - load_var value - load_const null - cmp_op == - pop_jump_if_false L9 - jump L7 - - L9: - load_var key - call anthropic.internal._anth_verbatim_subtree - pop_jump_if_false L10 - jump L11 - - L10: - load_var value - call anthropic.internal._anth_drop_nulls - store_var kept - jump L12 - - L11: - load_var value - store_var kept - - L12: - load_type string - load_type baml.json.json - load_var2 4 7 - load_var kept - call baml.Map.set - pop 1 - jump L7 - - L13: - load_var out - - L14: - return -} - -function anthropic.internal._anth_stream_call_at(state: anthropic.internal.AnthStreamState, index: int | null) -> anthropic.internal.AnthStreamToolCall | null { - load_var index - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const 1 - unary_op - - store_var _4 - - L0: - load_var _4 - store_var wanted - load_var state - load_field .tool_calls - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L1: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_var _8 - store_var_load_var call - load_field .index - load_var wanted - cmp_int_op == - pop_jump_if_false L1 - load_var call - jump L4 - - L3: - load_const null - - L4: - return -} - -function anthropic.internal._anth_stream_failure(error: anthropic.internal.AnthStreamError | null, raw: string) -> ai.errors.Failure { - load_var error - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var error - load_field .0 - jump L2 - - L1: - load_const null - - L2: - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _4 - - L3: - load_var _4 - store_var kind - load_var error - load_const null - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_var error - load_field .1 - jump L6 - - L5: - load_const null - - L6: - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L7 - load_var kind - store_var _10 - - L7: - load_var _10 - store_var detail - load_var kind - load_const "rate_limit_error" - cmp_op == - pop_jump_if_false L8 - jump L15 - - L8: - load_var kind - load_const "overloaded_error" - cmp_op == - pop_jump_if_false L9 - jump L14 - - L9: - load_var kind - load_const "api_error" - cmp_op == - pop_jump_if_false L10 - jump L13 - - L10: - load_var kind - load_const "timeout_error" - cmp_op == - pop_jump_if_false L11 - jump L12 - - L11: - load_type string - load_var kind - call baml.String.from - store_var _45 - load_type string - load_var detail - call baml.String.from - store_var _48 - load_const "anthropic" - load_const null - load_var _45 - load_const ": " - bin_op + - load_var _48 - bin_op + - load_var raw - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - jump L16 - - L12: - load_type "api_error" | "overloaded_error" | "timeout_error" - load_var kind - call baml.String.from - store_var _37 - load_type string - load_var detail - call baml.String.from - store_var _40 - load_const "anthropic" - load_var _37 - load_const ": " - bin_op + - load_var _40 - bin_op + - load_var raw - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L16 - - L13: - load_type "api_error" | "overloaded_error" | "timeout_error" - load_var kind - call baml.String.from - store_var _28 - load_type string - load_var detail - call baml.String.from - store_var _31 - load_const "anthropic" - load_var _28 - load_const ": " - bin_op + - load_var _31 - bin_op + - load_var raw - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L16 - - L14: - load_type "api_error" | "overloaded_error" | "timeout_error" - load_var kind - call baml.String.from - store_var _19 - load_type string - load_var detail - call baml.String.from - store_var _22 - load_const "anthropic" - load_var _19 - load_const ": " - bin_op + - load_var _22 - bin_op + - load_var raw - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L16 - - L15: - load_const "anthropic" - load_const null - load_var raw - init_instance ai.errors.RateLimited .provider, .retry_after_ms, .raw_body - - L16: - return -} - -function anthropic.internal._anth_supported_image_mime(mime: string) -> bool { - load_var mime - call baml.String.to_lower_case - store_var m - load_var m - load_const "image/jpeg" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var m - load_const "image/png" - cmp_op == - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var m - load_const "image/gif" - cmp_op == - - L3: - jump_if_false L4 - jump L5 - - L4: - pop 1 - load_var m - load_const "image/webp" - cmp_op == - - L5: - return -} - -function anthropic.internal._anth_verbatim_subtree(key: string) -> bool { - load_var key - load_const "input" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var key - load_const "input_schema" - cmp_op == - - L1: - return -} - -function anthropic.internal._anthropic_assistant_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 0 - store_var out - load_var content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _4 - store_var b - load_var b - store_var _8 - load_var _8 - narrow_bind ai.content.Text, slot=6 - pop_jump_if_false L2 - jump L5 - - L2: - load_var b - store_var _17 - load_var _17 - narrow_bind ai.content.Reasoning, slot=8 - pop_jump_if_false L3 - jump L0 - - L3: - load_var b - store_var _18 - load_var _18 - narrow_bind ai.content.Media, slot=9 - pop_jump_if_false L4 - jump L0 - - L4: - load_var b - store_var u - load_var u - load_field .id - store_var _22 - load_var u - load_field .name - store_var _23 - load_type map - load_var u - load_field .args - call baml.json.to_json - store_var _24 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var out - load_const "tool_use" - load_var2 11 12 - load_var _24 - load_const null - init_instance anthropic.internal.AnthToolUseBlock .type, .id, .name, .input, .cache_control - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _8 - store_var_load_var t - load_field .text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var out - load_const "text" - load_var t - load_field .text - load_const null - init_instance anthropic.internal.AnthTextBlock .type, .text, .cache_control - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var out - return -} - -function anthropic.internal._anthropic_body_params(c: anthropic.AnthropicClient) -> anthropic.internal.AnthropicBodyParams { - load_var c - load_field .model - store_var _2 - load_var c - load_field .max_tokens - store_var _3 - load_var c - load_field .temperature - store_var _4 - load_var c - load_field .top_p - store_var _5 - load_var c - load_field .top_k - store_var _6 - load_var c - load_field .stop_sequences - store_var _7 - load_var c - load_field .thinking - store_var _8 - load_var c - load_field .tool_choice - store_var _9 - load_var c - load_field .request_body - store_var _10 - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - load_var2 2 3 - load_var2 4 5 - load_var2 6 7 - load_var2 8 9 - load_var2 10 11 - init_instance anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id - return -} - -function anthropic.internal._anthropic_headers(c: anthropic.AnthropicClient) -> map { - load_const "2023-06-01" - load_const "application/json" - load_const "anthropic-version" - load_const "content-type" - load_type string - load_type string - alloc_map 2 - store_var headers - load_var c - load_field .headers - store_var _4 - load_var _4 - narrow_bind map, slot=3 - pop_jump_if_false L3 - load_var _4 - store_var extra - load_type string - load_type string - load_var extra - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var key - load_var key - call baml.String.to_lower_case - store_var _15 - load_type string - load_type string - load_var2 4 7 - call baml.Map.get - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _17 - - L2: - load_type string - load_type string - load_var2 2 8 - load_var _17 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var c - call anthropic.AnthropicClient.resolved_api_key - store_var _26 - load_type string - load_type string - load_var headers - load_const "x-api-key" - load_var _26 - call baml.Map.set - pop 1 - load_var headers - return -} - -function anthropic.internal._anthropic_lower_journal(j: ai.Journal) -> anthropic.internal.AnthropicMessage[] { - load_type anthropic.internal.AnthropicMessage - alloc_array 0 - store_var msgs - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L8 - - L1: - load_var _5 - store_var e - load_var e - store_var _9 - load_var _9 - narrow_bind ai.events.UserMessage, slot=6 - pop_jump_if_false L2 - jump L7 - - L2: - load_var e - store_var _17 - load_var _17 - narrow_bind ai.events.AssistantMessage, slot=7 - pop_jump_if_false L3 - jump L6 - - L3: - load_var e - store_var _27 - load_var _27 - narrow_bind ai.events.ToolCompleted, slot=10 - pop_jump_if_false L4 - jump L5 - - L4: - load_var e - store_var _33 - load_var _33 - narrow_bind ai.events.ToolFailed, slot=12 - pop_jump_if_false L0 - load_var _33 - store_var f - load_var2 2 13 - load_field .id - load_var f - load_field .message - load_const true - call anthropic.internal._anthropic_push_tool_result - pop 1 - jump L0 - - L5: - load_var _27 - store_var c - load_var2 2 11 - load_field .id - load_var c - load_field .output - load_const false - call anthropic.internal._anthropic_push_tool_result - pop 1 - jump L0 - - L6: - load_var _17 - load_field .content - call anthropic.internal._anthropic_assistant_blocks - store_var blocks - load_var blocks - container_len - store_var _22 - load_var _22 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_type anthropic.internal.AnthropicMessage - load_var msgs - load_const "assistant" - load_const false - load_var blocks - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - call baml.Array.push - pop 1 - jump L0 - - L7: - load_type anthropic.internal.AnthropicMessage - load_var msgs - load_const "user" - load_const false - load_const "text" - load_var _9 - load_field .content - load_const null - init_instance anthropic.internal.AnthTextBlock .type, .text, .cache_control - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 1 - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var msgs - return -} - -function anthropic.internal._anthropic_lower_prompt(prompt: ai.Prompt) -> anthropic.internal.AnthropicPrompt { - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 0 - store_var system - load_type anthropic.internal.AnthropicMessage - alloc_array 0 - store_var messages - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L9 - - L1: - load_var _6 - store_var message - load_type string - load_type baml.json.json - load_var message - load_field .metadata - load_const "cache_control" - call baml.Map.get - store_var cache_control - load_var message - load_field .role - load_const "system" - cmp_op == - pop_jump_if_false L2 - jump L6 - - L2: - load_var message - load_field .role - load_const "assistant" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_const "user" - store_var role - jump L5 - - L4: - load_const "assistant" - store_var role - - L5: - load_var2 6 11 - call anthropic.internal._anthropic_prompt_blocks - store_var blocks - load_var2 12 7 - call anthropic.internal._anth_apply_cache_control - pop 1 - load_var blocks - container_len - store_var _40 - load_var _40 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_type anthropic.internal.AnthropicMessage - load_var2 3 11 - load_const false - load_var blocks - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var message - load_const "system" - call anthropic.internal._anthropic_prompt_blocks - store_var blocks - load_var2 8 7 - call anthropic.internal._anth_apply_cache_control - pop 1 - load_var blocks - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _22 - - L7: - load_var _22 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _23 - load_var _23 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L0 - - L8: - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var2 2 10 - call baml.Array.push - pop 1 - jump L7 - - L9: - load_var2 2 3 - init_instance anthropic.internal.AnthropicPrompt .system, .messages - return -} - -function anthropic.internal._anthropic_media_block(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, block_type: string) -> anthropic.internal.AnthMediaBlock { - load_var media - load_const false - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .url - store_var _6 - load_var _6 - narrow_bind string, slot=5 - pop_jump_if_false L0 - jump L5 - - L0: - load_var block_type - load_const "image" - cmp_op == - jump_if_false L1 - pop 1 - load_var resolved - load_field .mime_type - call anthropic.internal._anth_supported_image_mime - unary_op ! - - L1: - pop_jump_if_false L2 - jump L4 - - L2: - load_var resolved - load_field .mime_type - store_var _19 - load_var resolved - load_field .base64 - store_var_load_var _21 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _21 - - L3: - load_const "base64" - load_var2 7 8 - load_const null - init_instance anthropic.internal.AnthSource .type, .media_type, .data, .url - store_var source - jump L6 - - L4: - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _16 - load_const "Anthropic does not accept " - load_var _16 - bin_op + - load_const " images: the Messages API supports image/jpeg, image/png, image/gif and image/webp" - bin_op + - call anthropic.internal._reject - throw - - L5: - load_const "url" - load_const null - load_const null - load_var _6 - init_instance anthropic.internal.AnthSource .type, .media_type, .data, .url - store_var source - - L6: - load_var2 2 4 - load_const null - init_instance anthropic.internal.AnthMediaBlock .type, .source, .cache_control - return -} - -function anthropic.internal._anthropic_prompt_blocks(message: ai.PromptMessage, role: string) -> (anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock)[] { - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 0 - store_var blocks - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L14 - - L1: - load_var _6 - store_var part - load_var part - store_var _10 - load_var _10 - narrow_bind string, slot=7 - pop_jump_if_false L2 - jump L13 - - L2: - load_var part - store_var _18 - load_var _18 - narrow_bind baml.media.Image, slot=9 - pop_jump_if_false L3 - jump L10 - - L3: - load_var part - store_var _29 - load_var _29 - narrow_bind baml.media.Audio, slot=13 - pop_jump_if_false L4 - jump L9 - - L4: - load_var part - store_var _31 - load_var _31 - narrow_bind baml.media.Pdf, slot=14 - pop_jump_if_false L5 - jump L6 - - L5: - load_const "Anthropic does not support video prompt input" - call anthropic.internal._reject - throw - - L6: - load_var _31 - store_var pdf - load_var role - load_const "user" - cmp_op != - pop_jump_if_false L7 - jump L8 - - L7: - load_var pdf - load_const "document" - call anthropic.internal._anthropic_media_block - store_var _39 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var2 3 17 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_type string - load_var role - call baml.String.from - store_var _36 - load_const "Anthropic only supports PDF input in user messages, found " - load_var _36 - bin_op + - call anthropic.internal._reject - throw - - L9: - load_const "Anthropic does not support audio prompt input: the Messages API has no audio content block" - call anthropic.internal._reject - throw - - L10: - load_var _18 - store_var image - load_var role - load_const "user" - cmp_op != - pop_jump_if_false L11 - jump L12 - - L11: - load_var image - load_const "image" - call anthropic.internal._anthropic_media_block - store_var _26 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var2 3 12 - call baml.Array.push - pop 1 - jump L0 - - L12: - load_type string - load_var role - call baml.String.from - store_var _23 - load_const "Anthropic only supports image input in user messages, found " - load_var _23 - bin_op + - call anthropic.internal._reject - throw - - L13: - load_var _10 - store_var text - load_var text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var blocks - load_const "text" - load_var text - load_const null - init_instance anthropic.internal.AnthTextBlock .type, .text, .cache_control - call baml.Array.push - pop 1 - jump L0 - - L14: - load_var blocks - return -} - -function anthropic.internal._anthropic_push_tool_result(msgs: anthropic.internal.AnthropicMessage[], id: string, content: string, is_error: bool) -> void { - load_const "tool_result" - load_var2 2 3 - load_var is_error - load_const null - init_instance anthropic.internal.AnthToolResultBlock .type, .tool_use_id, .content, .is_error, .cache_control - store_var block - load_var msgs - container_len - store_var _8 - load_type anthropic.internal.AnthropicMessage - load_var2 1 6 - load_const 1 - sub_int - call baml.Array.at - store_var _10 - load_var _10 - narrow_bind anthropic.internal.AnthropicMessage, slot=7 - pop_jump_if_false L0 - jump L1 - - L0: - load_type anthropic.internal.AnthropicMessage - load_var msgs - load_const "user" - load_const true - load_var block - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 1 - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - call baml.Array.push - pop 1 - load_const null - jump L4 - - L1: - load_var _10 - store_var_load_var m - load_field .tool_results - pop_jump_if_false L2 - jump L3 - - L2: - load_type anthropic.internal.AnthropicMessage - load_var msgs - load_const "user" - load_const true - load_var block - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 1 - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - call baml.Array.push - pop 1 - load_const null - jump L4 - - L3: - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var m - load_field .blocks - load_var block - call baml.Array.push - pop 1 - load_const null - - L4: - return -} - -function anthropic.internal._anthropic_query_suffix(query_params: map | null) -> string { - load_var query_params - load_const null - cmp_op == - pop_jump_if_false L0 - jump L7 - - L0: - load_type string - alloc_array 0 - store_var pairs - load_type string - load_type string - load_var query_params - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L1: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L4 - - L2: - load_var _9 - store_var key - load_type string - load_var key - call baml.String.from - store_var _16 - load_type string - load_type string - load_var2 1 5 - call baml.Map.get - store_var_load_var _21 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _21 - - L3: - load_type string - load_var _21 - call baml.String.from - store_var _19 - load_type string - load_var2 2 6 - load_const "=" - bin_op + - load_var _19 - bin_op + - call baml.Array.push - pop 1 - jump L1 - - L4: - load_var pairs - container_len - store_var _30 - load_var _30 - load_const 0 - cmp_int_op > - pop_jump_if_false L5 - jump L6 - - L5: - load_const "" - jump L8 - - L6: - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _32 - load_type string - load_var _32 - call baml.String.from - store_var _31 - load_const "?" - load_var _31 - bin_op + - jump L8 - - L7: - load_const "" - - L8: - return -} - -function anthropic.internal._anthropic_render_messages(msgs: anthropic.internal.AnthropicMessage[]) -> anthropic.internal.AnthMessageParam[] { - load_type anthropic.internal.AnthMessageParam - alloc_array 0 - store_var out - load_var msgs - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _4 - store_var m - load_var out - container_len - store_var _10 - load_type anthropic.internal.AnthMessageParam - load_var2 2 6 - load_const 1 - sub_int - call baml.Array.at - store_var _12 - load_var _12 - narrow_bind anthropic.internal.AnthMessageParam, slot=7 - pop_jump_if_false L2 - load_var _12 - store_var_load_var last - load_field .role - load_var m - load_field .role - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_var m - load_field .role - store_var _29 - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var m - load_field .blocks - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 0 - call baml.Array.concat - store_var _30 - load_type anthropic.internal.AnthMessageParam - load_var2 2 11 - load_var _30 - init_instance anthropic.internal.AnthMessageParam .role, .content - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var m - load_field .blocks - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - - L4: - load_var _18 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - load_var _19 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L0 - - L5: - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - load_var last - load_field .content - load_var _19 - call baml.Array.push - pop 1 - jump L4 - - L6: - load_var out - return -} - -function anthropic.internal._anthropic_request(c: anthropic.AnthropicClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - load_var c - call anthropic.AnthropicClient.resolved_base_url - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "https://api.anthropic.com" - store_var _5 - - L0: - load_type string - load_var _5 - call baml.String.from - store_var _10 - load_var c - load_field .query_params - call anthropic.internal._anthropic_query_suffix - store_var _14 - load_type string - load_var _14 - call baml.String.from - store_var _13 - load_var c - call anthropic.internal._anthropic_headers - store_var _17 - load_var c - call anthropic.internal._anthropic_body_params - load_var2 2 3 - call anthropic.internal.anthropic_messages_body - store_var _18 - load_const "POST" - load_var _10 - load_const "/v1/messages" - bin_op + - load_var _13 - bin_op + - load_var2 8 9 - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function anthropic.internal._anthropic_sse_failure(message: string) -> ai.errors.Failure { - load_var message - load_const "SSE request failed with status " - call baml.String.starts_with - pop_jump_if_false L1 - load_const "SSE request failed with status " - call baml.String.length - store_var _6 - load_var message - call baml.String.length - store_var _7 - load_var2 1 3 - load_var _7 - call baml.String.slice - store_var rest - load_var rest - load_const ":" - call baml.String.index_of - store_var _9 - load_var _9 - narrow_bind int, slot=5 - pop_jump_if_false L1 - load_var _9 - store_var separator - load_var rest - load_const 0 - load_var separator - call baml.String.slice - call baml.Int.parse - store_var status - jump L0 - load_var e - throw_if_panic - load_const 0 - store_var status - - L0: - load_var status - load_const 0 - cmp_int_op > - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var message - call baml.String.from - store_var _24 - load_const "anthropic" - load_const "transport failed before a response arrived: " - load_var _24 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L3 - - L2: - load_var status - store_var _17 - load_var separator - load_const 1 - add_int - store_var _20 - load_var rest - call baml.String.length - store_var _22 - load_var2 2 11 - load_var _22 - call baml.String.slice - call baml.String.trim - store_var _18 - load_const "anthropic" - load_var2 9 10 - load_const - call ai.errors.classify_http - - L3: - return -} - -function anthropic.internal._anthropic_stop_reason(s: string) -> ai.content.StopReason { - load_var s - load_const "end_turn" - cmp_op == - pop_jump_if_false L0 - jump L7 - - L0: - load_var s - load_const "stop_sequence" - cmp_op == - pop_jump_if_false L1 - jump L6 - - L1: - load_var s - load_const "tool_use" - cmp_op == - pop_jump_if_false L2 - jump L5 - - L2: - load_var s - load_const "refusal" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L8 - - L4: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L8 - - L5: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - jump L8 - - L6: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - jump L8 - - L7: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - - L8: - return -} - -function anthropic.internal._anthropic_thinking_param(thinking: anthropic.ThinkingConfig | null) -> anthropic.internal.AnthThinkingParam | null { - load_var thinking - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var thinking - load_field .type - load_var thinking - load_field .budget_tokens - init_instance anthropic.internal.AnthThinkingParam .type, .budget_tokens - jump L2 - - L1: - load_const null - - L2: - return -} - -function anthropic.internal._anthropic_tool_choice_param(choice: anthropic.ToolChoice | null) -> anthropic.internal.AnthToolChoiceParam { - load_var choice - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var choice - load_field .type - load_var choice - load_field .name - load_var choice - load_field .disable_parallel_tool_use - init_instance anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use - jump L2 - - L1: - load_const "auto" - load_const null - load_const null - init_instance anthropic.internal.AnthToolChoiceParam .type, .name, .disable_parallel_tool_use - - L2: - return -} - -function anthropic.internal._anthropic_tool_params(toolbox: ai.tools.Toolbox) -> anthropic.internal.AnthToolParam[] { - load_type anthropic.internal.AnthToolParam - alloc_array 0 - store_var out - load_var toolbox - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var t - load_var t - load_field .name - store_var _11 - load_var t - load_field .description - store_var _12 - load_type map - load_var t - load_field .input_schema - call baml.json.to_json - store_var _13 - load_type anthropic.internal.AnthToolParam - load_var2 2 6 - load_var2 7 8 - load_const null - init_instance anthropic.internal.AnthToolParam .name, .description, .input_schema, .cache_control - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var out - return -} - -function anthropic.internal._reject(detail: string) -> ai.errors.InvalidRequest { - load_const "anthropic" - load_const null - load_var detail - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function anthropic.internal.anthropic_decode_batch(batch: string, state: anthropic.internal.AnthStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - store_var out - load_var batch - call ai.stream.decode_sse_batch - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L70 - - L1: - load_var _6 - store_var_load_var raw - load_field .data - store_var _11 - load_var _11 - narrow_bind string, slot=7 - pop_jump_if_false L0 - load_var _11 - store_var data - load_type anthropic.internal.AnthStreamEvent - load_var data - call baml.json.from_string - jump L2 - load_var e - throw_if_panic - load_const null - - L2: - store_var _17 - load_var _17 - narrow_bind anthropic.internal.AnthStreamEvent, slot=10 - pop_jump_if_false L0 - load_var _17 - store_var_load_var event - load_field .type - store_var_load_var _22 - load_const null - cmp_op == - pop_jump_if_false L3 - load_var raw - load_field .event - store_var _22 - - L3: - load_var _22 - store_var_load_var _20 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const "" - store_var _20 - - L4: - load_var _20 - store_var_load_var t - load_const "error" - cmp_op == - pop_jump_if_false L5 - jump L69 - - L5: - load_var t - load_const "message_start" - cmp_op == - pop_jump_if_false L6 - jump L51 - - L6: - load_var t - load_const "content_block_start" - cmp_op == - pop_jump_if_false L7 - jump L41 - - L7: - load_var t - load_const "content_block_delta" - cmp_op == - pop_jump_if_false L8 - jump L30 - - L8: - load_var t - load_const "message_delta" - cmp_op == - pop_jump_if_false L9 - jump L10 - - L9: - load_var t - load_const "message_stop" - cmp_op == - pop_jump_if_false L0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - alloc_instance ai.stream.TurnDone - call baml.Array.push - pop 1 - jump L0 - - L10: - load_var event - load_field .usage - store_var _169 - load_var _169 - narrow_bind anthropic.internal.AnthStreamUsage, slot=55 - pop_jump_if_false L17 - load_var _169 - store_var_load_var usage - load_field .cache_read_input_tokens - store_var_load_var _171 - load_const null - cmp_op == - pop_jump_if_false L11 - load_var state - load_field .cache_read_input_tokens - store_var _171 - - L11: - load_var2 2 57 - store_field .cache_read_input_tokens - load_var usage - load_field .cache_creation_input_tokens - store_var_load_var _174 - load_const null - cmp_op == - pop_jump_if_false L12 - load_var state - load_field .cache_creation_input_tokens - store_var _174 - - L12: - load_var2 2 58 - store_field .cache_creation_input_tokens - load_var usage - load_field .output_tokens_details - load_const null - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_var usage - load_field .output_tokens_details - load_field .0 - jump L15 - - L14: - load_const null - - L15: - store_var_load_var _177 - load_const null - cmp_op == - pop_jump_if_false L16 - load_var state - load_field .reasoning_tokens - store_var _177 - - L16: - load_var2 2 59 - store_field .reasoning_tokens - - L17: - load_var event - load_field .delta - load_const null - cmp_op == - pop_jump_if_false L18 - jump L19 - - L18: - load_var event - load_field .delta - load_field .5 - store_var _184 - jump L20 - - L19: - load_const null - store_var _184 - - L20: - load_var _184 - load_const null - cmp_op == - pop_jump_if_false L21 - jump L22 - - L21: - load_var _184 - store_var s - load_var2 2 62 - store_field .stop_reason_raw - load_var s - call anthropic.internal._anthropic_stop_reason - store_var stop - jump L23 - - L22: - load_const null - store_var stop - - L23: - load_var stop - store_var _193 - load_var event - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L24 - jump L25 - - L24: - load_var event - load_field .usage - load_field .0 - store_var _194 - jump L26 - - L25: - load_const null - store_var _194 - - L26: - load_var event - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L27 - jump L28 - - L27: - load_var event - load_field .usage - load_field .1 - store_var _198 - jump L29 - - L28: - load_const null - store_var _198 - - L29: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 63 - load_var2 64 65 - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - jump L0 - - L30: - load_var event - load_field .delta - store_var _119 - load_var _119 - narrow_bind anthropic.internal.AnthStreamDelta, slot=39 - pop_jump_if_false L0 - load_var _119 - store_var_load_var d - load_field .type - store_var_load_var _122 - load_const null - cmp_op == - pop_jump_if_false L31 - load_const "" - store_var _122 - - L31: - load_var _122 - store_var_load_var kind - load_const "text_delta" - cmp_op == - pop_jump_if_false L32 - jump L40 - - L32: - load_var kind - load_const "input_json_delta" - cmp_op == - pop_jump_if_false L33 - jump L38 - - L33: - load_var kind - load_const "thinking_delta" - cmp_op == - pop_jump_if_false L34 - jump L36 - - L34: - load_var kind - load_const "signature_delta" - cmp_op == - pop_jump_if_false L0 - load_type string - load_var state - load_field .signature - call baml.String.from - store_var _158 - load_var d - load_field .signature - store_var_load_var _163 - load_const null - cmp_op == - pop_jump_if_false L35 - load_const "" - store_var _163 - - L35: - load_type string - load_var _163 - call baml.String.from - store_var _161 - load_var2 2 52 - load_var _161 - bin_op + - store_field .signature - jump L0 - - L36: - load_type string - load_var state - load_field .thinking - call baml.String.from - store_var _148 - load_var d - load_field .thinking - store_var_load_var _153 - load_const null - cmp_op == - pop_jump_if_false L37 - load_const "" - store_var _153 - - L37: - load_type string - load_var _153 - call baml.String.from - store_var _151 - load_var2 2 49 - load_var _151 - bin_op + - store_field .thinking - jump L0 - - L38: - load_var2 2 11 - load_field .index - call anthropic.internal._anth_stream_call_at - store_var _136 - load_var _136 - narrow_bind anthropic.internal.AnthStreamToolCall, slot=44 - pop_jump_if_false L0 - load_var _136 - store_var call - load_type string - load_var call - load_field .args_json - call baml.String.from - store_var _138 - load_var d - load_field .partial_json - store_var_load_var _143 - load_const null - cmp_op == - pop_jump_if_false L39 - load_const "" - store_var _143 - - L39: - load_type string - load_var _143 - call baml.String.from - store_var _141 - load_var2 45 46 - load_var _141 - bin_op + - store_field .args_json - jump L0 - - L40: - load_var d - load_field .text - store_var _127 - load_var _127 - narrow_bind string, slot=43 - pop_jump_if_false L0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 43 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - jump L0 - - L41: - load_var event - load_field .content_block - store_var _74 - load_var _74 - narrow_bind anthropic.internal.AnthStreamContentBlock, slot=24 - pop_jump_if_false L0 - load_var _74 - store_var_load_var block - load_field .type - store_var_load_var _77 - load_const null - cmp_op == - pop_jump_if_false L42 - load_const "" - store_var _77 - - L42: - load_var _77 - store_var_load_var kind - load_const "tool_use" - cmp_op == - pop_jump_if_false L43 - jump L47 - - L43: - load_var kind - load_const "thinking" - cmp_op == - pop_jump_if_false L44 - jump L45 - - L44: - load_var block - load_field .text - store_var _109 - load_var _109 - narrow_bind string, slot=37 - pop_jump_if_false L0 - load_var _109 - store_var_load_var text - load_const "" - cmp_op != - pop_jump_if_false L0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 38 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - jump L0 - - L45: - load_type string - load_var state - load_field .thinking - call baml.String.from - store_var _99 - load_var block - load_field .thinking - store_var_load_var _104 - load_const null - cmp_op == - pop_jump_if_false L46 - load_const "" - store_var _104 - - L46: - load_type string - load_var _104 - call baml.String.from - store_var _102 - load_var2 2 34 - load_var _102 - bin_op + - store_field .thinking - jump L0 - - L47: - load_var state - load_field .tool_calls - store_var _82 - load_var event - load_field .index - store_var_load_var _85 - load_const null - cmp_op == - pop_jump_if_false L48 - load_var state - load_field .tool_calls - container_len - store_var _85 - - L48: - load_var _85 - store_var _84 - load_var block - load_field .id - store_var_load_var _90 - load_const null - cmp_op == - pop_jump_if_false L49 - load_const "" - store_var _90 - - L49: - load_var _90 - store_var _89 - load_var block - load_field .name - store_var_load_var _94 - load_const null - cmp_op == - pop_jump_if_false L50 - load_const "" - store_var _94 - - L50: - load_type anthropic.internal.AnthStreamToolCall - load_var2 28 29 - load_var2 31 33 - load_const "" - init_instance anthropic.internal.AnthStreamToolCall .index, .id, .name, .args_json - call baml.Array.push - pop 1 - jump L0 - - L51: - load_var event - load_field .message - store_var _32 - load_var _32 - narrow_bind anthropic.internal.AnthStreamMessage, slot=15 - pop_jump_if_false L58 - load_var _32 - store_var message - load_var2 2 16 - load_field .model - store_field .model - load_var message - load_field .usage - store_var _35 - load_var _35 - narrow_bind anthropic.internal.AnthStreamUsage, slot=17 - pop_jump_if_false L58 - load_var _35 - store_var_load_var usage - load_field .cache_read_input_tokens - store_var_load_var _37 - load_const null - cmp_op == - pop_jump_if_false L52 - load_var state - load_field .cache_read_input_tokens - store_var _37 - - L52: - load_var2 2 19 - store_field .cache_read_input_tokens - load_var usage - load_field .cache_creation_input_tokens - store_var_load_var _40 - load_const null - cmp_op == - pop_jump_if_false L53 - load_var state - load_field .cache_creation_input_tokens - store_var _40 - - L53: - load_var2 2 20 - store_field .cache_creation_input_tokens - load_var usage - load_field .output_tokens_details - load_const null - cmp_op == - pop_jump_if_false L54 - jump L55 - - L54: - load_var usage - load_field .output_tokens_details - load_field .0 - jump L56 - - L55: - load_const null - - L56: - store_var_load_var _43 - load_const null - cmp_op == - pop_jump_if_false L57 - load_var state - load_field .reasoning_tokens - store_var _43 - - L57: - load_var2 2 21 - store_field .reasoning_tokens - - L58: - load_var event - load_field .message - load_const null - cmp_op == - pop_jump_if_false L59 - jump L62 - - L59: - load_var event - load_field .message - load_field .3 - load_const null - cmp_op == - pop_jump_if_false L60 - jump L62 - - L60: - load_var event - load_field .message - load_const null - cmp_op == - pop_jump_if_false L61 - jump L62 - - L61: - load_var event - load_field .message - load_field .3 - load_field .0 - store_var _51 - jump L63 - - L62: - load_const null - store_var _51 - - L63: - load_var event - load_field .message - load_const null - cmp_op == - pop_jump_if_false L64 - jump L67 - - L64: - load_var event - load_field .message - load_field .3 - load_const null - cmp_op == - pop_jump_if_false L65 - jump L67 - - L65: - load_var event - load_field .message - load_const null - cmp_op == - pop_jump_if_false L66 - jump L67 - - L66: - load_var event - load_field .message - load_field .3 - load_field .1 - store_var _61 - jump L68 - - L67: - load_const null - store_var _61 - - L68: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - load_const null - load_var2 22 23 - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - jump L0 - - L69: - load_var event - load_field .error - load_var data - call anthropic.internal._anth_stream_failure - throw - - L70: - load_var out - return -} - -function anthropic.internal.anthropic_messages_body(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> string { - load_var2 1 2 - load_var stream - call anthropic.internal.anthropic_messages_request - store_var request - load_type anthropic.internal.AnthropicMessagesRequest - load_var request - call baml.json.to_json - call anthropic.internal._anth_drop_nulls - load_var params - load_field .request_body - call ai.wire.merge_request_body - call baml.json.stringify - return -} - -function anthropic.internal.anthropic_messages_request(params: anthropic.internal.AnthropicBodyParams, input: ai.ModelTurnInput, stream: bool) -> anthropic.internal.AnthropicMessagesRequest { - load_var input - load_field .prompt - store_var _5 - load_var input - load_field .output_type - call ai.wire.render_output_format - load_var _5 - call_indirect - call anthropic.internal._anthropic_lower_prompt - store_var lowered_prompt - load_var lowered_prompt - load_field .system - store_var system - load_var lowered_prompt - load_field .messages - store_var lowered - load_var input - load_field .journal - load_var params - load_field .client_id - call ai.wire.sanitize_for_client - call anthropic.internal._anthropic_lower_journal - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _16 - - L0: - load_var _16 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - load_var _17 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type anthropic.internal.AnthropicMessage - load_var2 7 9 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_type anthropic.internal.AnthropicMessage - load_var lowered - load_const 0 - call baml.Array.at - load_const null - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_type anthropic.internal.AnthropicMessage - load_var lowered - load_const 0 - call baml.Array.at - load_field .0 - jump L5 - - L4: - load_const null - - L5: - store_var_load_var _25 - load_const null - cmp_op == - pop_jump_if_false L6 - load_const "" - store_var _25 - - L6: - load_var _25 - store_var_load_var first_role - load_const "user" - cmp_op != - jump_if_false L7 - pop 1 - jump L8 - - L7: - store_var promote_system - jump L9 - - L8: - load_var system - container_len - store_var _36 - load_var _36 - load_const 0 - cmp_int_op > - store_var promote_system - - L9: - load_var lowered - container_len - store_var _40 - load_var _40 - load_const 0 - cmp_int_op > - jump_if_false L10 - pop 1 - load_var first_role - load_const "user" - cmp_op != - - L10: - jump_if_false L11 - pop 1 - load_var system - container_len - store_var _42 - load_var _42 - load_const 0 - cmp_int_op == - - L11: - load_var promote_system - pop_jump_if_false L12 - jump L15 - - L12: - pop_jump_if_false L13 - jump L14 - - L13: - load_var lowered - jump L16 - - L14: - load_type anthropic.internal.AnthropicMessage - load_const "user" - load_const false - load_const "text" - load_const "(continue)" - load_const null - init_instance anthropic.internal.AnthTextBlock .type, .text, .cache_control - load_type anthropic.internal.AnthTextBlock | anthropic.internal.AnthMediaBlock | anthropic.internal.AnthToolUseBlock | anthropic.internal.AnthToolResultBlock - alloc_array 1 - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - load_type anthropic.internal.AnthropicMessage - alloc_array 1 - load_var lowered - call baml.Array.concat - jump L16 - - L15: - load_type anthropic.internal.AnthropicMessage - load_const "user" - load_const false - load_var system - init_instance anthropic.internal.AnthropicMessage .role, .tool_results, .blocks - load_type anthropic.internal.AnthropicMessage - alloc_array 1 - load_var lowered - call baml.Array.concat - - L16: - call anthropic.internal._anthropic_render_messages - store_var messages - load_var messages - container_len - store_var _60 - load_var _60 - load_const 0 - cmp_int_op == - pop_jump_if_false L17 - jump L32 - - L17: - load_var promote_system - jump_if_false L18 - jump L19 - - L18: - pop 1 - load_var system - container_len - store_var _65 - load_var _65 - load_const 0 - cmp_int_op == - - L19: - pop_jump_if_false L20 - jump L21 - - L20: - load_var system - store_var system_param - jump L22 - - L21: - load_const null - store_var system_param - - L22: - load_var input - load_field .toolbox - call ai.tools.Toolbox.is_empty - unary_op ! - store_var_load_var has_tools - pop_jump_if_false L23 - jump L24 - - L23: - load_const null - store_var tool_params - jump L25 - - L24: - load_var input - load_field .toolbox - call anthropic.internal._anthropic_tool_params - store_var tool_params - - L25: - load_var has_tools - pop_jump_if_false L26 - jump L27 - - L26: - load_const null - store_var choice - jump L28 - - L27: - load_var params - load_field .tool_choice - call anthropic.internal._anthropic_tool_choice_param - store_var choice - - L28: - load_var stream - pop_jump_if_false L29 - jump L30 - - L29: - load_const null - store_var stream_flag - jump L31 - - L30: - load_const true - store_var stream_flag - - L31: - load_var params - load_field .model - store_var _76 - load_var params - load_field .max_tokens - store_var _77 - load_var system_param - store_var _78 - load_var tool_params - store_var _80 - load_var choice - store_var _81 - load_var params - load_field .temperature - store_var _82 - load_var params - load_field .top_p - store_var _83 - load_var params - load_field .top_k - store_var _84 - load_var params - load_field .stop_sequences - store_var _85 - load_var params - load_field .thinking - call anthropic.internal._anthropic_thinking_param - store_var _86 - load_var2 24 25 - load_var2 26 16 - load_var2 27 28 - load_var2 29 30 - load_var2 31 32 - load_var2 33 23 - init_instance anthropic.internal.AnthropicMessagesRequest .model, .max_tokens, .system, .messages, .tools, .tool_choice, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .stream - return - - L32: - load_const "anthropic" - load_const null - load_const "the rendered prompt and journal produced no message content" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function anthropic.internal.anthropic_parse(resp: anthropic.internal.AnthropicResponse) -> ai.ModelTurn { - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_var resp - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L11 - - L1: - load_var _5 - store_var b - load_var b - load_field .type - store_var_load_var _9 - load_const "text" - cmp_op == - pop_jump_if_false L2 - jump L9 - - L2: - load_var _9 - load_const "thinking" - cmp_op == - pop_jump_if_false L3 - jump L7 - - L3: - load_var _9 - load_const "tool_use" - cmp_op == - pop_jump_if_false L0 - load_var b - load_field .id - store_var_load_var _31 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const "" - store_var _31 - - L4: - load_var _31 - store_var _30 - load_var b - load_field .name - store_var_load_var _35 - load_const null - cmp_op == - pop_jump_if_false L5 - load_const "" - store_var _35 - - L5: - load_var _35 - store_var _34 - load_var b - load_field .input - store_var_load_var _39 - load_const null - cmp_op == - pop_jump_if_false L6 - load_type string - load_type unknown - alloc_map 0 - store_var _39 - - L6: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 2 9 - load_var2 11 13 - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var b - load_field .thinking - store_var_load_var _22 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const "" - store_var _22 - - L8: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 2 8 - init_instance ai.content.Reasoning .summary - call baml.Array.push - pop 1 - jump L0 - - L9: - load_var b - load_field .text - store_var_load_var _14 - load_const null - cmp_op == - pop_jump_if_false L10 - load_const "" - store_var _14 - - L10: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 2 7 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L0 - - L11: - load_var resp - load_field .stop_reason - store_var_load_var _44 - load_const null - cmp_op == - pop_jump_if_false L12 - jump L13 - - L12: - load_var _44 - call anthropic.internal._anthropic_stop_reason - store_var stop - jump L14 - - L13: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - - L14: - load_var resp - load_field .usage - store_var _50 - load_var _50 - narrow_bind anthropic.internal.AnthropicUsage, slot=17 - pop_jump_if_false L15 - jump L16 - - L15: - load_const null - store_var usage - jump L22 - - L16: - load_var _50 - store_var_load_var u - load_field .input_tokens - store_var_load_var _53 - load_const null - cmp_op == - pop_jump_if_false L17 - load_const 0 - store_var _53 - - L17: - load_var _53 - store_var _52 - load_var u - load_field .output_tokens - store_var_load_var _57 - load_const null - cmp_op == - pop_jump_if_false L18 - load_const 0 - store_var _57 - - L18: - load_var _57 - store_var _56 - load_var u - load_field .cache_read_input_tokens - store_var _60 - load_var u - load_field .output_tokens_details - load_const null - cmp_op == - pop_jump_if_false L19 - jump L20 - - L19: - load_var u - load_field .output_tokens_details - load_field .0 - store_var _61 - jump L21 - - L20: - load_const null - store_var _61 - - L21: - load_var2 19 21 - load_var2 23 24 - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L22: - load_var2 2 14 - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return -} - -function anthropic.internal.anthropic_render(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var2 1 2 - load_const false - call anthropic.internal._anthropic_request - return -} - -function anthropic.internal.invoke(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - load_const false - call anthropic.internal._anthropic_request - store_var req - load_type anthropic.internal.AnthropicResponse - load_var req - load_const "anthropic" - call ai.wire.send_as - call anthropic.internal.anthropic_parse - return -} - -function anthropic.internal.invoke_stream(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var ?7 - make_cell - store_var ?7 - load_var2 1 2 - load_const true - call anthropic.internal._anthropic_request - sys_op baml.http.fetch_sse - store_var sse - jump L4 - load_var e - is_type baml.errors.Io - pop_jump_if_false L0 - jump L3 - - L0: - load_var e - is_type baml.errors.Timeout - pop_jump_if_false L1 - jump L2 - - L1: - load_var e - rethrow - - L2: - load_type baml.errors.Timeout - load_var e - call baml.String.from - store_var _14 - load_type string - load_var _14 - call baml.String.from - store_var _13 - load_const "anthropic" - load_const "the streaming request timed out: " - load_var _13 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L3: - load_var e - load_field .message - call anthropic.internal._anthropic_sse_failure - throw - - L4: - call anthropic.internal.AnthStreamState.new - store_deref ?7 - load_var2 3 7 - make_closure ., 1 - load_const "anthropic" - call ai.stream.TurnStream.from_sse - return -} - -function assert.approx_equal(actual: float, expected: float, eps: float) -> void { - load_var eps - load_const 0.0 - cmp_float_op < - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var eps - call baml.Float.is_nan - - L1: - pop_jump_if_false L2 - load_const "assertion failed: epsilon must be a non-negative number" - call baml.sys.panic - pop 1 - - L2: - load_var2 1 2 - sub_float - call baml.Float.abs - store_var delta - load_var delta - call baml.Float.is_nan - jump_if_false L3 - jump L4 - - L3: - pop 1 - load_var2 4 3 - cmp_float_op > - - L4: - pop_jump_if_false L5 - jump L6 - - L5: - load_const null - jump L7 - - L6: - load_type float - load_var delta - call baml.String.from - store_var _20 - load_type float - load_var eps - call baml.String.from - store_var _23 - load_type float - load_var actual - call baml.String.from - store_var _25 - load_type float - load_var expected - call baml.String.from - store_var _27 - load_const "assertion failed: |left - right| = \"" - load_var _20 - bin_op + - load_const "\", eps = \"" - bin_op + - load_var _23 - bin_op + - load_const "\", left = \"" - bin_op + - load_var _25 - bin_op + - load_const "\", right = \"" - bin_op + - load_var _27 - bin_op + - load_const "\"" - bin_op + - call baml.sys.panic - - L7: - return -} - -function assert.contains(haystack: string, needle: string) -> void { - load_var2 1 2 - call baml.String.includes - unary_op ! - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_const "assertion failed: string does not contain expected substring" - call baml.sys.panic - - L2: - return -} - -function assert.equal(actual: unknown, expected: unknown) -> void { - load_var2 1 2 - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_var actual - call assert.format_operand - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_var expected - call assert.format_operand - store_var _12 - load_type string - load_var _12 - call baml.String.from - store_var _11 - load_const "assertion failed: left = " - load_var _8 - bin_op + - load_const ", right = " - bin_op + - load_var _11 - bin_op + - call baml.sys.panic - - L2: - return -} - -function assert.format_operand(value: unknown) -> string { - load_var value - store_var _2 - load_var _2 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_type unknown - load_var value - call baml.String.from - jump L2 - - L1: - load_type string - load_var _2 - call baml.String.from - store_var _5 - load_const "\"" - load_var _5 - bin_op + - load_const "\"" - bin_op + - - L2: - return -} - -function assert.is_true(condition: bool) -> void { - load_var condition - unary_op ! - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_const "assertion failed: expected true" - call baml.sys.panic - - L2: - return -} - -function assert.is_type(actual: unknown) -> #0 { - load_var actual - is_type #0 - pop_jump_if_false L0 - jump L1 - - L0: - load_type type - load_type #0 - call baml.String.from - store_var _8 - load_type unknown - load_var actual - call baml.String.from - store_var _11 - load_const "assertion failed: expected type \"" - load_var _8 - bin_op + - load_const "\", got \"" - bin_op + - load_var _11 - bin_op + - load_const "\"" - bin_op + - call baml.sys.panic - jump L2 - - L1: - load_var actual - - L2: - return -} - -function assert.not_null(value: unknown | null) -> void { - load_var value - load_const null - call baml.ops.equals_equals - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_const "assertion failed: expected non-null value" - call baml.sys.panic - - L2: - return -} - -function aws.BedrockClient.ai.Client.id(self: aws.BedrockClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "bedrock/" - load_var _2 - bin_op + - return -} - -function aws.BedrockClient.ai.Client.invoke(self: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call aws.internal.invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function aws.BedrockClient.new(model: string, region: string | null, profile: string | null, access_key_id: string | null, secret_access_key: string | null, session_token: string | null, endpoint_url: string | baml.env.Ref | null, max_tokens: int | null, temperature: float | null, top_p: float | null, stop_sequences: string[] | null, tool_choice: string | null, cache_system_prompt: bool, cache_tools: bool, additional_model_request_fields: baml.json.json | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> aws.BedrockClient { - load_var region - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var region - - L0: - load_var profile - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var profile - - L1: - load_var access_key_id - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var access_key_id - - L2: - load_var secret_access_key - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var secret_access_key - - L3: - load_var session_token - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var session_token - - L4: - load_var endpoint_url - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var endpoint_url - - L5: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var max_tokens - - L6: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var temperature - - L7: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var top_p - - L8: - load_var stop_sequences - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var stop_sequences - - L9: - load_var tool_choice - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var tool_choice - - L10: - load_var cache_system_prompt - load_const - cmp_op == - pop_jump_if_false L11 - load_const false - store_var cache_system_prompt - - L11: - load_var cache_tools - load_const - cmp_op == - pop_jump_if_false L12 - load_const false - store_var cache_tools - - L12: - load_var additional_model_request_fields - load_const - cmp_op == - pop_jump_if_false L13 - load_const null - store_var additional_model_request_fields - - L13: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L14 - load_const null - store_var request_body - - L14: - load_var headers - load_const - cmp_op == - pop_jump_if_false L15 - load_const null - store_var headers - - L15: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L16 - load_const null - store_var query_params - - L16: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var2 13 14 - load_var2 15 16 - load_var2 17 18 - init_instance aws.BedrockClient .model, .region, .profile, .access_key_id, .secret_access_key, .session_token, .endpoint_url, .max_tokens, .temperature, .top_p, .stop_sequences, .tool_choice, .cache_system_prompt, .cache_tools, .additional_model_request_fields, .request_body, .headers, .query_params - return -} - -function aws.BedrockClient.resolved_endpoint_url(self: aws.BedrockClient) -> string | null { - load_var self - load_field .endpoint_url - load_const null - call ai.wire.resolve_credential - return -} - -function aws.internal.ContentBlock.of_audio(audio: aws.internal.AudioBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text, .image, .video, .document - load_var audio - init_field .audio - load_var _2 - init_spread .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal.ContentBlock.of_cache_point() -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _1 - alloc_instance aws.internal.ContentBlock - load_var _1 - init_spread .text, .image, .video, .document, .audio, .toolUse, .toolResult - load_const "default" - init_instance aws.internal.CachePointBlock .type - init_field .cachePoint - return -} - -function aws.internal.ContentBlock.of_document(document: aws.internal.DocumentBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text, .image, .video - load_var document - init_field .document - load_var _2 - init_spread .audio, .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal.ContentBlock.of_image(image: aws.internal.ImageBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text - load_var image - init_field .image - load_var _2 - init_spread .video, .document, .audio, .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal.ContentBlock.of_text(text: string) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var text - init_field .text - load_var _2 - init_spread .image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal.ContentBlock.of_tool_result(tool_result: aws.internal.ToolResultBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text, .image, .video, .document, .audio, .toolUse - load_var tool_result - init_field .toolResult - load_var _2 - init_spread .cachePoint - return -} - -function aws.internal.ContentBlock.of_tool_use(tool_use: aws.internal.ToolUseBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text, .image, .video, .document, .audio - load_var tool_use - init_field .toolUse - load_var _2 - init_spread .toolResult, .cachePoint - return -} - -function aws.internal.ContentBlock.of_video(video: aws.internal.VideoBlock) -> aws.internal.ContentBlock { - call aws.internal._empty_content_block - store_var _2 - alloc_instance aws.internal.ContentBlock - load_var _2 - init_spread .text, .image - load_var video - init_field .video - load_var _2 - init_spread .document, .audio, .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal.SystemContentBlock.of_cache_point() -> aws.internal.SystemContentBlock { - load_const null - load_const "default" - init_instance aws.internal.CachePointBlock .type - init_instance aws.internal.SystemContentBlock .text, .cachePoint - return -} - -function aws.internal.SystemContentBlock.of_text(text: string) -> aws.internal.SystemContentBlock { - load_var text - load_const null - init_instance aws.internal.SystemContentBlock .text, .cachePoint - return -} - -function aws.internal.ToolEntry.of_cache_point() -> aws.internal.ToolEntry { - load_const null - load_const "default" - init_instance aws.internal.CachePointBlock .type - init_instance aws.internal.ToolEntry .toolSpec, .cachePoint - return -} - -function aws.internal.ToolEntry.of_spec(spec: aws.internal.ToolSpec) -> aws.internal.ToolEntry { - load_var spec - load_const null - init_instance aws.internal.ToolEntry .toolSpec, .cachePoint - return -} - -function aws.internal.ToolInputSchema.baml.ToJson.to_json(self: aws.internal.ToolInputSchema) -> baml.json.json { - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var out - load_const "json" - load_var self - load_field .json_schema - call baml.Map.set - pop 1 - load_var out - return -} - -function aws.internal._apply_query(url: string, params: map | null) -> string { - load_var params - load_const null - cmp_op == - pop_jump_if_false L0 - jump L9 - - L0: - load_type string - alloc_array 0 - store_var pairs - load_type string - load_type string - load_var params - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L1: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L4 - - L2: - load_var _10 - store_var_load_var name - call aws.internal.encode_path_label - store_var _18 - load_type string - load_var _18 - call baml.String.from - store_var _17 - load_type string - load_type string - load_var2 2 6 - call baml.Map.get - store_var_load_var _24 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _24 - - L3: - load_var _24 - call aws.internal.encode_path_label - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_type string - load_var2 3 7 - load_const "=" - bin_op + - load_var _21 - bin_op + - call baml.Array.push - pop 1 - jump L1 - - L4: - load_var pairs - container_len - store_var _33 - load_var _33 - load_const 0 - cmp_int_op == - pop_jump_if_false L5 - jump L8 - - L5: - load_var url - load_const "?" - call baml.String.includes - pop_jump_if_false L6 - jump L7 - - L6: - load_type string - load_var url - call baml.String.from - store_var _43 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _46 - load_type string - load_var _46 - call baml.String.from - store_var _45 - load_var _43 - load_const "?" - bin_op + - load_var _45 - bin_op + - jump L10 - - L7: - load_type string - load_var url - call baml.String.from - store_var _36 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _39 - load_type string - load_var _39 - call baml.String.from - store_var _38 - load_var _36 - load_const "&" - bin_op + - load_var _38 - bin_op + - jump L10 - - L8: - load_var url - jump L10 - - L9: - load_var url - - L10: - return -} - -function aws.internal._assistant_content(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[]) -> aws.internal.ContentBlock[] { - load_type aws.internal.ContentBlock - alloc_array 0 - store_var out - load_var content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _4 - store_var block - load_var block - store_var _8 - load_var _8 - narrow_bind ai.content.Text, slot=6 - pop_jump_if_false L2 - jump L5 - - L2: - load_var block - store_var _14 - load_var _14 - narrow_bind ai.content.Reasoning, slot=8 - pop_jump_if_false L3 - jump L0 - - L3: - load_var block - store_var _15 - load_var _15 - narrow_bind ai.content.Media, slot=9 - pop_jump_if_false L4 - jump L0 - - L4: - load_var block - store_var_load_var use - load_field .id - load_var use - load_field .name - load_var use - load_field .args - init_instance aws.internal.ToolUseBlock .toolUseId, .name, .input - call aws.internal.ContentBlock.of_tool_use - store_var _18 - load_type aws.internal.ContentBlock - load_var2 2 11 - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _8 - load_field .text - call aws.internal.ContentBlock.of_text - store_var _11 - load_type aws.internal.ContentBlock - load_var2 2 7 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var out - return -} - -function aws.internal._audio_block(audio: baml.media.Audio) -> aws.internal.ContentBlock { - load_var audio - call baml.media.Audio.url - call aws.internal._is_s3_url - store_var _4 - load_var2 1 3 - unary_op ! - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .mime_type - call aws.internal._audio_format - load_var resolved - load_const "audio" - call aws.internal._media_source - init_instance aws.internal.AudioBlock .format, .source - call aws.internal.ContentBlock.of_audio - return -} - -function aws.internal._audio_format(mime: string) -> string { - load_var mime - load_const "audio/mpeg" - cmp_op == - pop_jump_if_false L0 - jump L39 - - L0: - load_var mime - load_const "audio/mp3" - cmp_op == - pop_jump_if_false L1 - jump L38 - - L1: - load_var mime - load_const "audio/wav" - cmp_op == - pop_jump_if_false L2 - jump L37 - - L2: - load_var mime - load_const "audio/x-wav" - cmp_op == - pop_jump_if_false L3 - jump L36 - - L3: - load_var mime - load_const "audio/wave" - cmp_op == - pop_jump_if_false L4 - jump L35 - - L4: - load_var mime - load_const "audio/flac" - cmp_op == - pop_jump_if_false L5 - jump L34 - - L5: - load_var mime - load_const "audio/x-flac" - cmp_op == - pop_jump_if_false L6 - jump L33 - - L6: - load_var mime - load_const "audio/ogg" - cmp_op == - pop_jump_if_false L7 - jump L32 - - L7: - load_var mime - load_const "audio/opus" - cmp_op == - pop_jump_if_false L8 - jump L31 - - L8: - load_var mime - load_const "audio/aac" - cmp_op == - pop_jump_if_false L9 - jump L30 - - L9: - load_var mime - load_const "audio/x-aac" - cmp_op == - pop_jump_if_false L10 - jump L29 - - L10: - load_var mime - load_const "audio/mp4" - cmp_op == - pop_jump_if_false L11 - jump L28 - - L11: - load_var mime - load_const "audio/m4a" - cmp_op == - pop_jump_if_false L12 - jump L27 - - L12: - load_var mime - load_const "audio/x-m4a" - cmp_op == - pop_jump_if_false L13 - jump L26 - - L13: - load_var mime - load_const "audio/x-matroska" - cmp_op == - pop_jump_if_false L14 - jump L25 - - L14: - load_var mime - load_const "audio/mpga" - cmp_op == - pop_jump_if_false L15 - jump L24 - - L15: - load_var mime - load_const "audio/pcm" - cmp_op == - pop_jump_if_false L16 - jump L23 - - L16: - load_var mime - load_const "audio/x-pcm" - cmp_op == - pop_jump_if_false L17 - jump L22 - - L17: - load_var mime - load_const "audio/L16" - cmp_op == - pop_jump_if_false L18 - jump L21 - - L18: - load_var mime - load_const "audio/webm" - cmp_op == - pop_jump_if_false L19 - jump L20 - - L19: - load_type string - load_var mime - call baml.String.from - store_var _24 - load_const "unsupported audio format for Bedrock: " - load_var _24 - bin_op + - call aws.internal._reject - throw - - L20: - load_const "webm" - jump L40 - - L21: - load_const "pcm" - jump L40 - - L22: - load_const "pcm" - jump L40 - - L23: - load_const "pcm" - jump L40 - - L24: - load_const "mpga" - jump L40 - - L25: - load_const "mka" - jump L40 - - L26: - load_const "m4a" - jump L40 - - L27: - load_const "m4a" - jump L40 - - L28: - load_const "mp4" - jump L40 - - L29: - load_const "x-aac" - jump L40 - - L30: - load_const "aac" - jump L40 - - L31: - load_const "opus" - jump L40 - - L32: - load_const "ogg" - jump L40 - - L33: - load_const "flac" - jump L40 - - L34: - load_const "flac" - jump L40 - - L35: - load_const "wav" - jump L40 - - L36: - load_const "wav" - jump L40 - - L37: - load_const "wav" - jump L40 - - L38: - load_const "mp3" - jump L40 - - L39: - load_const "mp3" - - L40: - return -} - -function aws.internal._conversation_role(role: string) -> string { - load_var role - load_const "assistant" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_const "user" - jump L2 - - L1: - load_const "assistant" - - L2: - return -} - -function aws.internal._document_block(pdf: baml.media.Pdf) -> aws.internal.ContentBlock { - load_var pdf - call baml.media.Pdf.url - call aws.internal._is_s3_url - store_var _4 - load_var2 1 3 - unary_op ! - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .mime_type - load_const "application/pdf" - cmp_op != - pop_jump_if_false L0 - jump L1 - - L0: - load_var resolved - load_const "document" - call aws.internal._media_source - store_var _14 - load_const "pdf" - load_const "document" - load_var _14 - init_instance aws.internal.DocumentBlock .format, .name, .source - call aws.internal.ContentBlock.of_document - return - - L1: - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _10 - load_const "unsupported document format for Bedrock: " - load_var _10 - bin_op + - call aws.internal._reject - throw -} - -function aws.internal._empty_content_block() -> aws.internal.ContentBlock { - load_const null - load_const null - load_const null - load_const null - load_const null - load_const null - load_const null - load_const null - init_instance aws.internal.ContentBlock .text, .image, .video, .document, .audio, .toolUse, .toolResult, .cachePoint - return -} - -function aws.internal._image_block(image: baml.media.Image) -> aws.internal.ContentBlock { - load_var image - call baml.media.Image.url - call aws.internal._is_s3_url - store_var _4 - load_var2 1 3 - unary_op ! - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .mime_type - call aws.internal._image_format - load_var resolved - load_const "image" - call aws.internal._media_source - init_instance aws.internal.ImageBlock .format, .source - call aws.internal.ContentBlock.of_image - return -} - -function aws.internal._image_format(mime: string) -> string { - load_var mime - load_const "image/png" - cmp_op == - pop_jump_if_false L0 - jump L9 - - L0: - load_var mime - load_const "image/jpeg" - cmp_op == - pop_jump_if_false L1 - jump L8 - - L1: - load_var mime - load_const "image/jpg" - cmp_op == - pop_jump_if_false L2 - jump L7 - - L2: - load_var mime - load_const "image/gif" - cmp_op == - pop_jump_if_false L3 - jump L6 - - L3: - load_var mime - load_const "image/webp" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_type string - load_var mime - call baml.String.from - store_var _9 - load_const "unsupported image format for Bedrock: " - load_var _9 - bin_op + - call aws.internal._reject - throw - - L5: - load_const "webp" - jump L10 - - L6: - load_const "gif" - jump L10 - - L7: - load_const "jpeg" - jump L10 - - L8: - load_const "jpeg" - jump L10 - - L9: - load_const "png" - - L10: - return -} - -function aws.internal._inference_config(client: aws.BedrockClient) -> aws.internal.InferenceConfig | null { - load_var client - load_field .max_tokens - store_var _3 - load_var _3 - narrow_bind int, slot=2 - pop_jump_if_false L2 - load_var _3 - store_var_load_var limit - load_const 2147483647 - cmp_int_op > - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var limit - load_const 0 - cmp_int_op < - - L1: - pop_jump_if_false L2 - jump L14 - - L2: - load_var client - load_field .stop_sequences - store_var_load_var _16 - load_const null - cmp_op == - pop_jump_if_false L3 - jump L6 - - L3: - load_var _16 - store_var sequences - load_var sequences - container_len - store_var _20 - load_var _20 - load_const 0 - cmp_int_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_var sequences - store_var stops - jump L7 - - L5: - load_const null - store_var stops - jump L7 - - L6: - load_const null - store_var stops - - L7: - load_var client - load_field .max_tokens - load_const null - call baml.ops.equals_equals - jump_if_false L8 - pop 1 - load_var client - load_field .temperature - load_const null - call baml.ops.equals_equals - - L8: - jump_if_false L9 - pop 1 - load_var client - load_field .top_p - load_const null - call baml.ops.equals_equals - - L9: - jump_if_false L10 - pop 1 - load_var stops - load_const null - call baml.ops.equals_equals - - L10: - pop_jump_if_false L11 - jump L12 - - L11: - load_var client - load_field .max_tokens - load_var client - load_field .temperature - load_var client - load_field .top_p - load_var stops - init_instance aws.internal.InferenceConfig .maxTokens, .temperature, .topP, .stopSequences - jump L13 - - L12: - load_const null - - L13: - return - - L14: - load_type int - load_var limit - call baml.String.from - store_var _12 - load_const "max_tokens value " - load_var _12 - bin_op + - load_const " is out of the supported range (0..=2147483647)" - bin_op + - call aws.internal._reject - throw -} - -function aws.internal._is_malformed_stop(raw: string) -> bool { - load_var raw - load_const "malformed_model_output" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var raw - load_const "malformed_tool_use" - cmp_op == - - L1: - return -} - -function aws.internal._is_opaque_key(key: string) -> bool { - load_var key - load_const "additionalModelRequestFields" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var key - load_const "json" - cmp_op == - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var key - load_const "input" - cmp_op == - - L3: - return -} - -function aws.internal._is_s3_url(url: string | null) -> bool { - load_var url - store_var_load_var _3 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _3 - - L0: - load_var _3 - load_const "s3://" - call baml.String.starts_with - return -} - -function aws.internal._is_unreserved_byte(byte: int) -> bool { - load_var byte - load_const 48 - cmp_int_op >= - jump_if_false L0 - pop 1 - load_var byte - load_const 57 - cmp_int_op <= - - L0: - jump_if_false L1 - jump L2 - - L1: - pop 1 - load_var byte - load_const 65 - cmp_int_op >= - jump_if_false L2 - pop 1 - load_var byte - load_const 90 - cmp_int_op <= - - L2: - jump_if_false L3 - jump L4 - - L3: - pop 1 - load_var byte - load_const 97 - cmp_int_op >= - jump_if_false L4 - pop 1 - load_var byte - load_const 122 - cmp_int_op <= - - L4: - jump_if_false L5 - jump L6 - - L5: - pop 1 - load_var byte - load_const 45 - cmp_int_op == - - L6: - jump_if_false L7 - jump L8 - - L7: - pop 1 - load_var byte - load_const 46 - cmp_int_op == - - L8: - jump_if_false L9 - jump L10 - - L9: - pop 1 - load_var byte - load_const 95 - cmp_int_op == - - L10: - jump_if_false L11 - jump L12 - - L11: - pop 1 - load_var byte - load_const 126 - cmp_int_op == - - L12: - return -} - -function aws.internal._lower_journal(journal: ai.Journal, with_status: bool) -> aws.internal.Message[] { - load_type aws.internal.PendingMessage - alloc_array 0 - store_var pending - load_var journal - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L8 - - L1: - load_var _6 - store_var event - load_var event - store_var _10 - load_var _10 - narrow_bind ai.events.UserMessage, slot=7 - pop_jump_if_false L2 - jump L7 - - L2: - load_var event - store_var _19 - load_var _19 - narrow_bind ai.events.AssistantMessage, slot=9 - pop_jump_if_false L3 - jump L6 - - L3: - load_var event - store_var _30 - load_var _30 - narrow_bind ai.events.ToolCompleted, slot=12 - pop_jump_if_false L4 - jump L5 - - L4: - load_var event - store_var _36 - load_var _36 - narrow_bind ai.events.ToolFailed, slot=14 - pop_jump_if_false L0 - load_var _36 - store_var failed - load_var2 3 15 - load_field .id - load_var failed - load_field .message - load_const true - load_var with_status - call aws.internal._push_tool_result - pop 1 - jump L0 - - L5: - load_var _30 - store_var completed - load_var2 3 13 - load_field .id - load_var completed - load_field .output - load_const false - load_var with_status - call aws.internal._push_tool_result - pop 1 - jump L0 - - L6: - load_var _19 - load_field .content - call aws.internal._assistant_content - store_var content - load_var content - container_len - store_var _24 - load_var _24 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_type aws.internal.PendingMessage - load_var pending - load_const "assistant" - load_var content - init_instance aws.internal.Message .role, .content - load_const false - init_instance aws.internal.PendingMessage .message, .tool_results - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var _10 - load_field .content - call aws.internal.ContentBlock.of_text - store_var _16 - load_type aws.internal.PendingMessage - load_var pending - load_const "user" - load_var _16 - load_type aws.internal.ContentBlock - alloc_array 1 - init_instance aws.internal.Message .role, .content - load_const false - init_instance aws.internal.PendingMessage .message, .tool_results - call baml.Array.push - pop 1 - jump L0 - - L8: - load_type aws.internal.Message - alloc_array 0 - store_var out - load_var pending - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _44 - - L9: - load_var _44 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _45 - load_var _45 - is_type baml.iter.Done - pop_jump_if_false L10 - jump L11 - - L10: - load_type aws.internal.Message - load_var2 16 18 - load_field .message - call baml.Array.push - pop 1 - jump L9 - - L11: - load_var out - return -} - -function aws.internal._lower_prompt(prompt: ai.Prompt) -> aws.internal.BedrockPrompt { - load_type aws.internal.SystemContentBlock - alloc_array 0 - store_var system - load_type aws.internal.Message - alloc_array 0 - store_var messages - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L8 - - L1: - load_var _6 - store_var_load_var message - load_field .role - load_const "system" - cmp_op == - pop_jump_if_false L2 - jump L4 - - L2: - load_var message - call aws.internal._prompt_content - store_var content - load_var content - container_len - store_var _30 - load_var _30 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_var message - call aws.internal._wants_cache_point - pop_jump_if_false L3 - call aws.internal.ContentBlock.of_cache_point - store_var _34 - load_type aws.internal.ContentBlock - load_var2 10 12 - call baml.Array.push - pop 1 - - L3: - load_var message - load_field .role - call aws.internal._conversation_role - store_var _38 - load_type aws.internal.Message - load_var2 3 13 - load_var content - init_instance aws.internal.Message .role, .content - call baml.Array.push - pop 1 - jump L0 - - L4: - load_var message - call aws.internal._prompt_system - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _14 - - L5: - load_var _14 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _15 - load_var _15 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L7 - - L6: - load_type aws.internal.SystemContentBlock - load_var2 2 8 - call baml.Array.push - pop 1 - jump L5 - - L7: - load_var message - call aws.internal._wants_cache_point - pop_jump_if_false L0 - call aws.internal.SystemContentBlock.of_cache_point - store_var _25 - load_type aws.internal.SystemContentBlock - load_var2 2 9 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var2 2 3 - init_instance aws.internal.BedrockPrompt .system, .messages - return -} - -function aws.internal._media_source(resolved: ai.wire.ResolvedMedia, kind: string) -> aws.internal.MediaSource { - load_var resolved - load_field .base64 - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L5 - - L0: - load_var resolved - load_field .url - store_var _8 - load_var _8 - narrow_bind string, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var kind - call baml.String.from - store_var _25 - load_const "Bedrock " - load_var _25 - bin_op + - load_const " content could not be resolved" - bin_op + - call aws.internal._reject - throw - - L2: - load_var _8 - store_var url - load_var url - load_const "s3://" - call baml.String.starts_with - pop_jump_if_false L3 - jump L4 - - L3: - load_type string - load_var kind - call baml.String.from - store_var _17 - load_type string - load_var url - call baml.String.from - store_var _19 - load_const "Bedrock requires s3:// URIs for " - load_var _17 - bin_op + - load_const " URLs, got: " - bin_op + - load_var _19 - bin_op + - call aws.internal._reject - throw - - L4: - load_const null - load_var url - load_const null - init_instance aws.internal.S3Location .uri, .bucketOwner - init_instance aws.internal.MediaSource .bytes, .s3Location - jump L6 - - L5: - load_var _4 - load_const null - init_instance aws.internal.MediaSource .bytes, .s3Location - - L6: - return -} - -function aws.internal._merge_adjacent_roles(messages: aws.internal.Message[]) -> aws.internal.Message[] { - load_type aws.internal.Message - alloc_array 0 - store_var out - load_var messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _4 - store_var message - load_var out - container_len - store_var _10 - load_type aws.internal.Message - load_var2 2 6 - load_const 1 - sub_int - call baml.Array.at - store_var _12 - load_var _12 - narrow_bind aws.internal.Message, slot=7 - pop_jump_if_false L2 - load_var _12 - store_var_load_var last - load_field .role - load_var message - load_field .role - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_var message - load_field .role - store_var _29 - load_type aws.internal.ContentBlock - load_var message - load_field .content - load_type aws.internal.ContentBlock - alloc_array 0 - call baml.Array.concat - store_var _30 - load_type aws.internal.Message - load_var2 2 11 - load_var _30 - init_instance aws.internal.Message .role, .content - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var message - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - - L4: - load_var _18 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - load_var _19 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L0 - - L5: - load_type aws.internal.ContentBlock - load_var last - load_field .content - load_var _19 - call baml.Array.push - pop 1 - jump L4 - - L6: - load_var out - return -} - -function aws.internal._merge_headers(base: map, extra: map | null) -> map { - load_type string - load_type string - alloc_map 0 - store_var out - load_type string - load_type string - load_var base - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L0: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _8 - store_var name - load_var name - call baml.String.to_lower_case - store_var _13 - load_type string - load_type string - load_var2 1 6 - call baml.Map.get - store_var_load_var _15 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _15 - - L2: - load_type string - load_type string - load_var2 3 7 - load_var _15 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var extra - load_const null - cmp_op == - pop_jump_if_false L4 - jump L8 - - L4: - load_type string - load_type string - load_var extra - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L5: - load_var _28 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L8 - - L6: - load_var _29 - store_var name - load_var name - call baml.String.to_lower_case - store_var _34 - load_type string - load_type string - load_var2 2 11 - call baml.Map.get - store_var_load_var _36 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const "" - store_var _36 - - L7: - load_type string - load_type string - load_var2 3 12 - load_var _36 - call baml.Map.set - pop 1 - jump L5 - - L8: - load_var out - return -} - -function aws.internal._prompt_content(message: ai.PromptMessage) -> aws.internal.ContentBlock[] { - load_type aws.internal.ContentBlock - alloc_array 0 - store_var blocks - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L10 - - L1: - load_var _5 - store_var part - load_var part - store_var _9 - load_var _9 - narrow_bind string, slot=6 - pop_jump_if_false L2 - jump L9 - - L2: - load_var part - store_var _17 - load_var _17 - narrow_bind baml.media.Image, slot=9 - pop_jump_if_false L3 - jump L8 - - L3: - load_var part - store_var _23 - load_var _23 - narrow_bind baml.media.Audio, slot=11 - pop_jump_if_false L4 - jump L7 - - L4: - load_var part - store_var _29 - load_var _29 - narrow_bind baml.media.Video, slot=13 - pop_jump_if_false L5 - jump L6 - - L5: - load_var part - call aws.internal._document_block - store_var _37 - load_type aws.internal.ContentBlock - load_var2 2 15 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var _29 - call aws.internal._video_block - store_var _32 - load_type aws.internal.ContentBlock - load_var2 2 14 - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var _23 - call aws.internal._audio_block - store_var _26 - load_type aws.internal.ContentBlock - load_var2 2 12 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var _17 - call aws.internal._image_block - store_var _20 - load_type aws.internal.ContentBlock - load_var2 2 10 - call baml.Array.push - pop 1 - jump L0 - - L9: - load_var _9 - store_var text - load_var text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_var text - call aws.internal.ContentBlock.of_text - store_var _14 - load_type aws.internal.ContentBlock - load_var2 2 8 - call baml.Array.push - pop 1 - jump L0 - - L10: - load_var blocks - return -} - -function aws.internal._prompt_system(message: ai.PromptMessage) -> aws.internal.SystemContentBlock[] { - load_type aws.internal.SystemContentBlock - alloc_array 0 - store_var blocks - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _5 - store_var _9 - load_var _9 - narrow_bind string, slot=5 - pop_jump_if_false L2 - jump L3 - - L2: - load_const "Bedrock system messages do not support media content" - call aws.internal._reject - throw - - L3: - load_var _9 - store_var text - load_var text - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L0 - load_var text - call aws.internal.SystemContentBlock.of_text - store_var _14 - load_type aws.internal.SystemContentBlock - load_var2 2 7 - call baml.Array.push - pop 1 - jump L0 - - L4: - load_var blocks - return -} - -function aws.internal._prune_nulls(value: baml.json.json) -> baml.json.json { - load_var value - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var value - store_var _31 - load_var _31 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var value - jump L13 - - L2: - load_type baml.json.json - alloc_array 0 - store_var out - load_var _31 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _35 - - L3: - load_var _35 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _36 - load_var _36 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _36 - call aws.internal._prune_nulls - store_var _41 - load_type baml.json.json - load_var2 11 14 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - jump L13 - - L6: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L7: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L12 - - L8: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var member - load_var member - load_const null - cmp_op == - pop_jump_if_false L9 - jump L7 - - L9: - load_var key - call aws.internal._is_opaque_key - pop_jump_if_false L10 - jump L11 - - L10: - load_var member - call aws.internal._prune_nulls - store_var _27 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _27 - call baml.Map.set - pop 1 - jump L7 - - L11: - load_type string - load_type baml.json.json - load_var2 4 7 - load_var member - call baml.Map.set - pop 1 - jump L7 - - L12: - load_var out - - L13: - return -} - -function aws.internal._push_tool_result(pending: aws.internal.PendingMessage[], id: string, output: string, is_error: bool, with_status: bool) -> void { - load_var with_status - unary_op ! - pop_jump_if_false L0 - jump L3 - - L0: - load_var is_error - pop_jump_if_false L1 - jump L2 - - L1: - load_const "success" - store_var status - jump L4 - - L2: - load_const "error" - store_var status - jump L4 - - L3: - load_const null - store_var status - - L4: - load_var2 2 3 - init_instance aws.internal.ToolResultContentBlock .text - load_type aws.internal.ToolResultContentBlock - alloc_array 1 - load_var status - init_instance aws.internal.ToolResultBlock .toolUseId, .content, .status - call aws.internal.ContentBlock.of_tool_result - store_var block - load_var pending - container_len - store_var _15 - load_type aws.internal.PendingMessage - load_var2 1 8 - load_const 1 - sub_int - call baml.Array.at - store_var _17 - load_var _17 - narrow_bind aws.internal.PendingMessage, slot=9 - pop_jump_if_false L5 - load_var _17 - store_var_load_var last - load_field .tool_results - pop_jump_if_false L5 - jump L6 - - L5: - load_type aws.internal.PendingMessage - load_var pending - load_const "user" - load_var block - load_type aws.internal.ContentBlock - alloc_array 1 - init_instance aws.internal.Message .role, .content - load_const true - init_instance aws.internal.PendingMessage .message, .tool_results - call baml.Array.push - pop 1 - jump L7 - - L6: - load_type aws.internal.ContentBlock - load_var last - load_field .message - load_field .content - load_var block - call baml.Array.push - pop 1 - - L7: - load_const null - return -} - -function aws.internal._reject(detail: string) -> ai.errors.InvalidRequest { - load_const "aws-bedrock" - load_const null - load_var detail - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function aws.internal._supports_tool_result_status(model: string) -> bool { - load_var model - call baml.String.to_lower_case - store_var id - load_var id - load_const "anthropic.claude" - call baml.String.includes - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var id - load_const "amazon.nova" - call baml.String.includes - - L1: - return -} - -function aws.internal._system_as_user(system: aws.internal.SystemContentBlock[]) -> aws.internal.Message { - load_type aws.internal.ContentBlock - alloc_array 0 - store_var content - load_var system - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _4 - load_field .text - store_var _9 - load_var _9 - narrow_bind string, slot=5 - pop_jump_if_false L2 - jump L3 - - L2: - call aws.internal.ContentBlock.of_cache_point - store_var _16 - load_type aws.internal.ContentBlock - load_var2 2 7 - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var _9 - call aws.internal.ContentBlock.of_text - store_var _12 - load_type aws.internal.ContentBlock - load_var2 2 6 - call baml.Array.push - pop 1 - jump L0 - - L4: - load_const "user" - load_var content - init_instance aws.internal.Message .role, .content - return -} - -function aws.internal._tool_choice(choice: string) -> aws.internal.ToolChoice { - load_type string - load_type unknown - alloc_map 0 - store_var empty - load_var choice - load_const "auto" - cmp_op == - pop_jump_if_false L0 - jump L5 - - L0: - load_var choice - load_const "any" - cmp_op == - pop_jump_if_false L1 - jump L4 - - L1: - load_var choice - load_const "required" - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_const null - load_const null - load_var choice - init_instance aws.internal.SpecificToolChoice .name - init_instance aws.internal.ToolChoice .auto, .any, .tool - jump L6 - - L3: - load_const null - load_var empty - load_const null - init_instance aws.internal.ToolChoice .auto, .any, .tool - jump L6 - - L4: - load_const null - load_var empty - load_const null - init_instance aws.internal.ToolChoice .auto, .any, .tool - jump L6 - - L5: - load_var empty - load_const null - load_const null - init_instance aws.internal.ToolChoice .auto, .any, .tool - - L6: - return -} - -function aws.internal._tool_config(toolbox: ai.tools.Toolbox, tool_choice: string | null, cache_tools: bool) -> aws.internal.ToolConfig | null { - load_var toolbox - call ai.tools.Toolbox.is_empty - pop_jump_if_false L0 - jump L8 - - L0: - load_type aws.internal.ToolEntry - alloc_array 0 - store_var entries - load_var toolbox - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L1: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_var _8 - store_var tool - load_var tool - load_field .name - store_var _15 - load_var tool - load_field .description - store_var _16 - load_type map - load_var tool - load_field .input_schema - call baml.json.to_json - store_var _18 - load_var2 9 10 - load_var _18 - init_instance aws.internal.ToolInputSchema .json_schema - init_instance aws.internal.ToolSpec .name, .description, .inputSchema - call aws.internal.ToolEntry.of_spec - store_var _13 - load_type aws.internal.ToolEntry - load_var2 4 8 - call baml.Array.push - pop 1 - jump L1 - - L3: - load_var cache_tools - pop_jump_if_false L4 - call aws.internal.ToolEntry.of_cache_point - store_var _23 - load_type aws.internal.ToolEntry - load_var2 4 12 - call baml.Array.push - pop 1 - - L4: - load_var tool_choice - load_const null - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_var tool_choice - call aws.internal._tool_choice - store_var selection - jump L7 - - L6: - load_const null - store_var selection - - L7: - load_var2 4 13 - init_instance aws.internal.ToolConfig .tools, .toolChoice - jump L9 - - L8: - load_const null - - L9: - return -} - -function aws.internal._video_block(video: baml.media.Video) -> aws.internal.ContentBlock { - load_var video - load_const false - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .mime_type - call aws.internal._video_format - load_var resolved - load_const "video" - call aws.internal._media_source - init_instance aws.internal.VideoBlock .format, .source - call aws.internal.ContentBlock.of_video - return -} - -function aws.internal._video_format(mime: string) -> string { - load_var mime - load_const "video/mp4" - cmp_op == - pop_jump_if_false L0 - jump L21 - - L0: - load_var mime - load_const "video/mpeg" - cmp_op == - pop_jump_if_false L1 - jump L20 - - L1: - load_var mime - load_const "video/mpg" - cmp_op == - pop_jump_if_false L2 - jump L19 - - L2: - load_var mime - load_const "video/x-mpg" - cmp_op == - pop_jump_if_false L3 - jump L18 - - L3: - load_var mime - load_const "video/x-ms-wmv" - cmp_op == - pop_jump_if_false L4 - jump L17 - - L4: - load_var mime - load_const "video/wmv" - cmp_op == - pop_jump_if_false L5 - jump L16 - - L5: - load_var mime - load_const "video/x-matroska" - cmp_op == - pop_jump_if_false L6 - jump L15 - - L6: - load_var mime - load_const "video/quicktime" - cmp_op == - pop_jump_if_false L7 - jump L14 - - L7: - load_var mime - load_const "video/x-flv" - cmp_op == - pop_jump_if_false L8 - jump L13 - - L8: - load_var mime - load_const "video/webm" - cmp_op == - pop_jump_if_false L9 - jump L12 - - L9: - load_var mime - load_const "video/3gpp" - cmp_op == - pop_jump_if_false L10 - jump L11 - - L10: - load_type string - load_var mime - call baml.String.from - store_var _15 - load_const "unsupported video format for Bedrock: " - load_var _15 - bin_op + - call aws.internal._reject - throw - - L11: - load_const "three_gp" - jump L22 - - L12: - load_const "webm" - jump L22 - - L13: - load_const "flv" - jump L22 - - L14: - load_const "mov" - jump L22 - - L15: - load_const "mkv" - jump L22 - - L16: - load_const "wmv" - jump L22 - - L17: - load_const "wmv" - jump L22 - - L18: - load_const "mpg" - jump L22 - - L19: - load_const "mpg" - jump L22 - - L20: - load_const "mpeg" - jump L22 - - L21: - load_const "mp4" - - L22: - return -} - -function aws.internal._wants_cache_point(message: ai.PromptMessage) -> bool { - load_type string - load_type baml.json.json - load_var message - load_field .metadata - load_const "cache_point" - call baml.Map.get - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_const true - jump L2 - - L1: - load_const false - - L2: - return -} - -function aws.internal.build_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var2 1 2 - call aws.internal.converse_request - store_var _5 - load_type aws.internal.ConverseRequest - load_var _5 - call baml.json.to_json - call aws.internal._prune_nulls - load_var client - load_field .request_body - call ai.wire.merge_request_body - store_var merged - load_var client - call aws.internal.converse_url - load_var client - load_field .query_params - call aws.internal._apply_query - store_var _10 - load_const "application/json" - load_const "application/json" - load_const "content-type" - load_const "accept" - load_type string - load_type string - alloc_map 2 - load_var client - load_field .headers - call aws.internal._merge_headers - store_var _13 - load_var merged - call baml.json.stringify - store_var _16 - load_const "POST" - load_var2 5 6 - load_var _16 - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function aws.internal.converse_model_path(model_id: string) -> string { - load_var model_id - call aws.internal.encode_path_label - store_var _4 - load_type string - load_var _4 - call baml.String.from - store_var _3 - load_const "/model/" - load_var _3 - bin_op + - load_const "/converse" - bin_op + - return -} - -function aws.internal.converse_request(client: aws.BedrockClient, input: ai.ModelTurnInput) -> aws.internal.ConverseRequest { - load_var input - load_field .prompt - store_var _5 - load_var input - load_field .output_type - call ai.wire.render_output_format - load_var _5 - call_indirect - call aws.internal._lower_prompt - store_var prompt - load_var prompt - load_field .system - store_var system - load_var client - load_field .cache_system_prompt - jump_if_false L0 - pop 1 - load_var system - container_len - store_var _11 - load_var _11 - load_const 0 - cmp_int_op > - - L0: - pop_jump_if_false L1 - call aws.internal.SystemContentBlock.of_cache_point - store_var _13 - load_type aws.internal.SystemContentBlock - load_var2 5 7 - call baml.Array.push - pop 1 - - L1: - load_var prompt - load_field .messages - store_var messages - load_var input - load_field .journal - store_var _18 - load_var client - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - load_var2 10 11 - call ai.wire.sanitize_for_client - store_var _17 - load_var client - load_field .model - call aws.internal._supports_tool_result_status - store_var _20 - load_var2 9 12 - call aws.internal._lower_journal - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _23 - - L2: - load_var _23 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _24 - load_var _24 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L4 - - L3: - load_type aws.internal.Message - load_var2 8 14 - call baml.Array.push - pop 1 - jump L2 - - L4: - load_type aws.internal.Message - load_var messages - load_const 0 - call baml.Array.at - load_const null - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_type aws.internal.Message - load_var messages - load_const 0 - call baml.Array.at - load_field .0 - jump L7 - - L6: - load_const null - - L7: - store_var_load_var _32 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const "" - store_var _32 - - L8: - load_var _32 - store_var_load_var leading_role - load_const "user" - cmp_op != - jump_if_false L9 - pop 1 - jump L10 - - L9: - store_var folded - jump L11 - - L10: - load_var system - container_len - store_var _43 - load_var _43 - load_const 0 - cmp_int_op > - store_var folded - - L11: - load_var messages - container_len - store_var _47 - load_var _47 - load_const 0 - cmp_int_op > - jump_if_false L12 - pop 1 - load_var leading_role - load_const "user" - cmp_op != - - L12: - jump_if_false L13 - pop 1 - load_var system - container_len - store_var _49 - load_var _49 - load_const 0 - cmp_int_op == - - L13: - load_var folded - pop_jump_if_false L14 - jump L17 - - L14: - pop_jump_if_false L15 - jump L16 - - L15: - load_var messages - jump L18 - - L16: - load_const "(continue)" - call aws.internal.ContentBlock.of_text - store_var _62 - load_type aws.internal.Message - load_const "user" - load_var _62 - load_type aws.internal.ContentBlock - alloc_array 1 - init_instance aws.internal.Message .role, .content - load_type aws.internal.Message - alloc_array 1 - load_var messages - call baml.Array.concat - jump L18 - - L17: - load_var system - call aws.internal._system_as_user - store_var _54 - load_type aws.internal.Message - load_var _54 - load_type aws.internal.Message - alloc_array 1 - load_var messages - call baml.Array.concat - - L18: - call aws.internal._merge_adjacent_roles - store_var wire_messages - load_var wire_messages - container_len - store_var _66 - load_var _66 - load_const 0 - cmp_int_op == - pop_jump_if_false L19 - jump L25 - - L19: - load_var folded - jump_if_false L20 - jump L21 - - L20: - pop 1 - load_var system - container_len - store_var _71 - load_var _71 - load_const 0 - cmp_int_op == - - L21: - pop_jump_if_false L22 - jump L23 - - L22: - load_var system - jump L24 - - L23: - load_const null - - L24: - store_var _73 - load_var client - call aws.internal._inference_config - store_var _74 - load_var input - load_field .toolbox - load_var client - load_field .tool_choice - load_var client - load_field .cache_tools - call aws.internal._tool_config - store_var _75 - load_var2 21 26 - load_var2 27 28 - load_var client - load_field .additional_model_request_fields - init_instance aws.internal.ConverseRequest .messages, .system, .inferenceConfig, .toolConfig, .additionalModelRequestFields - return - - L25: - load_const "the rendered prompt and journal produced no message content" - call aws.internal._reject - throw -} - -function aws.internal.converse_url(client: aws.BedrockClient) -> string { - load_var client - load_field .model - call aws.internal.converse_model_path - store_var path - load_var client - call aws.BedrockClient.resolved_endpoint_url - store_var _5 - load_var _5 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L6 - - L0: - load_var client - load_field .region - store_var _18 - load_var _18 - narrow_bind string, slot=9 - pop_jump_if_false L1 - jump L5 - - L1: - load_const null - load_var client - load_field .profile - call aws.internal.resolve_region - jump L2 - load_var e - throw_if_panic - load_type baml.errors.AccessError | baml.errors.Io - load_var e - call baml.String.from - store_var _34 - load_type string - load_var _34 - call baml.String.from - store_var _33 - load_const "aws-bedrock" - load_const null - load_const "AWS region resolution failed: " - load_var _33 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L2: - store_var _37 - load_var _37 - narrow_bind string, slot=15 - pop_jump_if_false L3 - jump L4 - - L3: - load_const "aws-bedrock" - load_const null - load_const "no AWS region: set the client's `region` option, AWS_REGION, AWS_DEFAULT_REGION, or a `region` key on the active profile (or set `endpoint_url` to bypass region resolution)" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L4: - load_type string - load_var _37 - call baml.String.from - store_var _41 - load_type string - load_var path - call baml.String.from - store_var _44 - load_const "https://bedrock-runtime." - load_var _41 - bin_op + - load_const ".amazonaws.com" - bin_op + - load_var _44 - bin_op + - jump L10 - - L5: - load_type string - load_var _18 - call baml.String.from - store_var _22 - load_type string - load_var path - call baml.String.from - store_var _25 - load_const "https://bedrock-runtime." - load_var _22 - bin_op + - load_const ".amazonaws.com" - bin_op + - load_var _25 - bin_op + - jump L10 - - L6: - load_var _5 - store_var endpoint - load_var endpoint - load_const "/" - call baml.String.ends_with - pop_jump_if_false L7 - jump L8 - - L7: - load_var endpoint - store_var base - jump L9 - - L8: - load_var endpoint - call baml.String.length - store_var _10 - load_var endpoint - load_const 0 - load_var _10 - load_const 1 - sub_int - call baml.String.slice - store_var base - - L9: - load_type string - load_var base - call baml.String.from - store_var _11 - load_type string - load_var path - call baml.String.from - store_var _14 - load_var2 7 8 - bin_op + - - L10: - return -} - -function aws.internal.encode_path_label(value: string) -> string { - load_type string - alloc_array 0 - store_var out - load_var value - call baml.String.to_utf8 - call baml.Uint8Array.to_array - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - - L0: - load_var _6 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var _7 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _7 - store_var_load_var byte - call aws.internal._is_unreserved_byte - pop_jump_if_false L2 - jump L5 - - L2: - load_const "0123456789ABCDEF" - load_var byte - load_const 16 - div_int - call baml.String.at - store_var_load_var _23 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _23 - - L3: - load_type string - load_var _23 - call baml.String.from - store_var _21 - load_const "0123456789ABCDEF" - load_var byte - load_const 16 - mod_int - call baml.String.at - store_var_load_var _31 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const "" - store_var _31 - - L4: - load_type string - load_var _31 - call baml.String.from - store_var _29 - load_type string - load_var out - load_const "%" - load_var _21 - bin_op + - load_var _29 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var byte - load_type int - alloc_array 1 - call baml.String.from_code_points - store_var _14 - load_type string - load_var2 2 6 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_type string - load_var out - load_const "" - call baml.Array.join - return -} - -function aws.internal.invoke(client: aws.BedrockClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call aws.internal.build_request - store_var _4 - load_var2 1 4 - call aws.internal.sign - store_var request - load_type aws.internal.ConverseResponse - load_var request - load_const "aws-bedrock" - call ai.wire.send_as - call aws.internal.parse_response - return -} - -function aws.internal.parse_response(response: aws.internal.ConverseResponse) -> ai.ModelTurn { - load_var response - load_field .stopReason - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - load_var _3 - call aws.internal._is_malformed_stop - pop_jump_if_false L0 - jump L28 - - L0: - load_var response - load_field .output - load_const null - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var response - load_field .output - load_field .0 - store_var message - jump L3 - - L2: - load_const null - store_var message - - L3: - load_var message - load_const null - call baml.ops.equals_equals - pop_jump_if_false L4 - jump L27 - - L4: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_var message - load_field .1 - store_var_load_var _23 - load_const null - cmp_op == - pop_jump_if_false L5 - load_type aws.internal.ResponseContentBlock - alloc_array 0 - store_var _23 - - L5: - load_var _23 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _27 - - L6: - load_var _27 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - load_var _28 - is_type baml.iter.Done - pop_jump_if_false L7 - jump L18 - - L7: - load_var _28 - store_var_load_var block - load_field .text - store_var _33 - load_var _33 - narrow_bind string, slot=11 - pop_jump_if_false L8 - jump L17 - - L8: - load_var block - load_field .toolUse - store_var _40 - load_var _40 - narrow_bind aws.internal.ResponseToolUse, slot=12 - pop_jump_if_false L9 - jump L13 - - L9: - load_var block - load_field .reasoningContent - store_var _59 - load_var _59 - narrow_bind aws.internal.ReasoningContent, slot=19 - pop_jump_if_false L6 - load_var _59 - store_var_load_var reasoning - load_field .reasoningText - load_const null - cmp_op == - pop_jump_if_false L10 - jump L11 - - L10: - load_var reasoning - load_field .reasoningText - load_field .0 - jump L12 - - L11: - load_const null - - L12: - store_var _65 - load_var _65 - narrow_bind string, slot=21 - pop_jump_if_false L6 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 6 21 - init_instance ai.content.Reasoning .summary - call baml.Array.push - pop 1 - jump L6 - - L13: - load_var _40 - store_var_load_var use - load_field .toolUseId - store_var_load_var _46 - load_const null - cmp_op == - pop_jump_if_false L14 - load_const "" - store_var _46 - - L14: - load_var _46 - store_var _45 - load_var use - load_field .name - store_var_load_var _50 - load_const null - cmp_op == - pop_jump_if_false L15 - load_const "" - store_var _50 - - L15: - load_var _50 - store_var _49 - load_var use - load_field .input - store_var_load_var _54 - load_const null - cmp_op == - pop_jump_if_false L16 - load_type string - load_type unknown - alloc_map 0 - store_var _54 - - L16: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 6 14 - load_var2 16 18 - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L6 - - L17: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 6 11 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L6 - - L18: - load_var response - load_field .stopReason - store_var_load_var _72 - load_const null - cmp_op == - pop_jump_if_false L19 - jump L20 - - L19: - load_var _72 - call aws.internal.stop_reason - store_var stop - jump L21 - - L20: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - - L21: - load_var response - load_field .usage - store_var_load_var _77 - load_const null - cmp_op == - pop_jump_if_false L22 - jump L25 - - L22: - load_var _77 - store_var_load_var reported - load_field .inputTokens - store_var_load_var _81 - load_const null - cmp_op == - pop_jump_if_false L23 - load_const 0 - store_var _81 - - L23: - load_var _81 - store_var _80 - load_var reported - load_field .outputTokens - store_var_load_var _85 - load_const null - cmp_op == - pop_jump_if_false L24 - load_const 0 - store_var _85 - - L24: - load_var2 27 29 - load_var reported - load_field .cacheReadInputTokens - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - jump L26 - - L25: - load_const null - store_var usage - - L26: - load_var2 6 22 - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return - - L27: - load_type aws.internal.ConverseResponse - load_var response - call baml.json.to_json - call baml.json.stringify - store_var _18 - load_const "aws-bedrock" - load_var _18 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L28: - load_type aws.internal.ConverseResponse - load_var response - call baml.json.to_json - call baml.json.stringify - store_var _8 - load_const "aws-bedrock" - load_var _8 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function aws.internal.resolve_region(region: string | null, profile: string | null) -> string | null { - load_var2 1 2 - sys_op ai.internal._aws_resolve_region - return -} - -function aws.internal.sign(client: aws.BedrockClient, request: baml.http.Request) -> baml.http.Request { - load_var2 2 1 - load_field .region - load_var client - load_field .profile - load_var client - load_field .access_key_id - load_var client - load_field .secret_access_key - load_var client - load_field .session_token - load_const "bedrock" - init_instance aws.internal.AwsSignOptions .region, .profile, .access_key_id, .secret_access_key, .session_token, .service - call aws.internal.sign_request - jump L0 - load_var e - throw_if_panic - load_type baml.errors.AccessError | baml.errors.Io - load_var e - call baml.String.from - store_var _13 - load_type string - load_var _13 - call baml.String.from - store_var _12 - load_const "aws-bedrock" - load_const null - load_const "AWS SigV4 signing failed: " - load_var _12 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L0: - return -} - -function aws.internal.sign_request(req: baml.http.Request, opts: aws.internal.AwsSignOptions) -> baml.http.Request { - load_var2 1 2 - load_field .service - load_var opts - load_field .region - load_var opts - load_field .profile - load_var opts - load_field .access_key_id - load_var opts - load_field .secret_access_key - load_var opts - load_field .session_token - sys_op ai.internal._aws_sign_request - return -} - -function aws.internal.stop_reason(raw: string) -> ai.content.StopReason { - load_var raw - load_const "tool_use" - cmp_op == - pop_jump_if_false L0 - jump L11 - - L0: - load_var raw - load_const "max_tokens" - cmp_op == - pop_jump_if_false L1 - jump L10 - - L1: - load_var raw - load_const "model_context_window_exceeded" - cmp_op == - pop_jump_if_false L2 - jump L9 - - L2: - load_var raw - load_const "content_filtered" - cmp_op == - pop_jump_if_false L3 - jump L8 - - L3: - load_var raw - load_const "guardrail_intervened" - cmp_op == - pop_jump_if_false L4 - jump L7 - - L4: - load_var raw - call aws.internal._is_malformed_stop - pop_jump_if_false L5 - jump L6 - - L5: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - jump L12 - - L6: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L12 - - L7: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L12 - - L8: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L12 - - L9: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L12 - - L10: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L12 - - L11: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - - L12: - return -} - -function boundary.LocalId.capture(self: boundary.LocalId, inputs: bool | null, output: bool | null, error: bool | null) -> boundary.LocalId { -} - -function boundary.id() -> boundary.LocalId { -} - -function boundary.id.current() -> string { -} - -function claude_code.ClaudeCodeClient.ai.Client.id(self: claude_code.ClaudeCodeClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "claude-code/" - load_var _2 - bin_op + - return -} - -function claude_code.ClaudeCodeClient.ai.Client.invoke(self: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call claude_code.internal.invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function claude_code.ClaudeCodeClient.new(model: string, executable: string, cwd: string | null, timeout_ms: int, permission_mode: string, harness_tools: string[], mcp_servers: map | null) -> claude_code.ClaudeCodeClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "haiku" - store_var model - - L0: - load_var executable - load_const - cmp_op == - pop_jump_if_false L1 - load_const "claude" - store_var executable - - L1: - load_var cwd - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var cwd - - L2: - load_var timeout_ms - load_const - cmp_op == - pop_jump_if_false L3 - load_const 240000 - store_var timeout_ms - - L3: - load_var permission_mode - load_const - cmp_op == - pop_jump_if_false L4 - load_const "default" - store_var permission_mode - - L4: - load_var harness_tools - load_const - cmp_op == - pop_jump_if_false L5 - load_type string - alloc_array 0 - store_var harness_tools - - L5: - load_var mcp_servers - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var mcp_servers - - L6: - load_var mcp_servers - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L7 - load_type string - load_type baml.json.json - alloc_map 0 - store_var _17 - - L7: - load_var2 2 1 - load_var2 3 4 - load_var2 5 6 - load_var _17 - init_instance claude_code.ClaudeCodeClient .executable, .model, .cwd, .timeout_ms, .permission_mode, .harness_tools, .mcp_servers - return -} - -function claude_code.internal._log_cc_event(raw: baml.json.json) -> void { - load_type string - load_var raw - load_const ".type" - load_const "?" - call baml.json.path_or - store_var kind - load_var kind - load_const "system" - cmp_op == - pop_jump_if_false L0 - jump L28 - - L0: - load_var kind - load_const "assistant" - cmp_op == - pop_jump_if_false L1 - jump L16 - - L1: - load_var kind - load_const "user" - cmp_op == - pop_jump_if_false L2 - jump L4 - - L2: - load_var kind - load_const "result" - cmp_op == - pop_jump_if_false L3 - jump L31 - - L3: - load_type string - load_var kind - call baml.String.from - store_var _141 - load_const "$baml_log" - load_const "info" - load_const "cc event: " - load_var _141 - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - jump L31 - - L4: - load_type string - alloc_array 0 - store_var parts - load_type baml.json.json[] - load_var raw - load_const ".message.content" - load_type baml.json.json - alloc_array 0 - call baml.json.path_or - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _89 - - L5: - load_var _89 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _90 - load_var _90 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L15 - - L6: - load_var _90 - store_var b - load_type string - load_var b - load_const ".type" - load_const "?" - call baml.json.path_or - store_var bt - load_var bt - load_const "text" - cmp_op == - pop_jump_if_false L7 - jump L14 - - L7: - load_var bt - load_const "thinking" - cmp_op == - pop_jump_if_false L8 - jump L13 - - L8: - load_var bt - load_const "tool_use" - cmp_op == - pop_jump_if_false L9 - jump L12 - - L9: - load_var bt - load_const "tool_result" - cmp_op == - pop_jump_if_false L10 - jump L11 - - L10: - load_type string - load_var2 23 27 - call baml.Array.push - pop 1 - jump L5 - - L11: - load_type string - load_var parts - load_const "tool_result" - call baml.Array.push - pop 1 - jump L5 - - L12: - load_type string - load_var b - load_const ".name" - load_const "?" - call baml.json.path_or - store_var _119 - load_type string - load_var _119 - call baml.String.from - store_var _118 - load_type string - load_var parts - load_const "tool_use: " - load_var _118 - bin_op + - call baml.Array.push - pop 1 - jump L5 - - L13: - load_type string - load_var b - load_const ".thinking" - load_const "" - call baml.json.path_or - call claude_code.internal._preview - store_var _110 - load_type string - load_var _110 - call baml.String.from - store_var _109 - load_type string - load_var parts - load_const "thinking: " - load_var _109 - bin_op + - call baml.Array.push - pop 1 - jump L5 - - L14: - load_type string - load_var b - load_const ".text" - load_const "" - call baml.json.path_or - call claude_code.internal._preview - store_var _101 - load_type string - load_var _101 - call baml.String.from - store_var _100 - load_type string - load_var parts - load_const "text: " - load_var _100 - bin_op + - call baml.Array.push - pop 1 - jump L5 - - L15: - load_type "assistant" | "user" - load_var kind - call baml.String.from - store_var _132 - load_type string - load_var parts - load_const " | " - call baml.Array.join - store_var _136 - load_type string - load_var _136 - call baml.String.from - store_var _135 - load_const "$baml_log" - load_const "info" - load_const "cc event: " - load_var _132 - bin_op + - load_const " [" - bin_op + - load_var _135 - bin_op + - load_const "]" - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - jump L31 - - L16: - load_type string - alloc_array 0 - store_var parts - load_type baml.json.json[] - load_var raw - load_const ".message.content" - load_type baml.json.json - alloc_array 0 - call baml.json.path_or - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _33 - - L17: - load_var _33 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _34 - load_var _34 - is_type baml.iter.Done - pop_jump_if_false L18 - jump L27 - - L18: - load_var _34 - store_var b - load_type string - load_var b - load_const ".type" - load_const "?" - call baml.json.path_or - store_var bt - load_var bt - load_const "text" - cmp_op == - pop_jump_if_false L19 - jump L26 - - L19: - load_var bt - load_const "thinking" - cmp_op == - pop_jump_if_false L20 - jump L25 - - L20: - load_var bt - load_const "tool_use" - cmp_op == - pop_jump_if_false L21 - jump L24 - - L21: - load_var bt - load_const "tool_result" - cmp_op == - pop_jump_if_false L22 - jump L23 - - L22: - load_type string - load_var2 9 13 - call baml.Array.push - pop 1 - jump L17 - - L23: - load_type string - load_var parts - load_const "tool_result" - call baml.Array.push - pop 1 - jump L17 - - L24: - load_type string - load_var b - load_const ".name" - load_const "?" - call baml.json.path_or - store_var _63 - load_type string - load_var _63 - call baml.String.from - store_var _62 - load_type string - load_var parts - load_const "tool_use: " - load_var _62 - bin_op + - call baml.Array.push - pop 1 - jump L17 - - L25: - load_type string - load_var b - load_const ".thinking" - load_const "" - call baml.json.path_or - call claude_code.internal._preview - store_var _54 - load_type string - load_var _54 - call baml.String.from - store_var _53 - load_type string - load_var parts - load_const "thinking: " - load_var _53 - bin_op + - call baml.Array.push - pop 1 - jump L17 - - L26: - load_type string - load_var b - load_const ".text" - load_const "" - call baml.json.path_or - call claude_code.internal._preview - store_var _45 - load_type string - load_var _45 - call baml.String.from - store_var _44 - load_type string - load_var parts - load_const "text: " - load_var _44 - bin_op + - call baml.Array.push - pop 1 - jump L17 - - L27: - load_type "assistant" | "user" - load_var kind - call baml.String.from - store_var _76 - load_type string - load_var parts - load_const " | " - call baml.Array.join - store_var _80 - load_type string - load_var _80 - call baml.String.from - store_var _79 - load_const "$baml_log" - load_const "info" - load_const "cc event: " - load_var _76 - bin_op + - load_const " [" - bin_op + - load_var _79 - bin_op + - load_const "]" - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - jump L31 - - L28: - load_type string - load_var raw - load_const ".subtype" - load_const "?" - call baml.json.path_or - store_var subtype - load_var subtype - load_const "thinking_tokens" - cmp_op == - pop_jump_if_false L29 - jump L30 - - L29: - load_type string - load_var raw - load_const ".model" - load_const "?" - call baml.json.path_or - store_var model - load_type string - load_var subtype - call baml.String.from - store_var _21 - load_type string - load_var model - call baml.String.from - store_var _24 - load_const "$baml_log" - load_const "info" - load_const "cc event: system/" - load_var _21 - bin_op + - load_const " model=" - bin_op + - load_var _24 - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - jump L31 - - L30: - load_type int - load_var raw - load_const ".estimated_tokens" - load_const 0 - call baml.json.path_or - store_var estimated - load_type int - load_var estimated - call baml.String.from - store_var _13 - load_const "$baml_log" - load_const "debug" - load_const "cc event: thinking ~" - load_var _13 - bin_op + - load_const " tokens" - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - - L31: - load_const null - return -} - -function claude_code.internal._preview(text: string) -> string { - load_var text - call baml.String.length - load_const 120 - cmp_int_op > - pop_jump_if_false L0 - jump L1 - - L0: - load_var text - jump L2 - - L1: - load_var text - load_const 0 - load_const 120 - call baml.String.slice - store_var _5 - load_type string - load_var _5 - call baml.String.from - load_const "..." - bin_op + - - L2: - return -} - -function claude_code.internal._read_result(p: baml.sys.Process) -> baml.json.json { - load_const null - store_var result - load_var p - load_field .stdout - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _5 - call baml.String.trim - store_var trimmed - load_var trimmed - call baml.String.length - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_var trimmed - call baml.json.parse - store_var raw - jump L2 - load_var e - throw_if_panic - load_const "claude-code" - load_var trimmed - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L2: - load_var raw - call claude_code.internal._log_cc_event - pop 1 - load_type string - load_var raw - load_const ".type" - load_const "" - call baml.json.path_or - load_const "result" - cmp_op == - pop_jump_if_false L0 - load_var raw - store_var result - jump L0 - - L3: - load_var result - load_const null - call baml.ops.equals_equals - pop_jump_if_false L4 - jump L5 - - L4: - load_var result - return - - L5: - load_const "claude-code" - load_const "the Claude Code CLI stream ended without a result event" - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function claude_code.internal._type_schema(t: string) -> map { - load_type string - load_type unknown - alloc_map 0 - store_var m - load_type string - load_type unknown - load_var m - load_const "type" - load_var t - call baml.Map.set - pop 1 - load_var m - return -} - -function claude_code.internal.allowed_mcp_tools(c: claude_code.ClaudeCodeClient) -> string { - load_type string - load_type baml.json.json - load_var c - load_field .mcp_servers - call baml.Map.keys - store_var _3 - load_type string - load_type string - load_type never - load_var _3 - make_closure ., 0 - call baml.Array.map - store_var _2 - load_type string - load_var _2 - load_const "," - call baml.Array.join - return -} - -function claude_code.internal.envelope_schema(output_type: type) -> map { - load_var output_type - sys_op baml.json.schema - store_var _3 - load_type map - load_var _3 - call baml.json.from_json - store_var final_root - load_type string - load_type unknown - load_var final_root - load_const "$defs" - call baml.Map.delete - store_var definitions - load_type string - load_type unknown - alloc_map 0 - store_var call_props - load_const "string" - call claude_code.internal._type_schema - store_var _10 - load_type string - load_type unknown - load_var call_props - load_const "id" - load_var _10 - call baml.Map.set - pop 1 - load_const "string" - call claude_code.internal._type_schema - store_var _14 - load_type string - load_type unknown - load_var call_props - load_const "name" - load_var _14 - call baml.Map.set - pop 1 - load_const "object" - call claude_code.internal._type_schema - store_var _18 - load_type string - load_type unknown - load_var call_props - load_const "args" - load_var _18 - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var call_item - load_type string - load_type unknown - load_var call_item - load_const "type" - load_const "object" - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var call_item - load_const "properties" - load_var call_props - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var call_item - load_const "required" - load_const "id" - load_const "name" - load_const "args" - load_type string - alloc_array 3 - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var call_item - load_const "additionalProperties" - load_const false - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var calls_array - load_type string - load_type unknown - load_var calls_array - load_const "type" - load_const "array" - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var calls_array - load_const "items" - load_var call_item - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var calls_props - load_type string - load_type unknown - load_var calls_props - load_const "calls" - load_var calls_array - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var calls_schema - load_type string - load_type unknown - load_var calls_schema - load_const "type" - load_const "object" - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var calls_schema - load_const "properties" - load_var calls_props - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var calls_schema - load_const "required" - load_const "calls" - load_type string - alloc_array 1 - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var calls_schema - load_const "additionalProperties" - load_const false - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var outcome - load_type map - load_var final_root - call baml.json.to_json - store_var _67 - load_type map - load_var calls_schema - call baml.json.to_json - store_var _70 - load_type string - load_type unknown - load_var outcome - load_const "anyOf" - load_var2 14 15 - load_type baml.json.json - alloc_array 2 - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var props - load_type string - load_type unknown - load_var props - load_const "outcome" - load_var outcome - call baml.Map.set - pop 1 - load_type string - load_type unknown - alloc_map 0 - store_var envelope - load_type string - load_type unknown - load_var envelope - load_const "type" - load_const "object" - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var envelope - load_const "properties" - load_var props - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var envelope - load_const "required" - load_const "outcome" - load_type string - alloc_array 1 - call baml.Map.set - pop 1 - load_type string - load_type unknown - load_var envelope - load_const "additionalProperties" - load_const false - call baml.Map.set - pop 1 - load_var definitions - load_const null - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L0 - load_type string - load_type unknown - load_var envelope - load_const "$defs" - load_var definitions - call baml.Map.set - pop 1 - - L0: - load_var envelope - return -} - -function claude_code.internal.invoke(c: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_const "" - load_var input - load_field .prompt - call_indirect - call ai.Prompt.text - store_var instructions - load_var input - load_field .toolbox - call ai.tools.Toolbox.is_empty - unary_op ! - store_var_load_var has_tools - pop_jump_if_false L0 - jump L1 - - L0: - load_var input - load_field .output_type - sys_op baml.json.schema - store_var schema - jump L2 - - L1: - load_var input - load_field .output_type - call claude_code.internal.envelope_schema - store_var _11 - load_type map - load_var _11 - call baml.json.to_json - store_var schema - - L2: - load_var has_tools - pop_jump_if_false L3 - jump L4 - - L3: - load_type string - load_var instructions - call baml.String.from - store_var _29 - load_var input - load_field .journal - call claude_code.internal.transcript_text - store_var _33 - load_type string - load_var _33 - call baml.String.from - store_var _32 - load_var2 14 15 - bin_op + - store_var prompt_text - jump L5 - - L4: - load_type string - load_var instructions - call baml.String.from - store_var _18 - load_var input - load_field .journal - call claude_code.internal.transcript_text - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_var input - load_field .toolbox - call claude_code.internal.tool_protocol - store_var _26 - load_type string - load_var _26 - call baml.String.from - store_var _25 - load_var2 9 10 - bin_op + - load_var _25 - bin_op + - store_var prompt_text - - L5: - load_type string - load_var c - load_field .model - call baml.String.from - store_var _41 - load_var prompt_text - call baml.String.length - store_var _45 - load_type int - load_var _45 - call baml.String.from - store_var _44 - load_var input - load_field .toolbox - call ai.tools.Toolbox.list - container_len - store_var _48 - load_type int - load_var _48 - call baml.String.from - store_var _47 - load_const "$baml_log" - load_const "info" - load_const "claude-code invoke: model=" - load_var _41 - bin_op + - load_const " prompt_chars=" - bin_op + - load_var _44 - bin_op + - load_const " baml_tools=" - bin_op + - load_var _47 - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - load_type string - alloc_array 0 - store_var args - load_type string - load_var args - load_const "-p" - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--output-format" - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "stream-json" - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--verbose" - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--model" - call baml.Array.push - pop 1 - load_type string - load_var2 22 1 - load_field .model - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--permission-mode" - call baml.Array.push - pop 1 - load_type string - load_var2 22 1 - load_field .permission_mode - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--no-session-persistence" - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--tools" - call baml.Array.push - pop 1 - load_type string - load_var c - load_field .harness_tools - load_const "," - call baml.Array.join - store_var _76 - load_type string - load_var2 22 23 - call baml.Array.push - pop 1 - load_var c - call claude_code.internal.mcp_config_json - store_var _81 - load_var _81 - narrow_bind string, slot=24 - pop_jump_if_false L6 - load_var _81 - store_var mcp - load_type string - load_var args - load_const "--mcp-config" - call baml.Array.push - pop 1 - load_type string - load_var2 22 25 - call baml.Array.push - pop 1 - load_type string - load_var args - load_const "--strict-mcp-config" - call baml.Array.push - pop 1 - load_var c - call claude_code.internal.allowed_mcp_tools - store_var _93 - load_type string - load_var _93 - call baml.String.from - store_var _92 - load_type string - load_var args - load_const "--allowedTools=" - load_var _92 - bin_op + - call baml.Array.push - pop 1 - - L6: - load_type string - load_var args - load_const "--json-schema" - call baml.Array.push - pop 1 - load_var schema - call baml.json.stringify - store_var _99 - load_type string - load_var2 22 28 - call baml.Array.push - pop 1 - load_type string - load_var2 22 8 - call baml.Array.push - pop 1 - load_var c - load_field .executable - load_var2 22 1 - load_field .cwd - load_const null - load_var c - load_field .timeout_ms - load_const null - load_const null - init_instance baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open - sys_op baml.sys.start_process - store_var p - jump L7 - load_var e - throw_if_panic - load_type baml.errors.Io - load_var e - call baml.String.from - store_var _115 - load_type string - load_var _115 - call baml.String.from - store_var _114 - load_const "claude-code" - load_const "the Claude Code CLI could not start: " - load_var _114 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L7: - load_var p - sys_op baml.sys.Process.close_stdin - pop 1 - jump L8 - load_var e - throw_if_panic - - L8: - load_var p - call claude_code.internal._read_result - store_var result - load_var p - sys_op baml.sys.Process.wait - store_var exit - jump L9 - load_var e - throw_if_panic - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _129 - load_type string - load_var _129 - call baml.String.from - store_var _128 - load_const "claude-code" - load_const "the Claude Code CLI did not terminate cleanly: " - load_var _128 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L9: - load_var exit - call baml.sys.ProcessExit.ok - unary_op ! - pop_jump_if_false L10 - jump L23 - - L10: - load_type bool - load_var result - load_const ".is_error" - load_const false - call baml.json.path_or - pop_jump_if_false L11 - jump L22 - - L11: - load_type string - load_var result - load_const ".subtype" - load_const "?" - call baml.json.path_or - store_var _154 - load_type string - load_var _154 - call baml.String.from - store_var _153 - load_type float - load_var result - load_const ".total_cost_usd" - load_const 0.0 - call baml.json.path_or - store_var _159 - load_type float - load_var _159 - call baml.String.from - store_var _158 - load_type string - load_var result - load_const ".session_id" - load_const "?" - call baml.json.path_or - store_var _164 - load_type string - load_var _164 - call baml.String.from - store_var _163 - load_const "$baml_log" - load_const "info" - load_const "claude-code result: subtype=" - load_var _153 - bin_op + - load_const " cost_usd=" - bin_op + - load_var _158 - bin_op + - load_const " session=" - bin_op + - load_var _163 - bin_op + - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - load_type baml.json.json - load_var result - load_const ".structured_output" - call baml.json.path - store_var structured - jump L12 - load_var e - throw_if_panic - load_type string - load_var result - load_const ".result" - load_const "" - call baml.json.path_or - call baml.json.parse - store_var structured - jump L12 - load_var inner - throw_if_panic - load_var result - call baml.json.stringify - store_var _177 - load_const "claude-code" - load_var _177 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L12: - load_type int - load_var result - load_const ".usage.input_tokens" - load_const 0 - call baml.json.path_or - store_var _180 - load_type int - load_var result - load_const ".usage.output_tokens" - load_const 0 - call baml.json.path_or - store_var _183 - load_type int | null - load_var result - load_const ".usage.cache_read_input_tokens" - load_const null - call baml.json.path_or - store_var _186 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - load_var has_tools - pop_jump_if_false L13 - jump L14 - - L13: - load_var structured - call baml.json.stringify - store_var _247 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 57 74 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L21 - - L14: - load_type baml.json.json - load_var result - load_const ".structured_output.outcome" - load_var structured - call baml.json.path_or - store_var outcome - load_type baml.json.json[] | null - load_var outcome - load_const ".calls" - load_const null - call baml.json.path_or - store_var _199 - load_var _199 - narrow_bind baml.json.json[], slot=60 - pop_jump_if_false L15 - jump L16 - - L15: - load_var outcome - call baml.json.stringify - store_var _242 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 57 73 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L21 - - L16: - load_const 0 - store_var i - load_var _199 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _203 - - L17: - load_var _203 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _204 - load_var _204 - is_type baml.iter.Done - pop_jump_if_false L18 - jump L20 - - L18: - load_var _204 - store_var raw_call - load_var input - load_field .journal - call ai.Journal.entries - container_len - store_var _214 - load_type int - load_var _214 - call baml.String.from - store_var _213 - load_type int - load_var i - call baml.String.from - store_var _218 - load_type string - load_var raw_call - load_const ".id" - load_const "cc_call_" - load_var _213 - bin_op + - load_const "_" - bin_op + - load_var _218 - bin_op + - call baml.json.path_or - store_var id - load_type string - load_var raw_call - load_const ".name" - load_const "" - call baml.json.path_or - store_var name - load_type baml.json.json - load_var raw_call - load_const ".args" - load_type string - load_type baml.json.json - alloc_map 0 - call baml.json.path_or - store_var _227 - load_type map - load_var _227 - call baml.json.from_json - store_var call_args - jump L19 - load_var e - throw_if_panic - load_type string - load_type unknown - alloc_map 0 - store_var call_args - - L19: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 57 65 - load_var2 69 70 - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - load_var i - load_const 1 - add_int - store_var i - jump L17 - - L20: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - store_var stop - - L21: - load_var2 57 58 - load_var2 54 55 - load_var _186 - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - init_instance ai.ModelTurn .content, .stop_reason, .usage - store_var _0 - load_var p - sys_op baml.sys.Process.close - pop 1 - load_var _0 - return - - L22: - load_type string - load_var result - load_const ".subtype" - load_const "error" - call baml.json.path_or - store_var _143 - load_var result - call baml.json.stringify - store_var _146 - load_const "claude-code" - load_var2 42 43 - init_instance ai.errors.Refused .provider, .reason, .raw_body - throw - - L23: - load_type int - load_var exit - load_field .exit_code - call baml.String.from - store_var _136 - jump L24 - load_var p - sys_op baml.sys.Process.close - pop 1 - load_var _118 - rethrow - - L24: - load_const "claude-code" - load_const null - load_const "the Claude Code CLI exited with code " - load_var _136 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function claude_code.internal.mcp_config_json(c: claude_code.ClaudeCodeClient) -> string | null { - load_var c - load_field .mcp_servers - container_len - store_var _3 - load_var _3 - load_const 0 - cmp_int_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_type string - load_type unknown - alloc_map 0 - store_var wrapper - load_type string - load_type unknown - load_var wrapper - load_const "mcpServers" - load_var c - load_field .mcp_servers - call baml.Map.set - pop 1 - load_type map - load_var wrapper - call baml.json.to_json - call baml.json.stringify - jump L2 - - L1: - load_const null - - L2: - return -} - -function claude_code.internal.tool_protocol(tb: ai.tools.Toolbox) -> string { - load_type string - alloc_array 0 - store_var catalog - load_var tb - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var t - load_type string - load_var t - load_field .name - call baml.String.from - store_var _16 - load_type string - load_var t - load_field .description - call baml.String.from - store_var _19 - load_type map - load_var t - load_field .input_schema - call baml.json.to_json - call baml.json.stringify - store_var _23 - load_type string - load_var _23 - call baml.String.from - store_var _22 - load_type string - load_var catalog - load_const "{\"name\": \"" - load_var _16 - bin_op + - load_const "\", \"description\": \"" - bin_op + - load_var _19 - bin_op + - load_const "\", \"parameters\": " - bin_op + - load_var _22 - bin_op + - load_const "}" - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L2: - load_type string - load_var catalog - load_const ", " - call baml.Array.join - store_var _31 - load_type string - load_var _31 - call baml.String.from - store_var _30 - load_const "\n\nThe output contract is one object with an outcome field. Set outcome\nto either the final result or a tool request. The tools in the catalog\nbelow are NOT installed in your environment — never attempt to invoke\nthem directly; any such attempt fails. The ONLY way to run one is to\nfinish your reply with outcome set to\n{\"calls\": [{\"id\": \"\", \"name\": \"\", \"args\": {...}}]};\nthe caller executes the calls and re-invokes you with their results in\nthe conversation. If the Conversation so far section shows no tool\nresults yet, your outcome MUST be a calls request — never invent data a\ntool can provide. After tool results appear in the conversation, use\nthem; the Conversation so far section is authoritative. A tool result\nwith is_error=false means that call already ran — never repeat the same\nsuccessful tool call. Request only tools that are still necessary, or\nreturn the final result.\n\nApplication tool catalog (request via outcome.calls only):\n[" - load_var _30 - bin_op + - load_const "]" - bin_op + - return -} - -function claude_code.internal.transcript_text(j: ai.Journal) -> string { - load_type string - alloc_array 0 - store_var lines - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L12 - - L1: - load_var _5 - store_var e - load_var e - store_var _9 - load_var _9 - narrow_bind ai.events.UserMessage, slot=6 - pop_jump_if_false L2 - jump L11 - - L2: - load_var e - store_var _17 - load_var _17 - narrow_bind ai.events.AssistantMessage, slot=8 - pop_jump_if_false L3 - jump L6 - - L3: - load_var e - store_var _55 - load_var _55 - narrow_bind ai.events.ToolCompleted, slot=20 - pop_jump_if_false L4 - jump L5 - - L4: - load_var e - store_var _68 - load_var _68 - narrow_bind ai.events.ToolFailed, slot=24 - pop_jump_if_false L0 - load_var _68 - store_var failed - load_type string - load_var failed - load_field .id - call baml.String.from - store_var _74 - load_type string - load_var failed - load_field .message - call baml.String.from - store_var _77 - load_type string - load_var lines - load_const "tool result id=" - load_var _74 - bin_op + - load_const " is_error=true: " - bin_op + - load_var _77 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _55 - store_var done - load_type string - load_var done - load_field .id - call baml.String.from - store_var _61 - load_type string - load_var done - load_field .output - call baml.String.from - store_var _64 - load_type string - load_var lines - load_const "tool result id=" - load_var _61 - bin_op + - load_const " is_error=false: " - bin_op + - load_var _64 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var _17 - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - - L7: - load_var _20 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _21 - load_var _21 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L0 - - L8: - load_var _21 - store_var b - load_var b - store_var _25 - load_var _25 - narrow_bind ai.content.Text, slot=12 - pop_jump_if_false L9 - jump L10 - - L9: - load_var b - store_var _33 - load_var _33 - narrow_bind ai.content.ToolUse, slot=14 - pop_jump_if_false L7 - load_var _33 - store_var c - load_type string - load_var c - load_field .id - call baml.String.from - store_var _42 - load_type string - load_var c - load_field .name - call baml.String.from - store_var _45 - load_type map - load_var c - load_field .args - call baml.json.to_json - call baml.json.stringify - store_var _49 - load_type string - load_var _49 - call baml.String.from - store_var _48 - load_type string - load_var lines - load_const "assistant tool_call: {\"id\": \"" - load_var _42 - bin_op + - load_const "\", \"name\": \"" - bin_op + - load_var _45 - bin_op + - load_const "\", \"args\": " - bin_op + - load_var _48 - bin_op + - load_const "}" - bin_op + - call baml.Array.push - pop 1 - jump L7 - - L10: - load_type string - load_var _25 - load_field .text - call baml.String.from - store_var _29 - load_type string - load_var lines - load_const "assistant: " - load_var _29 - bin_op + - call baml.Array.push - pop 1 - jump L7 - - L11: - load_type string - load_var _9 - load_field .content - call baml.String.from - store_var _13 - load_type string - load_var lines - load_const "user: " - load_var _13 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L12: - load_var lines - container_len - store_var _82 - load_var _82 - load_const 0 - cmp_int_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_type string - load_var lines - load_const "\n" - call baml.Array.join - store_var _84 - load_type string - load_var _84 - call baml.String.from - store_var _83 - load_const "\n\nConversation so far:\n" - load_var _83 - bin_op + - jump L15 - - L14: - load_const "" - - L15: - return -} - -function google.GoogleClient.ai.Client.id(self: google.GoogleClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "google/" - load_var _2 - bin_op + - return -} - -function google.GoogleClient.ai.Client.invoke(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call google.internal.gemini_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function google.GoogleClient.ai.stream.StreamingClient.invoke_stream(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var2 1 2 - call google.internal.gemini_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function google.GoogleClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.GoogleClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "gemini-2.5-flash" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var request_body - - L3: - load_var headers - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var headers - - L4: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var query_params - - L5: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var temperature - - L6: - load_var max_output_tokens - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var max_output_tokens - - L7: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var top_p - - L8: - load_var top_k - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var top_k - - L9: - load_var stop_sequences - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var stop_sequences - - L10: - load_var response_modalities - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var response_modalities - - L11: - load_var safety_settings - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var safety_settings - - L12: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var safety_settings - init_instance google.GoogleClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings - return -} - -function google.GoogleClient.resolved_api_key(self: google.GoogleClient) -> string { - load_var self - load_field .api_key - load_const "GOOGLE_API_KEY" - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .api_key - load_const "GOOGLE_API_KEY" - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "google" - load_const null - load_const "google needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — " - load_var _8 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L1: - load_var _4 - return -} - -function google.GoogleClient.resolved_base_url(self: google.GoogleClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function google.SafetySetting.new(category: string, threshold: string) -> google.SafetySetting { - load_var2 1 2 - init_instance google.SafetySetting .category, .threshold - return -} - -function google.VertexClient.ai.Client.id(self: google.VertexClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "vertex/" - load_var _2 - bin_op + - return -} - -function google.VertexClient.ai.Client.invoke(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call google.internal.vertex_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function google.VertexClient.ai.stream.StreamingClient.invoke_stream(self: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var2 1 2 - call google.internal.vertex_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function google.VertexClient.new(model: string, project_id: string | null, location: string | null, credentials_json: string | null, credentials_file: string | null, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null, safety_settings: google.SafetySetting[] | null) -> google.VertexClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "gemini-2.5-flash" - store_var model - - L0: - load_var project_id - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var project_id - - L1: - load_var location - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var location - - L2: - load_var credentials_json - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var credentials_json - - L3: - load_var credentials_file - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var credentials_file - - L4: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var api_key - - L5: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var base_url - - L6: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var request_body - - L7: - load_var headers - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var headers - - L8: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var query_params - - L9: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var temperature - - L10: - load_var max_output_tokens - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var max_output_tokens - - L11: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var top_p - - L12: - load_var top_k - load_const - cmp_op == - pop_jump_if_false L13 - load_const null - store_var top_k - - L13: - load_var stop_sequences - load_const - cmp_op == - pop_jump_if_false L14 - load_const null - store_var stop_sequences - - L14: - load_var response_modalities - load_const - cmp_op == - pop_jump_if_false L15 - load_const null - store_var response_modalities - - L15: - load_var safety_settings - load_const - cmp_op == - pop_jump_if_false L16 - load_const null - store_var safety_settings - - L16: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var2 13 14 - load_var2 15 16 - load_var safety_settings - init_instance google.VertexClient .model, .project_id, .location, .credentials_json, .credentials_file, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_output_tokens, .top_p, .top_k, .stop_sequences, .response_modalities, .safety_settings - return -} - -function google.VertexClient.resolved_api_key(self: google.VertexClient) -> string | null { - load_var self - load_field .api_key - load_const null - call ai.wire.resolve_credential - return -} - -function google.VertexClient.resolved_base_url(self: google.VertexClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function google.internal.GmPart.of_file_data(data: google.internal.GmFileData) -> google.internal.GmPart { - load_const null - load_const null - load_var data - load_const null - load_const null - load_const null - init_instance google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature - return -} - -function google.internal.GmPart.of_function_call(call: google.internal.GmFunctionCall, signature: string | null) -> google.internal.GmPart { - load_const null - load_const null - load_const null - load_var call - load_const null - load_var signature - init_instance google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature - return -} - -function google.internal.GmPart.of_function_response(response: google.internal.GmFunctionResponse) -> google.internal.GmPart { - load_const null - load_const null - load_const null - load_const null - load_var response - load_const null - init_instance google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature - return -} - -function google.internal.GmPart.of_inline_data(data: google.internal.GmInlineData) -> google.internal.GmPart { - load_const null - load_var data - load_const null - load_const null - load_const null - load_const null - init_instance google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature - return -} - -function google.internal.GmPart.of_text(text: string) -> google.internal.GmPart { - load_var text - load_const null - load_const null - load_const null - load_const null - load_const null - init_instance google.internal.GmPart .text, .inlineData, .fileData, .functionCall, .functionResponse, .thoughtSignature - return -} - -function google.internal._gm_apply_headers(headers: map, extra: map | null) -> map { - load_var extra - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_var headers - jump L6 - - L1: - load_var _3 - store_var items - load_type string - load_type string - load_var items - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L2: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L5 - - L3: - load_var _9 - store_var name - load_var name - call baml.String.to_lower_case - store_var _14 - load_type string - load_type string - load_var2 4 7 - call baml.Map.get - store_var_load_var _16 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const "" - store_var _16 - - L4: - load_type string - load_type string - load_var2 1 8 - load_var _16 - call baml.Map.set - pop 1 - jump L2 - - L5: - load_var headers - - L6: - return -} - -function google.internal._gm_apply_query(url: string, params: map | null) -> string { - load_var params - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_var url - jump L9 - - L1: - load_var _3 - store_var items - load_var url - store_var out - load_type string - load_type string - load_var items - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L2: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L8 - - L3: - load_var _10 - store_var name - load_var out - load_const "?" - call baml.String.includes - pop_jump_if_false L4 - jump L5 - - L4: - load_const "?" - store_var separator - jump L6 - - L5: - load_const "&" - store_var separator - - L6: - load_type string - load_var out - call baml.String.from - store_var _19 - load_type string - load_var separator - call baml.String.from - store_var _22 - load_var name - call google.internal._gm_encode_query - store_var _26 - load_type string - load_var _26 - call baml.String.from - store_var _25 - load_type string - load_type string - load_var2 4 8 - call baml.Map.get - store_var_load_var _32 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const "" - store_var _32 - - L7: - load_var _32 - call google.internal._gm_encode_query - store_var _30 - load_type string - load_var _30 - call baml.String.from - store_var _29 - load_var2 10 11 - bin_op + - load_var _25 - bin_op + - load_const "=" - bin_op + - load_var _29 - bin_op + - store_var out - jump L2 - - L8: - load_var out - - L9: - return -} - -function google.internal._gm_call_id_signature(id: string) -> string | null { - call google.internal._gm_sig_marker - store_var marker - load_var2 1 2 - call baml.String.index_of - store_var _5 - load_var _5 - narrow_bind int, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L2 - - L1: - load_var _5 - store_var _8 - load_var marker - call baml.String.length - load_var _8 - add_int - store_var _7 - load_var id - call baml.String.length - store_var _10 - load_var2 1 4 - load_var _10 - call baml.String.slice - - L2: - return -} - -function google.internal._gm_decode_batch(batch: string, provider: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - store_var out - load_var batch - call ai.stream.decode_sse_batch - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L50 - - L1: - load_var _6 - load_field .data - store_var_load_var _12 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _12 - - L2: - load_var _12 - call baml.String.trim - store_var payload - load_var payload - load_const "" - cmp_op == - jump_if_false L3 - jump L4 - - L3: - pop 1 - load_var payload - load_const "[DONE]" - cmp_op == - - L4: - pop_jump_if_false L5 - jump L0 - - L5: - load_type google.internal.GmResponse - load_var payload - call baml.json.from_string - store_var resp - jump L6 - load_var e - throw_if_panic - load_var2 2 6 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L6: - load_var resp - load_field .error - store_var _26 - load_var _26 - narrow_bind google.internal.GmError, slot=10 - pop_jump_if_false L7 - jump L47 - - L7: - load_var resp - load_field .candidates - load_const null - cmp_op == - pop_jump_if_false L8 - jump L9 - - L8: - load_const 0 - load_var resp - load_field .candidates - make_bound_method baml.Array.at - call_indirect - store_var cand - jump L10 - - L9: - load_const null - store_var cand - - L10: - load_var cand - load_const null - cmp_op == - pop_jump_if_false L11 - jump L14 - - L11: - load_var cand - load_field .0 - load_const null - cmp_op == - pop_jump_if_false L12 - jump L14 - - L12: - load_var cand - load_const null - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_var cand - load_field .0 - load_field .1 - jump L15 - - L14: - load_const null - - L15: - store_var_load_var _43 - load_const null - cmp_op == - pop_jump_if_false L16 - load_type google.internal.GmRespPart - alloc_array 0 - store_var _43 - - L16: - load_var _43 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _56 - - L17: - load_var _56 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _57 - load_var _57 - is_type baml.iter.Done - pop_jump_if_false L18 - jump L21 - - L18: - load_var _57 - store_var_load_var p - load_field .text - store_var _62 - load_var _62 - narrow_bind string, slot=20 - pop_jump_if_false L17 - load_var _62 - store_var t - load_var p - load_field .thought - store_var_load_var _65 - load_const null - cmp_op == - pop_jump_if_false L19 - load_const false - store_var _65 - - L19: - load_var _65 - pop_jump_if_false L20 - jump L17 - - L20: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 21 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - jump L17 - - L21: - load_var cand - load_const null - cmp_op == - pop_jump_if_false L22 - jump L23 - - L22: - load_var cand - load_field .1 - jump L24 - - L23: - load_const null - - L24: - store_var_load_var _73 - load_const null - cmp_op == - pop_jump_if_false L25 - load_const "" - store_var _73 - - L25: - load_var _73 - store_var finish - load_var resp - load_field .promptFeedback - load_const null - cmp_op == - pop_jump_if_false L26 - jump L27 - - L26: - load_var resp - load_field .promptFeedback - load_field .0 - jump L28 - - L27: - load_const null - - L28: - load_const null - call baml.ops.equals_equals - store_var _84 - load_var finish - load_const "MAX_TOKENS" - cmp_op == - pop_jump_if_false L29 - jump L36 - - L29: - load_var _84 - unary_op ! - jump_if_false L30 - jump L31 - - L30: - pop 1 - load_var finish - call google.internal._gm_is_blocked - - L31: - pop_jump_if_false L32 - jump L35 - - L32: - load_var finish - load_const "" - cmp_op != - pop_jump_if_false L33 - jump L34 - - L33: - load_const null - store_var stop - jump L37 - - L34: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - jump L37 - - L35: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - store_var stop - jump L37 - - L36: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - store_var stop - - L37: - load_var resp - load_field .usageMetadata - store_var usage - load_var stop - load_const null - call baml.ops.equals_equals - unary_op ! - jump_if_false L38 - jump L39 - - L38: - pop 1 - load_var usage - load_const null - call baml.ops.equals_equals - unary_op ! - - L39: - pop_jump_if_false L46 - load_var stop - store_var _102 - load_var usage - load_const null - cmp_op == - pop_jump_if_false L40 - jump L41 - - L40: - load_var usage - load_field .0 - store_var _103 - jump L42 - - L41: - load_const null - store_var _103 - - L42: - load_var usage - load_const null - cmp_op == - pop_jump_if_false L43 - jump L44 - - L43: - load_var usage - load_field .1 - store_var _107 - jump L45 - - L44: - load_const null - store_var _107 - - L45: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 28 - load_var2 29 30 - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - - L46: - load_var stop - load_const null - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L0 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - alloc_instance ai.stream.TurnDone - call baml.Array.push - pop 1 - jump L0 - - L47: - load_var _26 - store_var_load_var err - load_field .code - store_var_load_var _30 - load_const null - cmp_op == - pop_jump_if_false L48 - load_const 0 - store_var _30 - - L48: - load_var _30 - store_var _29 - load_var err - load_field .message - store_var_load_var _34 - load_const null - cmp_op == - pop_jump_if_false L49 - load_var payload - store_var _34 - - L49: - load_var2 2 12 - load_var _34 - load_const - call ai.errors.classify_http - throw - - L50: - load_var out - return -} - -function google.internal._gm_encode_call_id(id: string, signature: string | null) -> string { - load_var signature - store_var _3 - load_var _3 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_var id - jump L2 - - L1: - load_var _3 - store_var sig - load_type string - load_var id - call baml.String.from - store_var _6 - call google.internal._gm_sig_marker - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_type string - load_var sig - call baml.String.from - store_var _11 - load_var2 5 6 - bin_op + - load_var _11 - bin_op + - - L2: - return -} - -function google.internal._gm_encode_query(value: string) -> string { - load_var value - load_const "%" - load_const "%25" - call baml.String.replace_all - load_const " " - load_const "%20" - call baml.String.replace_all - load_const "\"" - load_const "%22" - call baml.String.replace_all - load_const "#" - load_const "%23" - call baml.String.replace_all - load_const "&" - load_const "%26" - call baml.String.replace_all - load_const "+" - load_const "%2B" - call baml.String.replace_all - load_const "/" - load_const "%2F" - call baml.String.replace_all - load_const "<" - load_const "%3C" - call baml.String.replace_all - load_const "=" - load_const "%3D" - call baml.String.replace_all - load_const ">" - load_const "%3E" - call baml.String.replace_all - load_const "?" - load_const "%3F" - call baml.String.replace_all - return -} - -function google.internal._gm_generation_config(temperature: float | null, max_output_tokens: int | null, top_p: float | null, top_k: int | null, stop_sequences: string[] | null, response_modalities: string[] | null) -> google.internal.GmGenerationConfig | null { - load_var temperature - load_const null - call baml.ops.equals_equals - jump_if_false L0 - pop 1 - load_var max_output_tokens - load_const null - call baml.ops.equals_equals - - L0: - jump_if_false L1 - pop 1 - load_var top_p - load_const null - call baml.ops.equals_equals - - L1: - jump_if_false L2 - pop 1 - load_var top_k - load_const null - call baml.ops.equals_equals - - L2: - jump_if_false L3 - pop 1 - load_var stop_sequences - load_const null - call baml.ops.equals_equals - - L3: - jump_if_false L4 - pop 1 - load_var response_modalities - load_const null - call baml.ops.equals_equals - - L4: - pop_jump_if_false L5 - jump L6 - - L5: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - init_instance google.internal.GmGenerationConfig .temperature, .maxOutputTokens, .topP, .topK, .stopSequences, .responseModalities - jump L7 - - L6: - load_const null - - L7: - return -} - -function google.internal._gm_is_blocked(finish: string) -> bool { - load_var finish - load_const "SAFETY" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var finish - load_const "RECITATION" - cmp_op == - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var finish - load_const "PROHIBITED_CONTENT" - cmp_op == - - L3: - jump_if_false L4 - jump L5 - - L4: - pop 1 - load_var finish - load_const "BLOCKLIST" - cmp_op == - - L5: - jump_if_false L6 - jump L7 - - L6: - pop 1 - load_var finish - load_const "SPII" - cmp_op == - - L7: - jump_if_false L8 - jump L9 - - L8: - pop 1 - load_var finish - load_const "IMAGE_SAFETY" - cmp_op == - - L9: - return -} - -function google.internal._gm_is_opaque_key(key: string) -> bool { - load_var key - load_const "args" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var key - load_const "response" - cmp_op == - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var key - load_const "parametersJsonSchema" - cmp_op == - - L3: - return -} - -function google.internal._gm_is_provider_uri(url: string) -> bool { - load_var url - load_const "gs://" - call baml.String.starts_with - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var url - load_const "://generativelanguage.googleapis.com/v1beta/files/" - call baml.String.includes - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var url - load_const "://www.youtube.com/" - call baml.String.includes - - L3: - jump_if_false L4 - jump L5 - - L4: - pop 1 - load_var url - load_const "://youtube.com/" - call baml.String.includes - - L5: - jump_if_false L6 - jump L7 - - L6: - pop 1 - load_var url - load_const "://m.youtube.com/" - call baml.String.includes - - L7: - jump_if_false L8 - jump L9 - - L8: - pop 1 - load_var url - load_const "://youtu.be/" - call baml.String.includes - - L9: - return -} - -function google.internal._gm_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, fetch_url: bool) -> google.internal.GmPart { - load_var media - call google.internal._gm_media_url - store_var _5 - load_var _5 - narrow_bind string, slot=4 - pop_jump_if_false L0 - jump L1 - - L0: - load_const false - store_var passthrough - jump L2 - - L1: - load_var _5 - call google.internal._gm_is_provider_uri - store_var passthrough - - L2: - load_var fetch_url - jump_if_false L3 - pop 1 - jump L4 - - L3: - store_var _9 - jump L5 - - L4: - load_var passthrough - unary_op ! - store_var _9 - - L5: - load_var2 1 6 - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .url - store_var _12 - load_var _12 - narrow_bind string, slot=7 - pop_jump_if_false L6 - jump L8 - - L6: - load_var resolved - load_field .mime_type - store_var _20 - load_var resolved - load_field .base64 - store_var_load_var _22 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const "" - store_var _22 - - L7: - load_var2 9 10 - init_instance google.internal.GmInlineData .mimeType, .data - call google.internal.GmPart.of_inline_data - jump L9 - - L8: - load_var _12 - store_var_load_var url - load_var resolved - load_field .mime_type - call google.internal._gm_mime_for_uri - load_var url - init_instance google.internal.GmFileData .mimeType, .fileUri - call google.internal.GmPart.of_file_data - - L9: - return -} - -function google.internal._gm_media_url(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> string | null { - load_var media - store_var _2 - load_var _2 - narrow_bind baml.media.Image, slot=2 - pop_jump_if_false L0 - jump L5 - - L0: - load_var media - store_var _4 - load_var _4 - narrow_bind baml.media.Audio, slot=3 - pop_jump_if_false L1 - jump L4 - - L1: - load_var media - store_var _6 - load_var _6 - narrow_bind baml.media.Video, slot=4 - pop_jump_if_false L2 - jump L3 - - L2: - load_var media - call baml.media.Pdf.url - jump L6 - - L3: - load_var _6 - call baml.media.Video.url - jump L6 - - L4: - load_var _4 - call baml.media.Audio.url - jump L6 - - L5: - load_var _2 - call baml.media.Image.url - - L6: - return -} - -function google.internal._gm_mime_for_uri(url: string, mime: string) -> string | null { - load_var url - load_const "gs://" - call baml.String.starts_with - pop_jump_if_false L0 - jump L3 - - L0: - load_var url - load_const "youtu" - call baml.String.includes - pop_jump_if_false L1 - jump L2 - - L1: - load_var mime - jump L4 - - L2: - load_const null - jump L4 - - L3: - load_var mime - - L4: - return -} - -function google.internal._gm_open_sse(req: baml.http.Request, provider: string) -> baml.http.SseStream { - load_var req - sys_op baml.http.fetch_sse - jump L0 - load_var e - throw_if_panic - load_var2 2 3 - call google.internal._gm_sse_failure - throw - - L0: - return -} - -function google.internal._gm_output_media(mime: string, data: string) -> ai.content.Media { - load_var mime - load_const "audio/" - call baml.String.starts_with - pop_jump_if_false L0 - jump L5 - - L0: - load_var mime - load_const "video/" - call baml.String.starts_with - pop_jump_if_false L1 - jump L4 - - L1: - load_var mime - load_const "application/pdf" - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_var2 2 1 - call baml.media.Image.from_base64 - jump L6 - - L3: - load_var2 2 1 - call baml.media.Pdf.from_base64 - jump L6 - - L4: - load_var2 2 1 - call baml.media.Video.from_base64 - jump L6 - - L5: - load_var2 2 1 - call baml.media.Audio.from_base64 - - L6: - load_const - load_const - call ai.content.Media.new - return -} - -function google.internal._gm_prompt_parts(message: ai.PromptMessage, fetch_url: bool) -> google.internal.GmPart[] { - load_type google.internal.GmPart - alloc_array 0 - store_var parts - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L10 - - L1: - load_var _6 - store_var part - load_var part - store_var _10 - load_var _10 - narrow_bind string, slot=7 - pop_jump_if_false L2 - jump L9 - - L2: - load_var part - store_var _16 - load_var _16 - narrow_bind baml.media.Image, slot=9 - pop_jump_if_false L3 - jump L8 - - L3: - load_var part - store_var _22 - load_var _22 - narrow_bind baml.media.Audio, slot=11 - pop_jump_if_false L4 - jump L7 - - L4: - load_var part - store_var _28 - load_var _28 - narrow_bind baml.media.Video, slot=13 - pop_jump_if_false L5 - jump L6 - - L5: - load_var2 6 2 - call google.internal._gm_media_part - store_var _36 - load_type google.internal.GmPart - load_var2 3 15 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var2 13 2 - call google.internal._gm_media_part - store_var _31 - load_type google.internal.GmPart - load_var2 3 14 - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var2 11 2 - call google.internal._gm_media_part - store_var _25 - load_type google.internal.GmPart - load_var2 3 12 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var2 9 2 - call google.internal._gm_media_part - store_var _19 - load_type google.internal.GmPart - load_var2 3 10 - call baml.Array.push - pop 1 - jump L0 - - L9: - load_var _10 - call google.internal.GmPart.of_text - store_var _13 - load_type google.internal.GmPart - load_var2 3 8 - call baml.Array.push - pop 1 - jump L0 - - L10: - load_var parts - return -} - -function google.internal._gm_sig_marker() -> string { - load_const "~gts~" - return -} - -function google.internal._gm_sse_failure(provider: string, error: unknown) -> ai.errors.Failure { - load_var error - store_var _5 - load_var _5 - narrow_bind baml.errors.Io, slot=5 - pop_jump_if_false L0 - jump L1 - - L0: - load_type unknown - load_var error - call baml.String.from - store_var _4 - jump L2 - - L1: - load_var _5 - load_field .message - store_var _4 - - L2: - load_var _4 - call ai.wire.redact_url_secrets - store_var text - load_var text - load_const "failed with status " - call baml.String.index_of - store_var _11 - load_var _11 - narrow_bind int, slot=6 - pop_jump_if_false L5 - load_var _11 - store_var _15 - load_const "failed with status " - call baml.String.length - load_var _15 - add_int - store_var _14 - load_var text - call baml.String.length - store_var _17 - load_var2 3 8 - load_var _17 - call baml.String.slice - store_var rest - load_var rest - load_const ":" - call baml.String.split - store_var _21 - load_type string - load_var _21 - load_const 0 - call baml.Array.at - store_var_load_var _19 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _19 - - L3: - load_var _19 - call baml.String.trim - call baml.Int.parse - store_var status - jump L4 - load_var e - throw_if_panic - load_const 0 - store_var status - - L4: - load_var status - load_const 0 - cmp_int_op > - pop_jump_if_false L5 - jump L6 - - L5: - load_type string - load_var text - call baml.String.from - store_var _40 - load_var provider - load_const "transport failed before a response arrived: " - load_var _40 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L10 - - L6: - load_var rest - load_const ":" - call baml.String.index_of - store_var _31 - load_var _31 - narrow_bind int, slot=16 - pop_jump_if_false L7 - jump L8 - - L7: - load_const "" - store_var body - jump L9 - - L8: - load_var _31 - load_const 1 - add_int - store_var _34 - load_var rest - call baml.String.length - store_var _36 - load_var2 7 17 - load_var _36 - call baml.String.slice - call baml.String.trim - store_var body - - L9: - load_var2 1 13 - load_var body - load_const - call ai.errors.classify_http - - L10: - return -} - -function google.internal._gm_strip_nulls(value: baml.json.json, opaque: bool) -> baml.json.json { - load_var opaque - pop_jump_if_false L0 - jump L9 - - L0: - load_var value - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L1 - jump L4 - - L1: - load_var value - store_var _27 - load_var _27 - narrow_bind baml.json.json[], slot=12 - pop_jump_if_false L2 - jump L3 - - L2: - load_var value - jump L10 - - L3: - load_type baml.json.json - load_type baml.json.json - load_type never - load_var _27 - make_closure ., 0 - call baml.Array.map - jump L10 - - L4: - load_var _3 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L5: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L8 - - L6: - load_var _10 - store_var key - load_type string - load_type baml.json.json - load_var2 4 8 - call baml.Map.get - store_var entry - load_var entry - load_const null - cmp_op == - pop_jump_if_false L7 - jump L5 - - L7: - load_var key - call google.internal._gm_is_opaque_key - store_var _23 - load_var2 9 11 - call google.internal._gm_strip_nulls - store_var _21 - load_type string - load_type baml.json.json - load_var2 5 8 - load_var _21 - call baml.Map.set - pop 1 - jump L5 - - L8: - load_var out - jump L10 - - L9: - load_var value - - L10: - return -} - -function google.internal._gm_tool_name_for(j: ai.Journal, id: string) -> string { - load_const "" - store_var name - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L4 - - L1: - load_var _6 - store_var _10 - load_var _10 - narrow_bind ai.events.AssistantMessage, slot=6 - pop_jump_if_false L0 - load_var _10 - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _13 - - L2: - load_var _13 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _14 - load_var _14 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L0 - - L3: - load_var _14 - store_var _18 - load_var _18 - narrow_bind ai.content.ToolUse, slot=9 - pop_jump_if_false L2 - load_var _18 - store_var_load_var u - load_field .id - load_var id - cmp_op == - pop_jump_if_false L2 - load_var u - load_field .name - store_var name - jump L2 - - L4: - load_var name - return -} - -function google.internal._gm_usage(usage: google.internal.GmUsageMetadata | null) -> ai.events.Usage | null { - load_var usage - store_var _2 - load_var _2 - narrow_bind google.internal.GmUsageMetadata, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L4 - - L1: - load_var _2 - store_var_load_var um - load_field .promptTokenCount - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const 0 - store_var _5 - - L2: - load_var _5 - store_var _4 - load_var um - load_field .candidatesTokenCount - store_var_load_var _9 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const 0 - store_var _9 - - L3: - load_var2 4 6 - load_var um - load_field .cachedContentTokenCount - load_var um - load_field .thoughtsTokenCount - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - - L4: - return -} - -function google.internal._google_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_var batch - load_const "google" - call google.internal._gm_decode_batch - return -} - -function google.internal._google_request(c: google.GoogleClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var c - load_field .temperature - load_var c - load_field .max_output_tokens - load_var c - load_field .top_p - load_var c - load_field .top_k - load_var c - load_field .stop_sequences - load_var c - load_field .response_modalities - call google.internal._gm_generation_config - store_var _6 - load_var2 2 5 - load_var2 6 1 - load_field .safety_settings - load_var c - load_field .request_body - load_const - call google.internal.gemini_build_body - store_var body - load_var c - call google.GoogleClient.resolved_base_url - store_var_load_var _16 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "https://generativelanguage.googleapis.com/v1beta" - store_var _16 - - L0: - load_type string - load_var _16 - call baml.String.from - store_var _23 - load_type string - load_var c - load_field .model - call baml.String.from - store_var _26 - load_var stream - call google.internal.gemini_method - store_var _30 - load_type string - load_var _30 - call baml.String.from - store_var _29 - load_var _23 - load_const "/models/" - bin_op + - load_var _26 - bin_op + - load_var _29 - bin_op + - load_var c - load_field .query_params - call google.internal._gm_apply_query - store_var url - load_const "application/json" - load_const "content-type" - load_type string - load_type string - alloc_map 1 - load_var c - load_field .headers - call google.internal._gm_apply_headers - store_var with_user - load_var c - call google.GoogleClient.resolved_api_key - store_var _38 - load_type string - load_type string - load_var with_user - load_const "x-goog-api-key" - load_var _38 - call baml.Map.set - pop 1 - load_const "POST" - load_var2 8 13 - load_var body - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function google.internal._vertex_anthropic_body(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> string { - load_var c - load_field .model - store_var _6 - load_var c - load_field .max_output_tokens - store_var_load_var _8 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const 8192 - store_var _8 - - L0: - load_var _8 - store_var _7 - load_var c - load_field .temperature - store_var _11 - load_var c - load_field .top_p - store_var _12 - load_var c - load_field .top_k - store_var _13 - load_var c - load_field .stop_sequences - store_var _14 - load_const "vertex-2023-10-16" - load_const null - load_const "anthropic_version" - load_const "model" - load_type string - load_type baml.json.json - alloc_map 2 - load_var c - load_field .request_body - call ai.wire.merge_request_body - store_var _15 - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var2 4 5 - load_var2 7 8 - load_var2 9 10 - load_const null - load_const null - load_var2 11 12 - init_instance anthropic.internal.AnthropicBodyParams .model, .max_tokens, .temperature, .top_p, .top_k, .stop_sequences, .thinking, .tool_choice, .request_body, .client_id - load_var2 2 3 - call anthropic.internal.anthropic_messages_body - return -} - -function google.internal._vertex_credentials(c: google.VertexClient) -> string | null { - load_var c - load_field .credentials_json - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var c - load_field .credentials_file - store_var _7 - load_var _7 - narrow_bind string, slot=3 - pop_jump_if_false L1 - jump L4 - - L1: - load_const "GOOGLE_APPLICATION_CREDENTIALS_CONTENT" - sys_op baml.env.get - store_var _25 - load_var _25 - narrow_bind string, slot=9 - pop_jump_if_false L2 - load_var _25 - store_var from_env - load_var from_env - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L2 - jump L3 - - L2: - load_const null - jump L7 - - L3: - load_var from_env - call google.internal._vertex_unwrap_json - jump L7 - - L4: - load_var _7 - store_var_load_var path - sys_op baml.fs.read - jump L5 - load_var e - throw_if_panic - load_type string - load_var path - call baml.String.from - store_var _16 - load_type baml.errors.Io | baml.errors.ParseError - load_var e - call baml.String.from - store_var _20 - load_type string - load_var _20 - call baml.String.from - store_var _19 - load_const "vertex" - load_const null - load_const "Vertex AI credentials file " - load_var _16 - bin_op + - load_const " could not be read: " - bin_op + - load_var _19 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L5: - call google.internal._vertex_unwrap_json - jump L7 - - L6: - load_var _3 - call google.internal._vertex_unwrap_json - - L7: - return -} - -function google.internal._vertex_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_var batch - load_const "vertex" - call google.internal._gm_decode_batch - return -} - -function google.internal._vertex_express_key(c: google.VertexClient) -> string | null { - load_var c - call google.VertexClient.resolved_api_key - return -} - -function google.internal._vertex_is_express(c: google.VertexClient) -> bool { - load_var c - call google.internal._vertex_express_key - load_const null - call baml.ops.equals_equals - unary_op ! - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var c - call google.internal._vertex_key_in_query - - L1: - return -} - -function google.internal._vertex_is_multi_region(location: string) -> bool { - load_var location - load_const "us" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var location - load_const "eu" - cmp_op == - - L1: - return -} - -function google.internal._vertex_key_in_query(c: google.VertexClient) -> bool { - load_var c - load_field .query_params - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_const "key" - load_var c - load_field .query_params - make_bound_method baml.Map.get - call_indirect - store_var _2 - jump L2 - - L1: - load_const null - store_var _2 - - L2: - load_var _2 - load_const null - call baml.ops.equals_equals - unary_op ! - return -} - -function google.internal._vertex_method(c: google.VertexClient, stream: bool) -> string { - load_var c - call google.internal._vertex_publisher - load_const "anthropic" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var stream - call google.internal.gemini_method - jump L4 - - L1: - load_var stream - pop_jump_if_false L2 - jump L3 - - L2: - load_const ":rawPredict" - jump L4 - - L3: - load_const ":streamRawPredict" - - L4: - return -} - -function google.internal._vertex_models_base(c: google.VertexClient) -> string { - load_var c - call google.VertexClient.resolved_base_url - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L10 - - L0: - load_var c - call google.internal._vertex_publisher - store_var publisher - load_var c - call google.internal.vertex_location - store_var location - load_var location - load_const "global" - cmp_op == - pop_jump_if_false L1 - jump L4 - - L1: - load_var location - call google.internal._vertex_is_multi_region - pop_jump_if_false L2 - jump L3 - - L2: - load_type string - load_var location - call baml.String.from - load_const "-aiplatform.googleapis.com" - bin_op + - store_var host - jump L5 - - L3: - load_type string - load_var location - call baml.String.from - store_var _13 - load_const "aiplatform." - load_var _13 - bin_op + - load_const ".rep.googleapis.com" - bin_op + - store_var host - jump L5 - - L4: - load_const "aiplatform.googleapis.com" - store_var host - - L5: - load_var c - call google.internal.vertex_project_id - store_var _20 - load_var _20 - narrow_bind string, slot=7 - pop_jump_if_false L6 - jump L9 - - L6: - load_var c - call google.internal._vertex_is_express - pop_jump_if_false L7 - jump L8 - - L7: - load_const "vertex" - load_const null - load_const "Could not resolve project_id for Vertex AI. Set the client's project_id option, the GOOGLE_CLOUD_PROJECT env var, or supply credentials that carry a project_id." - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L8: - load_type string - load_var publisher - call baml.String.from - store_var _43 - load_const "https://aiplatform.googleapis.com/v1/publishers/" - load_var _43 - bin_op + - load_const "/models" - bin_op + - jump L11 - - L9: - load_var _20 - store_var resolved - load_type string - load_var host - call baml.String.from - store_var _29 - load_type string - load_var resolved - call baml.String.from - store_var _32 - load_type string - load_var location - call baml.String.from - store_var _35 - load_type string - load_var publisher - call baml.String.from - store_var _38 - load_const "https://" - load_var _29 - bin_op + - load_const "/v1/projects/" - bin_op + - load_var _32 - bin_op + - load_const "/locations/" - bin_op + - load_var _35 - bin_op + - load_const "/publishers/" - bin_op + - load_var _38 - bin_op + - load_const "/models" - bin_op + - jump L11 - - L10: - load_var _3 - - L11: - return -} - -function google.internal._vertex_publisher(c: google.VertexClient) -> string { - load_var c - load_field .model - load_const "claude" - call baml.String.starts_with - pop_jump_if_false L0 - jump L1 - - L0: - load_const "google" - jump L2 - - L1: - load_const "anthropic" - - L2: - return -} - -function google.internal._vertex_request(c: google.VertexClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - load_var c - call google.internal._vertex_publisher - load_const "anthropic" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var c - load_field .temperature - load_var c - load_field .max_output_tokens - load_var c - load_field .top_p - load_var c - load_field .top_k - load_var c - load_field .stop_sequences - load_var c - load_field .response_modalities - call google.internal._gm_generation_config - store_var _8 - load_var2 2 5 - load_var2 6 1 - load_field .safety_settings - load_var c - load_field .request_body - load_const false - call google.internal.gemini_build_body - store_var body - jump L2 - - L1: - load_var2 1 2 - load_var stream - call google.internal._vertex_anthropic_body - store_var body - - L2: - load_var2 1 3 - call google.internal.vertex_url - store_var url - load_const "application/json" - load_const "content-type" - load_type string - load_type string - alloc_map 1 - load_var c - load_field .headers - call google.internal._gm_apply_headers - store_var with_user - load_var c - call google.internal._vertex_is_express - pop_jump_if_false L3 - jump L5 - - L3: - load_var c - call google.internal._vertex_credentials - store_var credentials - call google.internal._vertex_scope - store_var _27 - load_var2 9 12 - call google.internal.gcp_access_token - store_var token - jump L4 - load_var e - throw_if_panic - load_type baml.errors.AccessError | baml.errors.Io - load_var e - call baml.String.from - store_var _31 - load_type string - load_var _31 - call baml.String.from - store_var _30 - load_const "vertex" - load_const null - load_const "Vertex AI authentication failed: " - load_var _30 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L4: - load_type string - load_var token - call baml.String.from - store_var _36 - load_type string - load_type string - load_var with_user - load_const "authorization" - load_const "Bearer " - load_var _36 - bin_op + - call baml.Map.set - pop 1 - load_type string - load_type string - load_var with_user - load_const "x-goog-user-project" - call baml.Map.get - load_const null - call baml.ops.equals_equals - pop_jump_if_false L5 - load_var credentials - call google.internal.gcp_quota_project_id - store_var _47 - load_var _47 - narrow_bind string, slot=16 - pop_jump_if_false L5 - load_type string - load_type string - load_var with_user - load_const "x-goog-user-project" - load_var _47 - call baml.Map.set - pop 1 - - L5: - load_const "POST" - load_var2 7 8 - load_var body - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function google.internal._vertex_scope() -> string { - load_const "https://www.googleapis.com/auth/cloud-platform" - return -} - -function google.internal._vertex_unwrap_json(document: string) -> string { - load_var document - call baml.String.trim - store_var trimmed - load_var trimmed - load_const "\"" - call baml.String.starts_with - pop_jump_if_false L0 - jump L1 - - L0: - load_var document - jump L2 - - L1: - load_type string - load_var trimmed - call baml.json.from_string - jump L2 - load_var e - throw_if_panic - load_var document - - L2: - return -} - -function google.internal.gcp_access_token(credentials_json: string | null, scope: string) -> string { - load_var2 1 2 - sys_op ai.internal._gcp_access_token - return -} - -function google.internal.gcp_project_id(credentials_json: string | null) -> string | null { - load_var credentials_json - sys_op ai.internal._gcp_project_id - return -} - -function google.internal.gcp_quota_project_id(credentials_json: string | null) -> string | null { - load_var credentials_json - sys_op ai.internal._gcp_quota_project_id - return -} - -function google.internal.gemini_build_body(input: ai.ModelTurnInput, client_id: string, generation_config: google.internal.GmGenerationConfig | null, safety_settings: google.SafetySetting[] | null, request_body: baml.json.json | null, fetch_url: bool) -> string { - load_var fetch_url - load_const - cmp_op == - pop_jump_if_false L0 - load_const true - store_var fetch_url - - L0: - load_var input - load_field .prompt - store_var _9 - load_var input - load_field .output_type - call ai.wire.render_output_format - load_var _9 - call_indirect - load_var fetch_url - call google.internal.google_lower_prompt - store_var lowered - load_var lowered - load_field .contents - store_var contents - load_var input - load_field .journal - load_var client_id - call ai.wire.sanitize_for_client - call google.internal.google_lower_journal - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L1: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_type google.internal.GmContent - load_var2 9 11 - call baml.Array.push - pop 1 - jump L1 - - L3: - load_const null - store_var system - load_type google.internal.GmContent - load_var contents - load_const 0 - call baml.Array.at - load_const null - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_type google.internal.GmContent - load_var contents - load_const 0 - call baml.Array.at - load_field .0 - jump L6 - - L5: - load_const null - - L6: - store_var_load_var _29 - load_const null - cmp_op == - pop_jump_if_false L7 - load_const "" - store_var _29 - - L7: - load_var _29 - load_const "user" - cmp_op != - jump_if_false L8 - pop 1 - load_var lowered - load_field .system_parts - container_len - store_var _40 - load_var _40 - load_const 0 - cmp_int_op > - - L8: - pop_jump_if_false L9 - jump L10 - - L9: - load_var lowered - load_field .system_parts - container_len - store_var _48 - load_var _48 - load_const 0 - cmp_int_op > - pop_jump_if_false L11 - load_const null - load_var lowered - load_field .system_parts - init_instance google.internal.GmContent .role, .parts - store_var system - jump L11 - - L10: - load_type google.internal.GmContent - load_const "user" - load_var lowered - load_field .system_parts - init_instance google.internal.GmContent .role, .parts - load_type google.internal.GmContent - alloc_array 1 - load_var contents - call baml.Array.concat - store_var contents - - L11: - load_var contents - container_len - store_var _52 - load_var _52 - load_const 0 - cmp_int_op == - pop_jump_if_false L12 - jump L17 - - L12: - load_const null - store_var tools - load_const null - store_var tool_config - load_var input - load_field .toolbox - call ai.tools.Toolbox.is_empty - unary_op ! - pop_jump_if_false L16 - load_type google.internal.GmFunctionDeclaration - alloc_array 0 - store_var declarations - load_var input - load_field .toolbox - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _62 - - L13: - load_var _62 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _63 - load_var _63 - is_type baml.iter.Done - pop_jump_if_false L14 - jump L15 - - L14: - load_var _63 - store_var t - load_type google.internal.GmFunctionDeclaration - load_var2 19 22 - load_field .name - load_var t - load_field .description - load_var t - load_field .input_schema - init_instance google.internal.GmFunctionDeclaration .name, .description, .parametersJsonSchema - call baml.Array.push - pop 1 - jump L13 - - L15: - load_var declarations - init_instance google.internal.GmTool .functionDeclarations - load_type google.internal.GmTool - alloc_array 1 - store_var tools - load_const "AUTO" - init_instance google.internal.GmFunctionCallingConfig .mode - init_instance google.internal.GmToolConfig .functionCallingConfig - store_var tool_config - - L16: - load_type google.internal.GmGenerateContentRequest - load_var2 9 12 - load_var2 17 18 - load_var2 3 4 - init_instance google.internal.GmGenerateContentRequest .contents, .systemInstruction, .tools, .toolConfig, .generationConfig, .safetySettings - call baml.json.to_json - load_const false - call google.internal._gm_strip_nulls - load_var request_body - call ai.wire.merge_request_body - call baml.json.stringify - return - - L17: - load_const "google" - load_const null - load_const "the rendered prompt and journal produced no message content" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function google.internal.gemini_invoke(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var input - load_field .journal - call ai.Journal.entries - container_len - store_var seq - load_var2 1 2 - call google.internal.google_render - store_var req - load_type google.internal.GmResponse - load_var req - load_const "google" - call ai.wire.send_as - load_var seq - load_const - call google.internal.google_parse - return -} - -function google.internal.gemini_invoke_stream(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var2 1 2 - load_const true - call google.internal._google_request - load_const "google" - call google.internal._gm_open_sse - load_const google.internal._google_decode_batch - load_const "google" - call ai.stream.TurnStream.from_sse - return -} - -function google.internal.gemini_method(stream: bool) -> string { - load_var stream - pop_jump_if_false L0 - jump L1 - - L0: - load_const ":generateContent" - jump L2 - - L1: - load_const ":streamGenerateContent?alt=sse" - - L2: - return -} - -function google.internal.google_lower_journal(j: ai.Journal) -> google.internal.GmContent[] { - load_type google.internal.GmContent - alloc_array 0 - store_var contents - load_type google.internal.GmPart - alloc_array 0 - store_var pending - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L15 - - L1: - load_var _6 - store_var e - load_var e - store_var _10 - load_var _10 - narrow_bind ai.events.UserMessage, slot=7 - pop_jump_if_false L2 - jump L13 - - L2: - load_var e - store_var _24 - load_var _24 - narrow_bind ai.events.AssistantMessage, slot=11 - pop_jump_if_false L3 - jump L6 - - L3: - load_var e - store_var _61 - load_var _61 - narrow_bind ai.events.ToolCompleted, slot=26 - pop_jump_if_false L4 - jump L5 - - L4: - load_var e - store_var _75 - load_var _75 - narrow_bind ai.events.ToolFailed, slot=30 - pop_jump_if_false L0 - load_var _75 - store_var f - load_type string - load_type unknown - alloc_map 0 - store_var response - load_type string - load_type unknown - load_var response - load_const "error" - load_var f - load_field .message - call baml.Map.set - pop 1 - load_var2 1 31 - load_field .id - call google.internal._gm_tool_name_for - load_var response - init_instance google.internal.GmFunctionResponse .name, .response - call google.internal.GmPart.of_function_response - store_var _83 - load_type google.internal.GmPart - load_var2 3 33 - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _61 - store_var c - load_type string - load_type unknown - alloc_map 0 - store_var response - load_type string - load_type unknown - load_var response - load_const "result" - load_var c - load_field .output - call baml.Map.set - pop 1 - load_var2 1 27 - load_field .id - call google.internal._gm_tool_name_for - load_var response - init_instance google.internal.GmFunctionResponse .name, .response - call google.internal.GmPart.of_function_response - store_var _69 - load_type google.internal.GmPart - load_var2 3 29 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var _24 - store_var a - load_var pending - container_len - store_var _27 - load_var _27 - load_const 0 - cmp_int_op > - pop_jump_if_false L7 - load_type google.internal.GmContent - load_var contents - load_const "user" - load_var pending - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - load_type google.internal.GmPart - alloc_array 0 - store_var pending - - L7: - load_type google.internal.GmPart - alloc_array 0 - store_var parts - load_var a - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _34 - - L8: - load_var _34 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _35 - load_var _35 - is_type baml.iter.Done - pop_jump_if_false L9 - jump L12 - - L9: - load_var _35 - store_var b - load_var b - store_var _39 - load_var _39 - narrow_bind ai.content.Text, slot=18 - pop_jump_if_false L10 - jump L11 - - L10: - load_var b - store_var _45 - load_var _45 - narrow_bind ai.content.ToolUse, slot=20 - pop_jump_if_false L8 - load_var _45 - store_var_load_var use - load_field .name - load_var use - load_field .args - init_instance google.internal.GmFunctionCall .name, .args - store_var _49 - load_var use - load_field .id - call google.internal._gm_call_id_signature - store_var _52 - load_var2 23 24 - call google.internal.GmPart.of_function_call - store_var _48 - load_type google.internal.GmPart - load_var2 14 22 - call baml.Array.push - pop 1 - jump L8 - - L11: - load_var _39 - load_field .text - call google.internal.GmPart.of_text - store_var _42 - load_type google.internal.GmPart - load_var2 14 19 - call baml.Array.push - pop 1 - jump L8 - - L12: - load_var parts - container_len - store_var _56 - load_var _56 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - load_type google.internal.GmContent - load_var contents - load_const "model" - load_var parts - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - jump L0 - - L13: - load_var _10 - store_var u - load_var pending - container_len - store_var _13 - load_var _13 - load_const 0 - cmp_int_op > - pop_jump_if_false L14 - load_type google.internal.GmContent - load_var contents - load_const "user" - load_var pending - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - load_type google.internal.GmPart - alloc_array 0 - store_var pending - - L14: - load_var u - load_field .content - call google.internal.GmPart.of_text - store_var _21 - load_type google.internal.GmContent - load_var contents - load_const "user" - load_var _21 - load_type google.internal.GmPart - alloc_array 1 - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - jump L0 - - L15: - load_var pending - container_len - store_var _90 - load_var _90 - load_const 0 - cmp_int_op > - pop_jump_if_false L16 - load_type google.internal.GmContent - load_var contents - load_const "user" - load_var pending - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - - L16: - load_var contents - return -} - -function google.internal.google_lower_prompt(prompt: ai.Prompt, fetch_url: bool) -> google.internal.GooglePrompt { - load_var fetch_url - load_const - cmp_op == - pop_jump_if_false L0 - load_const true - store_var fetch_url - - L0: - load_type google.internal.GmPart - alloc_array 0 - store_var system_parts - load_type google.internal.GmContent - alloc_array 0 - store_var contents - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L1: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L10 - - L2: - load_var _8 - store_var_load_var message - load_var fetch_url - call google.internal._gm_prompt_parts - store_var parts - load_var message - load_field .role - load_const "system" - cmp_op == - pop_jump_if_false L3 - jump L7 - - L3: - load_var message - load_field .role - load_const "assistant" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_const "user" - store_var role - jump L6 - - L5: - load_const "model" - store_var role - - L6: - load_type google.internal.GmContent - load_var2 4 11 - load_var parts - init_instance google.internal.GmContent .role, .parts - call baml.Array.push - pop 1 - jump L1 - - L7: - load_var parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L8: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L9 - jump L1 - - L9: - load_type google.internal.GmPart - load_var2 3 10 - call baml.Array.push - pop 1 - jump L8 - - L10: - load_var2 3 4 - init_instance google.internal.GooglePrompt .system_parts, .contents - return -} - -function google.internal.google_parse(resp: google.internal.GmResponse, seq: int, provider: string) -> ai.ModelTurn { - load_var provider - load_const - cmp_op == - pop_jump_if_false L0 - load_const "google" - store_var provider - - L0: - load_var resp - load_field .error - store_var _6 - load_var _6 - narrow_bind google.internal.GmError, slot=4 - pop_jump_if_false L1 - jump L44 - - L1: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_const false - store_var has_call - load_const 0 - store_var call_index - load_var resp - load_field .candidates - load_const null - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_const 0 - load_var resp - load_field .candidates - make_bound_method baml.Array.at - call_indirect - store_var cand - jump L4 - - L3: - load_const null - store_var cand - - L4: - load_var cand - load_const null - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_var cand - load_field .1 - jump L7 - - L6: - load_const null - - L7: - store_var_load_var _28 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const "" - store_var _28 - - L8: - load_var _28 - store_var finish - load_var cand - load_const null - cmp_op == - pop_jump_if_false L9 - jump L12 - - L9: - load_var cand - load_field .0 - load_const null - cmp_op == - pop_jump_if_false L10 - jump L12 - - L10: - load_var cand - load_const null - cmp_op == - pop_jump_if_false L11 - jump L12 - - L11: - load_var cand - load_field .0 - load_field .1 - jump L13 - - L12: - load_const null - - L13: - store_var_load_var _35 - load_const null - cmp_op == - pop_jump_if_false L14 - load_type google.internal.GmRespPart - alloc_array 0 - store_var _35 - - L14: - load_var _35 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _48 - - L15: - load_var _48 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _49 - load_var _49 - is_type baml.iter.Done - pop_jump_if_false L16 - jump L27 - - L16: - load_var _49 - store_var_load_var p - load_field .functionCall - store_var _54 - load_var _54 - narrow_bind google.internal.GmRespFunctionCall, slot=19 - pop_jump_if_false L17 - jump L25 - - L17: - load_var p - load_field .inlineData - store_var _76 - load_var _76 - narrow_bind google.internal.GmRespInlineData, slot=26 - pop_jump_if_false L18 - jump L22 - - L18: - load_var p - load_field .text - store_var _90 - load_var _90 - narrow_bind string, slot=32 - pop_jump_if_false L15 - load_var _90 - store_var t - load_var p - load_field .thought - store_var_load_var _93 - load_const null - cmp_op == - pop_jump_if_false L19 - load_const false - store_var _93 - - L19: - load_var _93 - pop_jump_if_false L20 - jump L21 - - L20: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 9 33 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L15 - - L21: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 9 33 - init_instance ai.content.Reasoning .summary - call baml.Array.push - pop 1 - jump L15 - - L22: - load_var _76 - store_var_load_var inline - load_field .mimeType - store_var_load_var _81 - load_const null - cmp_op == - pop_jump_if_false L23 - load_const "image/png" - store_var _81 - - L23: - load_var _81 - store_var _80 - load_var inline - load_field .data - store_var_load_var _85 - load_const null - cmp_op == - pop_jump_if_false L24 - load_const "" - store_var _85 - - L24: - load_var2 29 31 - call google.internal._gm_output_media - store_var _79 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 9 28 - call baml.Array.push - pop 1 - jump L15 - - L25: - load_var _54 - store_var fc - load_type string - load_type unknown - alloc_map 0 - store_var args - load_var fc - load_field .args - store_var _58 - load_var _58 - narrow_bind map, slot=22 - pop_jump_if_false L26 - load_var _58 - store_var args - - L26: - load_type int - load_var seq - call baml.String.from - store_var _66 - load_type int - load_var call_index - call baml.String.from - store_var _68 - load_const "call_" - load_var _66 - bin_op + - load_const "_" - bin_op + - load_var _68 - bin_op + - load_var p - load_field .thoughtSignature - call google.internal._gm_encode_call_id - store_var _62 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 9 23 - load_var fc - load_field .name - load_var args - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - load_var call_index - load_const 1 - add_int - store_var call_index - load_const true - store_var has_call - jump L15 - - L27: - load_var resp - load_field .promptFeedback - load_const null - cmp_op == - pop_jump_if_false L28 - jump L29 - - L28: - load_var resp - load_field .promptFeedback - load_field .0 - jump L30 - - L29: - load_const null - - L30: - load_const null - call baml.ops.equals_equals - unary_op ! - store_var blocked - load_var content - container_len - store_var _113 - load_var _113 - load_const 0 - cmp_int_op == - jump_if_false L31 - pop 1 - load_var finish - load_const "" - cmp_op == - - L31: - jump_if_false L32 - pop 1 - load_var blocked - unary_op ! - - L32: - pop_jump_if_false L33 - jump L43 - - L33: - load_var has_call - pop_jump_if_false L34 - jump L41 - - L34: - load_var finish - load_const "MAX_TOKENS" - cmp_op == - pop_jump_if_false L35 - jump L40 - - L35: - load_var blocked - jump_if_false L36 - jump L37 - - L36: - pop 1 - load_var finish - call google.internal._gm_is_blocked - - L37: - pop_jump_if_false L38 - jump L39 - - L38: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - jump L42 - - L39: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L42 - - L40: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L42 - - L41: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - - L42: - store_var _128 - load_var resp - load_field .usageMetadata - call google.internal._gm_usage - store_var _129 - load_var2 9 38 - load_var _129 - init_instance ai.ModelTurn .content, .stop_reason, .usage - return - - L43: - load_type google.internal.GmResponse - load_var resp - call baml.json.to_json - call baml.json.stringify - store_var _117 - load_var2 3 37 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L44: - load_var _6 - store_var_load_var err - load_field .code - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L45 - load_const 0 - store_var _10 - - L45: - load_var _10 - store_var _9 - load_var err - load_field .message - store_var_load_var _14 - load_const null - cmp_op == - pop_jump_if_false L46 - load_type google.internal.GmResponse - load_var resp - call baml.json.to_json - call baml.json.stringify - store_var _14 - - L46: - load_var2 3 6 - load_var _14 - load_const - call ai.errors.classify_http - throw -} - -function google.internal.google_render(c: google.GoogleClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var2 1 2 - load_const false - call google.internal._google_request - return -} - -function google.internal.vertex_invoke(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call google.internal.vertex_render - store_var req - load_var c - call google.internal._vertex_publisher - load_const "anthropic" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var input - load_field .journal - call ai.Journal.entries - container_len - store_var seq - load_type google.internal.GmResponse - load_var req - load_const "vertex" - call ai.wire.send_as - load_var seq - load_const "vertex" - call google.internal.google_parse - jump L2 - - L1: - load_type anthropic.internal.AnthropicResponse - load_var req - load_const "vertex" - call ai.wire.send_as - call anthropic.internal.anthropic_parse - - L2: - return -} - -function google.internal.vertex_invoke_stream(c: google.VertexClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var ?4 - make_cell - store_var ?4 - load_var2 1 2 - load_const true - call google.internal._vertex_request - load_const "vertex" - call google.internal._gm_open_sse - store_var sse - load_var c - call google.internal._vertex_publisher - load_const "anthropic" - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var sse - load_const google.internal._vertex_decode_batch - load_const "vertex" - call ai.stream.TurnStream.from_sse - jump L2 - - L1: - call anthropic.internal.AnthStreamState.new - store_deref ?4 - load_var2 3 4 - make_closure ., 1 - load_const "vertex" - call ai.stream.TurnStream.from_sse - - L2: - return -} - -function google.internal.vertex_location(c: google.VertexClient) -> string { - load_var c - load_field .location - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L5 - - L0: - load_const "GOOGLE_CLOUD_LOCATION" - sys_op baml.env.get - store_var _6 - load_var _6 - narrow_bind string, slot=3 - pop_jump_if_false L1 - load_var _6 - store_var from_env - load_var from_env - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L1 - jump L4 - - L1: - load_const "GOOGLE_CLOUD_REGION" - sys_op baml.env.get - store_var _11 - load_var _11 - narrow_bind string, slot=5 - pop_jump_if_false L2 - load_var _11 - store_var from_region - load_var from_region - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L2 - jump L3 - - L2: - load_const "global" - jump L6 - - L3: - load_var from_region - call baml.String.trim - jump L6 - - L4: - load_var from_env - call baml.String.trim - jump L6 - - L5: - load_var _3 - - L6: - return -} - -function google.internal.vertex_project_id(c: google.VertexClient) -> string | null { - load_var c - load_field .project_id - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L7 - - L0: - load_var c - call google.internal._vertex_is_express - pop_jump_if_false L1 - jump L6 - - L1: - load_const "GOOGLE_CLOUD_PROJECT" - sys_op baml.env.get - store_var _7 - load_var _7 - narrow_bind string, slot=3 - pop_jump_if_false L2 - load_var _7 - store_var from_env - load_var from_env - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L2 - jump L5 - - L2: - load_const "GCLOUD_PROJECT" - sys_op baml.env.get - store_var _12 - load_var _12 - narrow_bind string, slot=5 - pop_jump_if_false L3 - load_var _12 - store_var legacy - load_var legacy - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L3 - jump L4 - - L3: - load_var c - call google.internal._vertex_credentials - call google.internal.gcp_project_id - jump L8 - - L4: - load_var legacy - call baml.String.trim - jump L8 - - L5: - load_var from_env - call baml.String.trim - jump L8 - - L6: - load_const null - jump L8 - - L7: - load_var _3 - - L8: - return -} - -function google.internal.vertex_render(c: google.VertexClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var2 1 2 - load_const false - call google.internal._vertex_request - return -} - -function google.internal.vertex_url(c: google.VertexClient, stream: bool) -> string { - load_var c - call google.internal._vertex_models_base - store_var _8 - load_type string - load_var _8 - call baml.String.from - store_var _7 - load_type string - load_var c - load_field .model - call baml.String.from - store_var _10 - load_var2 1 2 - call google.internal._vertex_method - store_var _14 - load_type string - load_var _14 - call baml.String.from - store_var _13 - load_var _7 - load_const "/" - bin_op + - load_var _10 - bin_op + - load_var _13 - bin_op + - load_var c - load_field .query_params - call google.internal._gm_apply_query - store_var with_params - load_var c - call google.internal._vertex_express_key - store_var _18 - load_var _18 - narrow_bind string, slot=9 - pop_jump_if_false L0 - jump L1 - - L0: - load_var with_params - jump L2 - - L1: - load_var2 3 9 - load_const "key" - load_type string - load_type string - alloc_map 1 - call google.internal._gm_apply_query - - L2: - return -} - -function openai.AzureClient.ai.Client.id(self: openai.AzureClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "azure/" - load_var _2 - bin_op + - return -} - -function openai.AzureClient.ai.Client.invoke(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - call openai.AzureClient.compat - store_var _4 - load_var self - call openai.AzureClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.AzureClient.ai.stream.StreamingClient.invoke_stream(self: openai.AzureClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var self - call openai.AzureClient.compat - store_var _4 - load_var self - call openai.AzureClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.AzureClient.compat(self: openai.AzureClient) -> openai.internal.ChatCompat { - load_type string - load_type string - alloc_map 0 - store_var query - load_var self - load_field .api_version - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - load_type string - load_type string - load_var query - load_const "api-version" - load_var _4 - call baml.Map.set - pop 1 - - L0: - load_var self - call openai.AzureClient.resolved_base_url - store_var _10 - load_const "azure" - load_var _10 - load_const - load_const openai.internal.ChatAuth.ApiKeyHeader - alloc_variant openai.internal.ChatAuth - load_const "AZURE_OPENAI_API_KEY" - load_const true - load_const - load_const - load_const - load_const - load_const 4096 - load_const - load_var query - call openai.internal.ChatCompat.new - return -} - -function openai.AzureClient.new(model: string, resource_name: string | null, deployment_id: string | null, api_version: string | null, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.AzureClient { - load_var resource_name - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var resource_name - - L0: - load_var deployment_id - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var deployment_id - - L1: - load_var api_version - load_const - cmp_op == - pop_jump_if_false L2 - load_const "2024-10-21" - store_var api_version - - L2: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var base_url - - L3: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var api_key - - L4: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var request_body - - L5: - load_var headers - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var headers - - L6: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var query_params - - L7: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var temperature - - L8: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var max_tokens - - L9: - load_var max_completion_tokens - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var max_completion_tokens - - L10: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var top_p - - L11: - load_var stop - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var stop - - L12: - load_var seed - load_const - cmp_op == - pop_jump_if_false L13 - load_const null - store_var seed - - L13: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var2 13 14 - load_var seed - init_instance openai.AzureClient .model, .resource_name, .deployment_id, .api_version, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed - return -} - -function openai.AzureClient.params(self: openai.AzureClient) -> openai.internal.ChatParams { - load_var self - load_field .model - store_var _2 - load_var self - call openai.AzureClient.resolved_api_key - store_var _3 - load_var2 2 3 - load_var self - load_field .temperature - load_var self - load_field .max_tokens - load_var self - load_field .max_completion_tokens - load_var self - load_field .top_p - load_var self - load_field .stop - load_var self - load_field .seed - load_var self - load_field .headers - load_var self - load_field .query_params - load_var self - load_field .request_body - call openai.internal.ChatParams.new - return -} - -function openai.AzureClient.resolved_api_key(self: openai.AzureClient) -> string | null { - load_var self - load_field .api_key - load_const "AZURE_OPENAI_API_KEY" - call ai.wire.resolve_credential - return -} - -function openai.AzureClient.resolved_base_url(self: openai.AzureClient) -> string { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L8 - - L0: - load_var self - call openai.AzureClient.resolved_deployment_id - store_var deployment - load_var self - load_field .resource_name - store_var _15 - load_var _15 - narrow_bind string, slot=5 - pop_jump_if_false L1 - jump L7 - - L1: - load_const null - load_const "AZURE_OPENAI_ENDPOINT" - call ai.wire.resolve_credential - store_var _26 - load_var _26 - narrow_bind string, slot=8 - pop_jump_if_false L2 - jump L3 - - L2: - load_const "openai.AzureClient needs a deployment endpoint: set base_url, or resource_name, or the AZURE_OPENAI_ENDPOINT environment variable" - call openai.internal._azure_reject - throw - - L3: - load_var _26 - store_var endpoint - load_var endpoint - load_const "/" - call baml.String.ends_with - pop_jump_if_false L4 - jump L5 - - L4: - load_var endpoint - store_var origin - jump L6 - - L5: - load_var endpoint - call baml.String.length - store_var _31 - load_var endpoint - load_const 0 - load_var _31 - load_const 1 - sub_int - call baml.String.slice - store_var origin - - L6: - load_type string - load_var origin - call baml.String.from - store_var _33 - load_type string - load_var deployment - call baml.String.from - store_var _36 - load_var _33 - load_const "/openai/deployments/" - bin_op + - load_var _36 - bin_op + - jump L12 - - L7: - load_type string - load_var _15 - call baml.String.from - store_var _19 - load_type string - load_var deployment - call baml.String.from - store_var _22 - load_const "https://" - load_var _19 - bin_op + - load_const ".openai.azure.com/openai/deployments/" - bin_op + - load_var _22 - bin_op + - jump L12 - - L8: - load_var _4 - store_var explicit - load_var self - load_field .resource_name - load_const null - call baml.ops.equals_equals - unary_op ! - jump_if_false L9 - jump L10 - - L9: - pop 1 - load_var self - load_field .deployment_id - load_const null - call baml.ops.equals_equals - unary_op ! - - L10: - pop_jump_if_false L11 - jump L13 - - L11: - load_var explicit - - L12: - return - - L13: - load_const "openai.AzureClient takes base_url OR resource_name/deployment_id, not both" - call openai.internal._azure_reject - throw -} - -function openai.AzureClient.resolved_deployment_id(self: openai.AzureClient) -> string { - load_var self - load_field .deployment_id - store_var_load_var _2 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var self - load_field .model - store_var _2 - - L0: - load_var _2 - return -} - -function openai.ChatClient.ai.Client.id(self: openai.ChatClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "openai-chat/" - load_var _2 - bin_op + - return -} - -function openai.ChatClient.ai.Client.invoke(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - call openai.ChatClient.compat - store_var _4 - load_var self - call openai.ChatClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.ChatClient.ai.stream.StreamingClient.invoke_stream(self: openai.ChatClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var self - call openai.ChatClient.compat - store_var _4 - load_var self - call openai.ChatClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.ChatClient.compat(self: openai.ChatClient) -> openai.internal.ChatCompat { - load_var self - call openai.ChatClient.resolved_base_url - store_var _2 - load_const "openai-chat" - load_var _2 - load_const - load_const - load_const "OPENAI_API_KEY" - load_const true - load_const - load_const - load_const true - load_const - load_const - load_const - load_const - call openai.internal.ChatCompat.new - return -} - -function openai.ChatClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.ChatClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "gpt-4o-mini" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var request_body - - L3: - load_var headers - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var headers - - L4: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var query_params - - L5: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var temperature - - L6: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var max_tokens - - L7: - load_var max_completion_tokens - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var max_completion_tokens - - L8: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var top_p - - L9: - load_var stop - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var stop - - L10: - load_var seed - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var seed - - L11: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - init_instance openai.ChatClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed - return -} - -function openai.ChatClient.params(self: openai.ChatClient) -> openai.internal.ChatParams { - load_var self - load_field .model - store_var _2 - load_var self - call openai.ChatClient.resolved_api_key - store_var _3 - load_var2 2 3 - load_var self - load_field .temperature - load_var self - load_field .max_tokens - load_var self - load_field .max_completion_tokens - load_var self - load_field .top_p - load_var self - load_field .stop - load_var self - load_field .seed - load_var self - load_field .headers - load_var self - load_field .query_params - load_var self - load_field .request_body - call openai.internal.ChatParams.new - return -} - -function openai.ChatClient.resolved_api_key(self: openai.ChatClient) -> string | null { - load_var self - load_field .api_key - load_const "OPENAI_API_KEY" - call ai.wire.resolve_credential - return -} - -function openai.ChatClient.resolved_base_url(self: openai.ChatClient) -> string { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - store_var_load_var _2 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "https://api.openai.com/v1" - store_var _2 - - L0: - load_var _2 - return -} - -function openai.GenericClient.ai.Client.id(self: openai.GenericClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "openai-generic/" - load_var _2 - bin_op + - return -} - -function openai.GenericClient.ai.Client.invoke(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - call openai.GenericClient.compat - store_var _4 - load_var self - call openai.GenericClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.GenericClient.ai.stream.StreamingClient.invoke_stream(self: openai.GenericClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var self - call openai.GenericClient.compat - store_var _4 - load_var self - call openai.GenericClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.GenericClient.compat(self: openai.GenericClient) -> openai.internal.ChatCompat { - load_var self - call openai.GenericClient.resolved_base_url - store_var _2 - load_const "openai-generic" - load_var _2 - load_const - load_const - load_const - load_const - load_const true - load_const - load_const - load_const - load_const - load_const - load_const - call openai.internal.ChatCompat.new - return -} - -function openai.GenericClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.GenericClient { - load_var base_url - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var base_url - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var request_body - - L2: - load_var headers - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var headers - - L3: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var query_params - - L4: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var temperature - - L5: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var max_tokens - - L6: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var top_p - - L7: - load_var stop - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var stop - - L8: - load_var seed - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var seed - - L9: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var seed - init_instance openai.GenericClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed - return -} - -function openai.GenericClient.params(self: openai.GenericClient) -> openai.internal.ChatParams { - load_var self - load_field .model - store_var _2 - load_var self - call openai.GenericClient.resolved_api_key - store_var _3 - load_var2 2 3 - load_var self - load_field .temperature - load_var self - load_field .max_tokens - load_const - load_var self - load_field .top_p - load_var self - load_field .stop - load_var self - load_field .seed - load_var self - load_field .headers - load_var self - load_field .query_params - load_var self - load_field .request_body - call openai.internal.ChatParams.new - return -} - -function openai.GenericClient.resolved_api_key(self: openai.GenericClient) -> string | null { - load_var self - load_field .api_key - load_const null - call ai.wire.resolve_credential - return -} - -function openai.GenericClient.resolved_base_url(self: openai.GenericClient) -> string { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .base_url - load_const null - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "openai-generic" - load_const "openai.GenericClient requires base_url (a literal or env.NAME naming a set variable): the endpoint of the OpenAI-compatible server, e.g. \"http://localhost:8000/v1\". Checked: " - load_var _8 - bin_op + - call openai.internal._reject - throw - - L1: - load_var _4 - return -} - -function openai.ImageClient.ai.Client.id(self: openai.ImageClient) -> string { - load_var self - call openai.internal._oai_images_client_id - return -} - -function openai.ImageClient.ai.Client.invoke(self: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call openai.internal.images_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.ImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, quality: string | null, background: string | null, output_format: string | null, output_compression: int | null, moderation: string | null, style: string | null, user: string | null, response_format: string | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ImageClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "gpt-image-1" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var n - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var n - - L3: - load_var size - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var size - - L4: - load_var quality - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var quality - - L5: - load_var background - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var background - - L6: - load_var output_format - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var output_format - - L7: - load_var output_compression - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var output_compression - - L8: - load_var moderation - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var moderation - - L9: - load_var style - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var style - - L10: - load_var user - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var user - - L11: - load_var response_format - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var response_format - - L12: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L13 - load_const null - store_var request_body - - L13: - load_var headers - load_const - cmp_op == - pop_jump_if_false L14 - load_const null - store_var headers - - L14: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L15 - load_const null - store_var query_params - - L15: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var2 13 14 - load_var2 15 16 - init_instance openai.ImageClient .model, .api_key, .base_url, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format, .request_body, .headers, .query_params - return -} - -function openai.ImageClient.resolved_api_key(self: openai.ImageClient) -> string { - load_var self - load_field .api_key - load_const "OPENAI_API_KEY" - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .api_key - load_const "OPENAI_API_KEY" - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "openai-images" - load_const null - load_const "no OpenAI API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — " - load_var _8 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L1: - load_var _4 - return -} - -function openai.ImageClient.resolved_base_url(self: openai.ImageClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function openai.OllamaClient.ai.Client.id(self: openai.OllamaClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "ollama/" - load_var _2 - bin_op + - return -} - -function openai.OllamaClient.ai.Client.invoke(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - call openai.OllamaClient.compat - store_var _4 - load_var self - call openai.OllamaClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.OllamaClient.ai.stream.StreamingClient.invoke_stream(self: openai.OllamaClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var self - call openai.OllamaClient.compat - store_var _4 - load_var self - call openai.OllamaClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.OllamaClient.compat(self: openai.OllamaClient) -> openai.internal.ChatCompat { - load_var self - call openai.OllamaClient.resolved_base_url - store_var _2 - load_const "ollama" - load_var _2 - load_const - load_const - load_const - load_const - load_const true - load_const true - load_const - load_const - load_const - load_const - load_const - call openai.internal.ChatCompat.new - return -} - -function openai.OllamaClient.new(model: string, base_url: string | baml.env.Ref | null, api_key: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OllamaClient { - load_var base_url - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var base_url - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var request_body - - L2: - load_var headers - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var headers - - L3: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var query_params - - L4: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var temperature - - L5: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var max_tokens - - L6: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var top_p - - L7: - load_var stop - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var stop - - L8: - load_var seed - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var seed - - L9: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var seed - init_instance openai.OllamaClient .model, .base_url, .api_key, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed - return -} - -function openai.OllamaClient.params(self: openai.OllamaClient) -> openai.internal.ChatParams { - load_var self - load_field .model - store_var _2 - load_var self - call openai.OllamaClient.resolved_api_key - store_var _3 - load_var2 2 3 - load_var self - load_field .temperature - load_var self - load_field .max_tokens - load_const - load_var self - load_field .top_p - load_var self - load_field .stop - load_var self - load_field .seed - load_var self - load_field .headers - load_var self - load_field .query_params - load_var self - load_field .request_body - call openai.internal.ChatParams.new - return -} - -function openai.OllamaClient.resolved_api_key(self: openai.OllamaClient) -> string | null { - load_var self - load_field .api_key - load_const null - call ai.wire.resolve_credential - return -} - -function openai.OllamaClient.resolved_base_url(self: openai.OllamaClient) -> string { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - store_var_load_var _2 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "http://localhost:11434/v1" - store_var _2 - - L0: - load_var _2 - return -} - -function openai.OpenRouterClient.ai.Client.id(self: openai.OpenRouterClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "openrouter/" - load_var _2 - bin_op + - return -} - -function openai.OpenRouterClient.ai.Client.invoke(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var self - call openai.OpenRouterClient.compat - store_var _4 - load_var self - call openai.OpenRouterClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.OpenRouterClient.ai.stream.StreamingClient.invoke_stream(self: openai.OpenRouterClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var self - call openai.OpenRouterClient.compat - store_var _4 - load_var self - call openai.OpenRouterClient.params - store_var _5 - load_var2 4 5 - load_var input - call openai.internal.chat_invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.OpenRouterClient.compat(self: openai.OpenRouterClient) -> openai.internal.ChatCompat { - load_var self - call openai.OpenRouterClient.resolved_base_url - store_var _2 - load_const "openrouter" - load_var _2 - load_const - load_const - load_const "OPENROUTER_API_KEY" - load_const true - load_const - load_const - load_const - load_const - load_const - load_const - load_const - call openai.internal.ChatCompat.new - return -} - -function openai.OpenRouterClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null, temperature: float | null, max_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null) -> openai.OpenRouterClient { - load_var api_key - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var api_key - - L0: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var base_url - - L1: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var request_body - - L2: - load_var headers - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var headers - - L3: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var query_params - - L4: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var temperature - - L5: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var max_tokens - - L6: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var top_p - - L7: - load_var stop - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var stop - - L8: - load_var seed - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var seed - - L9: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var seed - init_instance openai.OpenRouterClient .model, .api_key, .base_url, .request_body, .headers, .query_params, .temperature, .max_tokens, .top_p, .stop, .seed - return -} - -function openai.OpenRouterClient.params(self: openai.OpenRouterClient) -> openai.internal.ChatParams { - load_var self - load_field .model - store_var _2 - load_var self - call openai.OpenRouterClient.resolved_api_key - store_var _3 - load_var2 2 3 - load_var self - load_field .temperature - load_var self - load_field .max_tokens - load_const - load_var self - load_field .top_p - load_var self - load_field .stop - load_var self - load_field .seed - load_var self - load_field .headers - load_var self - load_field .query_params - load_var self - load_field .request_body - call openai.internal.ChatParams.new - return -} - -function openai.OpenRouterClient.resolved_api_key(self: openai.OpenRouterClient) -> string | null { - load_var self - load_field .api_key - load_const "OPENROUTER_API_KEY" - call ai.wire.resolve_credential - return -} - -function openai.OpenRouterClient.resolved_base_url(self: openai.OpenRouterClient) -> string { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - store_var_load_var _2 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "https://openrouter.ai/api/v1" - store_var _2 - - L0: - load_var _2 - return -} - -function openai.ResponsesClient.ai.Client.id(self: openai.ResponsesClient) -> string { - load_type string - load_var self - load_field .model - call baml.String.from - store_var _2 - load_const "openai/" - load_var _2 - bin_op + - return -} - -function openai.ResponsesClient.ai.Client.invoke(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call openai.internal.invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.ResponsesClient.ai.stream.StreamingClient.invoke_stream(self: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var2 1 2 - call openai.internal.invoke_stream - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function openai.ResponsesClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, temperature: float | null, top_p: float | null, max_output_tokens: int | null, reasoning_effort: string | null, reasoning_summary: string | null, verbosity: string | null, parallel_tool_calls: bool | null, store: bool, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> openai.ResponsesClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "gpt-4o-mini" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var temperature - - L3: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var top_p - - L4: - load_var max_output_tokens - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var max_output_tokens - - L5: - load_var reasoning_effort - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var reasoning_effort - - L6: - load_var reasoning_summary - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var reasoning_summary - - L7: - load_var verbosity - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var verbosity - - L8: - load_var parallel_tool_calls - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var parallel_tool_calls - - L9: - load_var store - load_const - cmp_op == - pop_jump_if_false L10 - load_const false - store_var store - - L10: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L11 - load_const null - store_var request_body - - L11: - load_var headers - load_const - cmp_op == - pop_jump_if_false L12 - load_const null - store_var headers - - L12: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L13 - load_const null - store_var query_params - - L13: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var2 13 14 - init_instance openai.ResponsesClient .model, .api_key, .base_url, .temperature, .top_p, .max_output_tokens, .reasoning_effort, .reasoning_summary, .verbosity, .parallel_tool_calls, .store, .request_body, .headers, .query_params - return -} - -function openai.ResponsesClient.resolved_api_key(self: openai.ResponsesClient) -> string { - load_var self - load_field .api_key - load_const "OPENAI_API_KEY" - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .api_key - load_const "OPENAI_API_KEY" - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "openai" - load_const null - load_const "openai needs an API key: pass api_key (a literal or env.NAME), or set one of the variables it consulted — " - load_var _8 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L1: - load_var _4 - return -} - -function openai.ResponsesClient.resolved_base_url(self: openai.ResponsesClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function openai.internal.CcToolCall.baml.FromJson.from_json(j: baml.json.json) -> openai.internal.CcToolCall { - load_var j - load_const "id" - call baml.json.field - store_var _3 - load_type string | null - load_var _3 - call baml.json.to - load_var j - load_const "type" - call baml.json.field - store_var _6 - load_type string | null - load_var _6 - call baml.json.to - load_var j - load_const "index" - call baml.json.field - store_var _9 - load_type int | null - load_var _9 - call baml.json.to - load_var j - load_const "function" - call baml.json.field - store_var _12 - load_type openai.internal.CcFunctionCall | null - load_var _12 - call baml.json.to - init_instance openai.internal.CcToolCall .id, .type, .index, .fn - return -} - -function openai.internal.ChatCompat.new(provider: string, base_url: string, path: string, auth: openai.internal.ChatAuth, api_key_env: string | null, api_key_required: bool, collapse_text_content: bool, inline_image_urls: bool, send_stream_options: bool, max_tokens_key: string, default_max_tokens: int | null, default_role: string, compat_query: map | null) -> openai.internal.ChatCompat { - load_var path - load_const - cmp_op == - pop_jump_if_false L0 - load_const "/chat/completions" - store_var path - - L0: - load_var auth - load_const - cmp_op == - pop_jump_if_false L1 - load_const openai.internal.ChatAuth.Bearer - alloc_variant openai.internal.ChatAuth - store_var auth - - L1: - load_var api_key_env - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var api_key_env - - L2: - load_var api_key_required - load_const - cmp_op == - pop_jump_if_false L3 - load_const false - store_var api_key_required - - L3: - load_var collapse_text_content - load_const - cmp_op == - pop_jump_if_false L4 - load_const false - store_var collapse_text_content - - L4: - load_var inline_image_urls - load_const - cmp_op == - pop_jump_if_false L5 - load_const false - store_var inline_image_urls - - L5: - load_var send_stream_options - load_const - cmp_op == - pop_jump_if_false L6 - load_const false - store_var send_stream_options - - L6: - load_var max_tokens_key - load_const - cmp_op == - pop_jump_if_false L7 - load_const "max_tokens" - store_var max_tokens_key - - L7: - load_var default_max_tokens - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var default_max_tokens - - L8: - load_var default_role - load_const - cmp_op == - pop_jump_if_false L9 - load_const "user" - store_var default_role - - L9: - load_var compat_query - load_const - cmp_op == - pop_jump_if_false L10 - load_const null - store_var compat_query - - L10: - load_var compat_query - store_var_load_var _27 - load_const null - cmp_op == - pop_jump_if_false L11 - load_type string - load_type string - alloc_map 0 - store_var _27 - - L11: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var2 11 12 - load_var _27 - init_instance openai.internal.ChatCompat .provider, .base_url, .path, .auth, .api_key_env, .api_key_required, .collapse_text_content, .inline_image_urls, .send_stream_options, .max_tokens_key, .default_max_tokens, .default_role, .compat_query - return -} - -function openai.internal.ChatExtraPart.baml.ToJson.to_json(self: openai.internal.ChatExtraPart) -> baml.json.json { - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var self - load_field .part - call baml.json.to_json - store_var base - load_var base - store_var _5 - load_var _5 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_var base - jump L6 - - L1: - load_var _5 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - - L2: - load_var _11 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var _12 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L4 - - L3: - load_var _12 - store_var key - load_type string - load_type baml.json.json - load_var2 4 8 - call baml.Map.get - store_var _18 - load_type string - load_type baml.json.json - load_var2 5 8 - load_var _18 - call baml.Map.set - pop 1 - jump L2 - - L4: - load_type string - load_type baml.json.json - load_var self - load_field .extra - call baml.Map.keys - container_len - store_var _25 - load_var _25 - load_const 0 - cmp_int_op > - pop_jump_if_false L5 - call openai.internal._chat_directives_key - store_var _31 - load_type map - load_var self - load_field .extra - call baml.json.to_json - store_var _32 - load_type string - load_type baml.json.json - load_var2 5 11 - load_var _32 - call baml.Map.set - pop 1 - - L5: - load_var out - - L6: - return -} - -function openai.internal.ChatParams.new(model: string, api_key: string | null, temperature: float | null, max_tokens: int | null, max_completion_tokens: int | null, top_p: float | null, stop: string[] | null, seed: int | null, headers: map | null, query_params: map | null, request_body: baml.json.json | null) -> openai.internal.ChatParams { - load_var api_key - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var api_key - - L0: - load_var temperature - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var temperature - - L1: - load_var max_tokens - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var max_tokens - - L2: - load_var max_completion_tokens - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var max_completion_tokens - - L3: - load_var top_p - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var top_p - - L4: - load_var stop - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var stop - - L5: - load_var seed - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var seed - - L6: - load_var headers - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var headers - - L7: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var query_params - - L8: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var request_body - - L9: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - load_var request_body - init_instance openai.internal.ChatParams .model, .api_key, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .headers, .query_params, .request_body - return -} - -function openai.internal.ChatStreamDecoder._absorb_call(self: openai.internal.ChatStreamDecoder, delta: openai.internal.CcToolCall, position: int) -> void { - load_var ?4 - make_cell - store_var ?4 - load_var delta - load_field .index - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var position - store_var _5 - - L0: - load_var _5 - store_deref ?4 - load_type openai.internal.ChatToolCallBuffer - load_type never - load_var self - load_field .calls - load_var index - make_closure ., 1 - call baml.Array.find - store_var _14 - load_var _14 - narrow_bind openai.internal.ChatToolCallBuffer, slot=7 - pop_jump_if_false L1 - jump L2 - - L1: - load_deref ?4 - load_const "" - load_const "" - load_const "" - init_instance openai.internal.ChatToolCallBuffer .index, .id, .name, .arguments - store_var fresh - load_type openai.internal.ChatToolCallBuffer - load_var self - load_field .calls - load_var fresh - call baml.Array.push - pop 1 - load_var fresh - store_var buffer - jump L3 - - L2: - load_var _14 - store_var buffer - - L3: - load_var delta - load_field .id - store_var _23 - load_var _23 - narrow_bind string, slot=9 - pop_jump_if_false L4 - load_var2 6 9 - store_field .id - - L4: - load_var delta - load_field .fn - load_const null - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_var delta - load_field .fn - load_field .0 - jump L7 - - L6: - load_const null - - L7: - store_var _29 - load_var _29 - narrow_bind string, slot=10 - pop_jump_if_false L8 - load_var _29 - store_var name - load_type string - load_var buffer - load_field .name - call baml.String.from - store_var _31 - load_type string - load_var name - call baml.String.from - store_var _34 - load_var2 6 12 - load_var _34 - bin_op + - store_field .name - - L8: - load_var delta - load_field .fn - load_const null - cmp_op == - pop_jump_if_false L9 - jump L10 - - L9: - load_var delta - load_field .fn - load_field .1 - jump L11 - - L10: - load_const null - - L11: - store_var _41 - load_var _41 - narrow_bind string, slot=14 - pop_jump_if_false L12 - jump L13 - - L12: - load_const null - jump L14 - - L13: - load_var _41 - store_var fragment - load_type string - load_var buffer - load_field .arguments - call baml.String.from - store_var _43 - load_type string - load_var fragment - call baml.String.from - store_var _46 - load_var2 6 16 - load_var _46 - bin_op + - store_field .arguments - load_const null - - L14: - return -} - -function openai.internal.ChatStreamDecoder.decode(self: openai.internal.ChatStreamDecoder, batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - store_var out - load_var batch - call ai.stream.decode_sse_batch - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L25 - - L1: - load_var _6 - load_field .data - store_var _11 - load_var _11 - narrow_bind string, slot=6 - pop_jump_if_false L0 - load_var _11 - store_var data - load_var data - call baml.String.trim - load_const "[DONE]" - cmp_op == - pop_jump_if_false L2 - jump L24 - - L2: - load_var data - call baml.json.parse - store_var _20 - load_type openai.internal.CcStreamChunk - load_var _20 - call baml.json.to - store_var parsed - jump L3 - load_var e - throw_if_panic - load_const null - store_var parsed - - L3: - load_var parsed - load_const null - call baml.ops.equals_equals - jump_if_false L4 - pop 1 - load_var data - call baml.String.trim - load_const "{" - call baml.String.starts_with - - L4: - pop_jump_if_false L5 - jump L23 - - L5: - load_var parsed - store_var _30 - load_var _30 - narrow_bind openai.internal.CcStreamChunk, slot=11 - pop_jump_if_false L0 - load_var _30 - store_var_load_var chunk - load_field .choices - store_var_load_var _33 - load_const null - cmp_op == - pop_jump_if_false L6 - load_type openai.internal.CcStreamChoice - alloc_array 0 - store_var _33 - - L6: - load_type openai.internal.CcStreamChoice - load_var _33 - load_const 0 - call baml.Array.at - store_var _38 - load_var _38 - narrow_bind openai.internal.CcStreamChoice, slot=14 - pop_jump_if_false L22 - load_var _38 - store_var_load_var choice - load_field .delta - load_const null - cmp_op == - pop_jump_if_false L7 - jump L8 - - L7: - load_var choice - load_field .delta - load_field .1 - jump L9 - - L8: - load_const null - - L9: - store_var _44 - load_var _44 - narrow_bind string, slot=16 - pop_jump_if_false L10 - load_var _44 - store_var_load_var text - load_const "" - cmp_op != - pop_jump_if_false L10 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 17 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - - L10: - load_var choice - load_field .delta - load_const null - cmp_op == - pop_jump_if_false L11 - jump L12 - - L11: - load_var choice - load_field .delta - load_field .2 - jump L13 - - L12: - load_const null - - L13: - store_var _56 - load_var _56 - narrow_bind string, slot=18 - pop_jump_if_false L14 - load_var _56 - store_var_load_var refusal - load_const "" - cmp_op != - pop_jump_if_false L14 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 19 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - - L14: - load_var choice - load_field .delta - load_const null - cmp_op == - pop_jump_if_false L15 - jump L16 - - L15: - load_var choice - load_field .delta - load_field .4 - jump L17 - - L16: - load_const null - - L17: - store_var_load_var _65 - load_const null - cmp_op == - pop_jump_if_false L18 - load_type openai.internal.CcToolCall - alloc_array 0 - store_var _65 - - L18: - load_const 0 - store_var position - load_var _65 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _73 - - L19: - load_var _73 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _74 - load_var _74 - is_type baml.iter.Done - pop_jump_if_false L20 - jump L21 - - L20: - load_var2 1 23 - load_var position - call openai.internal.ChatStreamDecoder._absorb_call - pop 1 - load_var position - load_const 1 - add_int - store_var position - jump L19 - - L21: - load_var choice - load_field .finish_reason - store_var _82 - load_var _82 - narrow_bind string, slot=24 - pop_jump_if_false L22 - load_var _82 - call openai.internal.chat_stop_reason - store_var _86 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 25 - load_const null - load_const null - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - - L22: - load_var chunk - load_field .usage - store_var _90 - load_var _90 - narrow_bind openai.internal.CcUsage, slot=26 - pop_jump_if_false L0 - load_var _90 - store_var usage - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - load_const null - load_var usage - load_field .prompt_tokens - load_var usage - load_field .completion_tokens - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - jump L0 - - L23: - load_var self - load_field .provider - load_var data - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L24: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - alloc_instance ai.stream.TurnDone - call baml.Array.push - pop 1 - jump L0 - - L25: - load_var out - return -} - -function openai.internal.ChatStreamDecoder.new(provider: string) -> openai.internal.ChatStreamDecoder { - load_var provider - load_type openai.internal.ChatToolCallBuffer - alloc_array 0 - init_instance openai.internal.ChatStreamDecoder .provider, .calls - return -} - -function openai.internal.ChatStreamDecoder.tool_uses(self: openai.internal.ChatStreamDecoder) -> ai.content.ToolUse[] { - load_type ai.content.ToolUse - alloc_array 0 - store_var out - load_var self - load_field .calls - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L5 - - L1: - load_var _5 - store_var_load_var buffer - load_field .arguments - call baml.String.trim - load_const "" - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_var buffer - load_field .arguments - load_var self - load_field .provider - call openai.internal._chat_tool_args - store_var args - jump L4 - - L3: - load_type string - load_type unknown - alloc_map 0 - store_var args - - L4: - load_type ai.content.ToolUse - load_var2 2 5 - load_field .id - load_var buffer - load_field .name - load_var args - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var out - return -} - -function openai.internal.ChatTool.baml.ToJson.to_json(self: openai.internal.ChatTool) -> baml.json.json { - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var out - load_const "type" - load_var self - load_field .type - call baml.Map.set - pop 1 - load_type openai.internal.ChatToolFunction - load_var self - load_field .fn - call baml.json.to_json - store_var _8 - load_type string - load_type baml.json.json - load_var out - load_const "function" - load_var _8 - call baml.Map.set - pop 1 - load_var out - return -} - -function openai.internal.ChatToolCall.baml.ToJson.to_json(self: openai.internal.ChatToolCall) -> baml.json.json { - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var out - load_const "id" - load_var self - load_field .id - call baml.Map.set - pop 1 - load_type string - load_type baml.json.json - load_var out - load_const "type" - load_var self - load_field .type - call baml.Map.set - pop 1 - load_type openai.internal.ChatToolCallFunction - load_var self - load_field .fn - call baml.json.to_json - store_var _12 - load_type string - load_type baml.json.json - load_var out - load_const "function" - load_var _12 - call baml.Map.set - pop 1 - load_var out - return -} - -function openai.internal.OaStreamState.new() -> openai.internal.OaStreamState { - load_const null - load_type string - load_type bool - alloc_map 0 - load_type string - load_type string - alloc_map 0 - init_instance openai.internal.OaStreamState .model, .text_started, .call_arguments - return -} - -function openai.internal._azure_reject(detail: string) -> ai.errors.InvalidRequest { - load_const "azure" - load_var detail - call openai.internal._reject - return -} - -function openai.internal._chat_all_text(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[]) -> bool { - load_const true - store_var all - load_var parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _4 - store_var _8 - load_var _8 - narrow_bind openai.internal.ChatTextPart, slot=5 - pop_jump_if_false L2 - jump L0 - - L2: - load_const false - store_var all - jump L0 - - L3: - load_var all - return -} - -function openai.internal._chat_apply_directives(j: baml.json.json) -> baml.json.json { - load_var j - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L3 - - L0: - load_var j - store_var _47 - load_var _47 - narrow_bind baml.json.json[], slot=17 - pop_jump_if_false L1 - jump L2 - - L1: - load_var j - jump L10 - - L2: - load_type baml.json.json - load_type baml.json.json - load_type never - load_var _47 - make_closure ., 0 - call baml.Array.map - jump L10 - - L3: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L4: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L6 - - L5: - load_var _9 - store_var key - call openai.internal._chat_directives_key - store_var _15 - load_var2 7 8 - cmp_op != - pop_jump_if_false L4 - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - call openai.internal._chat_apply_directives - store_var _18 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _18 - call baml.Map.set - pop 1 - jump L4 - - L6: - call openai.internal._chat_directives_key - store_var _26 - load_type string - load_type baml.json.json - load_var2 3 10 - call baml.Map.get - store_var _29 - load_var _29 - narrow_bind map, slot=11 - pop_jump_if_false L9 - load_var _29 - store_var directives - load_type string - load_type baml.json.json - load_var directives - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _34 - - L7: - load_var _34 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _35 - load_var _35 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L9 - - L8: - load_var _35 - store_var key - load_type string - load_type baml.json.json - load_var2 12 15 - call baml.Map.get - store_var _41 - load_type string - load_type baml.json.json - load_var2 4 15 - load_var _41 - call baml.Map.set - pop 1 - jump L7 - - L9: - load_var out - - L10: - return -} - -function openai.internal._chat_apply_metadata(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], metadata: map) -> void { - load_type string - load_type baml.json.json - load_var metadata - call baml.Map.keys - container_len - store_var _4 - load_var _4 - load_const 0 - cmp_int_op == - pop_jump_if_false L0 - jump L7 - - L0: - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var parts - call baml.Array.pop - store_var _10 - load_var _10 - narrow_bind openai.internal.ChatTextPart, slot=4 - pop_jump_if_false L1 - jump L6 - - L1: - load_var _10 - narrow_bind openai.internal.ChatImagePart, slot=4 - pop_jump_if_false L2 - jump L6 - - L2: - load_var _10 - narrow_bind openai.internal.ChatAudioPart, slot=4 - pop_jump_if_false L3 - jump L6 - - L3: - load_var _10 - narrow_bind openai.internal.ChatFilePart, slot=4 - pop_jump_if_false L4 - jump L6 - - L4: - load_var _10 - narrow_bind openai.internal.ChatExtraPart, slot=4 - pop_jump_if_false L5 - jump L6 - - L5: - load_const null - jump L7 - - L6: - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var2 1 4 - load_var metadata - init_instance openai.internal.ChatExtraPart .part, .extra - call baml.Array.push - pop 1 - load_const null - - L7: - return -} - -function openai.internal._chat_audio_format(mime_type: string) -> string { - load_var mime_type - load_const "audio/" - call baml.String.starts_with - pop_jump_if_false L0 - jump L1 - - L0: - load_var mime_type - store_var subtype - jump L2 - - L1: - load_var mime_type - call baml.String.length - store_var _4 - load_var mime_type - load_const 6 - load_var _4 - call baml.String.slice - store_var subtype - - L2: - load_var subtype - load_const "mpeg" - cmp_op == - pop_jump_if_false L3 - jump L8 - - L3: - load_var subtype - load_const "mp3" - cmp_op == - pop_jump_if_false L4 - jump L7 - - L4: - load_var subtype - load_const "x-wav" - cmp_op == - pop_jump_if_false L5 - jump L6 - - L5: - load_var subtype - jump L9 - - L6: - load_const "wav" - jump L9 - - L7: - load_const "mp3" - jump L9 - - L8: - load_const "mp3" - - L9: - return -} - -function openai.internal._chat_audio_output_mime(request_body: baml.json.json | null) -> string { - load_type string - load_var request_body - load_const ".audio.format" - load_const "wav" - call baml.json.path_or - store_var format - load_var format - load_const "mp3" - cmp_op == - pop_jump_if_false L0 - jump L3 - - L0: - load_var format - load_const "pcm16" - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var format - call baml.String.from - store_var _6 - load_const "audio/" - load_var _6 - bin_op + - jump L4 - - L2: - load_const "audio/pcm" - jump L4 - - L3: - load_const "audio/mpeg" - - L4: - return -} - -function openai.internal._chat_body_mentions(overrides: baml.json.json | null, key: string) -> bool { - load_var overrides - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const false - jump L2 - - L1: - load_type string - load_type baml.json.json - load_var2 3 2 - call baml.Map.has - - L2: - return -} - -function openai.internal._chat_content(parts: (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[], collapse: bool) -> string | (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - load_var collapse - jump_if_false L0 - pop 1 - load_var parts - call openai.internal._chat_all_text - - L0: - pop_jump_if_false L1 - jump L2 - - L1: - load_var parts - jump L6 - - L2: - load_const "" - store_var text - load_var parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L3: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _6 - store_var _10 - load_var _10 - narrow_bind openai.internal.ChatTextPart, slot=6 - pop_jump_if_false L3 - load_var _10 - store_var t - load_type string - load_var text - call baml.String.from - store_var _12 - load_type string - load_var t - load_field .text - call baml.String.from - store_var _15 - load_var2 8 9 - bin_op + - store_var text - jump L3 - - L5: - load_var text - - L6: - return -} - -function openai.internal._chat_directives_key() -> string { - load_const "__baml_directives" - return -} - -function openai.internal._chat_headers(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> map { - load_const "application/json" - load_const "content-type" - load_type string - load_type string - alloc_map 1 - store_var headers - load_var params - load_field .headers - store_var _5 - load_var _5 - narrow_bind map, slot=4 - pop_jump_if_false L3 - load_var _5 - store_var user_headers - load_type string - load_type string - load_var user_headers - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - - L0: - load_var _10 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - load_var _11 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _11 - store_var name - load_var name - call baml.String.to_lower_case - store_var _16 - load_type string - load_type string - load_var2 5 8 - call baml.Map.get - store_var_load_var _18 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _18 - - L2: - load_type string - load_type string - load_var2 3 9 - load_var _18 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var params - load_field .api_key - store_var_load_var key - load_const null - call baml.ops.equals_equals - jump_if_false L4 - pop 1 - load_var compat - load_field .api_key_required - - L4: - pop_jump_if_false L5 - jump L11 - - L5: - load_var key - store_var _43 - load_var _43 - narrow_bind string, slot=16 - pop_jump_if_false L10 - load_var _43 - store_var credential - load_var compat - load_field .auth - discriminant - load_const ChatAuth.Bearer - cmp_int_op == - pop_jump_if_false L6 - jump L9 - - L6: - load_var compat - load_field .auth - discriminant - load_const ChatAuth.ApiKeyHeader - cmp_int_op == - pop_jump_if_false L7 - jump L8 - - L7: - jump L10 - - L8: - load_type string - load_type string - load_var headers - load_const "api-key" - load_var credential - call baml.Map.set - pop 1 - jump L10 - - L9: - load_type string - load_var credential - call baml.String.from - store_var _49 - load_type string - load_type string - load_var headers - load_const "authorization" - load_const "Bearer " - load_var _49 - bin_op + - call baml.Map.set - pop 1 - - L10: - load_var headers - return - - L11: - load_var compat - load_field .provider - store_var _31 - load_type string - load_var compat - load_field .provider - call baml.String.from - store_var _34 - load_var compat - load_field .api_key_env - store_var_load_var _39 - load_const null - cmp_op == - pop_jump_if_false L12 - load_const "the provider's environment variable" - store_var _39 - - L12: - load_type string - load_var _39 - call baml.String.from - store_var _37 - load_var2 12 13 - load_const " needs an API key: pass api_key, or set " - bin_op + - load_var _37 - bin_op + - call openai.internal._reject - throw -} - -function openai.internal._chat_is_opaque_key(key: string) -> bool { - load_var key - load_const "parameters" - cmp_op == - jump_if_false L0 - jump L1 - - L0: - pop 1 - call openai.internal._chat_directives_key - store_var _3 - load_var2 1 2 - cmp_op == - - L1: - return -} - -function openai.internal._chat_media_block(url: string) -> ai.content.Media { - load_var url - load_const "data:" - call baml.String.starts_with - pop_jump_if_false L0 - load_var url - load_const ";base64," - call baml.String.index_of - store_var _4 - load_var _4 - narrow_bind int, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var url - load_const null - call baml.media.Image.from_url - load_const - load_const - call ai.content.Media.new - jump L2 - - L1: - load_var _4 - store_var_load_var separator - load_const 8 - add_int - store_var _8 - load_var url - call baml.String.length - store_var _10 - load_var2 1 5 - load_var _10 - call baml.String.slice - store_var _7 - load_var url - load_const 5 - load_var separator - call baml.String.slice - store_var _11 - load_var2 4 7 - call baml.media.Image.from_base64 - load_const - load_const - call ai.content.Media.new - - L2: - return -} - -function openai.internal._chat_media_part(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf, compat: openai.internal.ChatCompat) -> openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart { - load_var media - store_var _3 - load_var _3 - narrow_bind baml.media.Image, slot=3 - pop_jump_if_false L0 - jump L10 - - L0: - load_var media - store_var _11 - load_var _11 - narrow_bind baml.media.Audio, slot=5 - pop_jump_if_false L1 - jump L8 - - L1: - load_var media - store_var _22 - load_var _22 - narrow_bind baml.media.Pdf, slot=10 - pop_jump_if_false L2 - jump L3 - - L2: - load_var compat - load_field .provider - load_const "OpenAI Chat Completions has no video input part; extract frames as images, or use the Realtime API" - call openai.internal._reject - throw - - L3: - load_var _22 - store_var_load_var pdf - load_const true - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .base64 - store_var _28 - load_var _28 - narrow_bind string, slot=14 - pop_jump_if_false L4 - jump L6 - - L4: - load_var compat - load_field .provider - store_var _31 - load_var resolved - load_field .url - store_var_load_var _36 - load_const null - cmp_op == - pop_jump_if_false L5 - load_const "this document" - store_var _36 - - L5: - load_type string - load_var _36 - call baml.String.from - store_var _34 - load_var _31 - load_const "OpenAI Chat Completions has no document-by-URL content part, so a PDF must be inlined, and " - load_var _34 - bin_op + - load_const " is not a URL this client can fetch (gs:// and other non-HTTP schemes are not supported here). Pass the PDF as base64 or a local file." - bin_op + - call openai.internal._reject - throw - - L6: - load_var _28 - store_var data - load_var pdf - call baml.media.Pdf.file - store_var_load_var _43 - load_const null - cmp_op == - pop_jump_if_false L7 - load_var pdf - call baml.media.Pdf.url - store_var _43 - - L7: - load_var _43 - call openai.internal._openai_file_name - store_var _41 - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _49 - load_type string - load_var data - call baml.String.from - store_var _52 - load_const "file" - load_var _41 - load_const "data:" - load_var _49 - bin_op + - load_const ";base64," - bin_op + - load_var _52 - bin_op + - init_instance openai.internal.ChatFileData .filename, .file_data - init_instance openai.internal.ChatFilePart .type, .file - jump L11 - - L8: - load_var _11 - load_const true - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .base64 - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L9 - load_const "" - store_var _17 - - L9: - load_var _17 - store_var _16 - load_var resolved - load_field .mime_type - call openai.internal._chat_audio_format - store_var _20 - load_const "input_audio" - load_var2 7 9 - init_instance openai.internal.ChatInputAudio .data, .format - init_instance openai.internal.ChatAudioPart .type, .input_audio - jump L11 - - L10: - load_var2 3 2 - load_field .inline_image_urls - call ai.wire.resolve_media - call openai.internal._chat_media_url - store_var _9 - load_const "image_url" - load_var _9 - init_instance openai.internal.ChatImageUrl .url - init_instance openai.internal.ChatImagePart .type, .image_url - - L11: - return -} - -function openai.internal._chat_media_url(resolved: ai.wire.ResolvedMedia) -> string { - load_var resolved - load_field .url - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L2 - - L0: - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _7 - load_var resolved - load_field .base64 - store_var_load_var _12 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "" - store_var _12 - - L1: - load_type string - load_var _12 - call baml.String.from - store_var _10 - load_const "data:" - load_var _7 - bin_op + - load_const ";base64," - bin_op + - load_var _10 - bin_op + - jump L3 - - L2: - load_var _3 - - L3: - return -} - -function openai.internal._chat_percent_encode(value: string) -> string { - load_const "" - store_var out - load_var value - call baml.String.chars - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L5 - - L1: - load_var _6 - store_var character - load_const "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~" - load_var character - call baml.String.includes - pop_jump_if_false L2 - jump L4 - - L2: - load_var character - call baml.String.to_utf8 - call baml.Uint8Array.to_hex - call baml.String.to_upper_case - store_var hex - load_const 0 - store_var i - - L3: - load_var i - store_var _23 - load_var hex - call baml.String.length - store_var _24 - load_var2 10 11 - cmp_int_op < - pop_jump_if_false L0 - load_type string - load_var out - call baml.String.from - store_var _26 - load_var2 8 9 - load_var i - load_const 2 - add_int - call baml.String.slice - store_var _30 - load_type string - load_var _30 - call baml.String.from - store_var _29 - load_var _26 - load_const "%" - bin_op + - load_var _29 - bin_op + - store_var out - load_var i - load_const 2 - add_int - store_var i - jump L3 - - L4: - load_type string - load_var out - call baml.String.from - store_var _12 - load_type string - load_var character - call baml.String.from - store_var _15 - load_var2 6 7 - bin_op + - store_var out - jump L0 - - L5: - load_var out - return -} - -function openai.internal._chat_prompt_parts(message: ai.PromptMessage, compat: openai.internal.ChatCompat) -> (openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart)[] { - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - alloc_array 0 - store_var parts - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L10 - - L1: - load_var _6 - store_var part - load_var part - store_var _10 - load_var _10 - narrow_bind string, slot=7 - pop_jump_if_false L2 - jump L9 - - L2: - load_var part - store_var _16 - load_var _16 - narrow_bind baml.media.Image, slot=8 - pop_jump_if_false L3 - jump L8 - - L3: - load_var part - store_var _22 - load_var _22 - narrow_bind baml.media.Audio, slot=10 - pop_jump_if_false L4 - jump L7 - - L4: - load_var part - store_var _28 - load_var _28 - narrow_bind baml.media.Pdf, slot=12 - pop_jump_if_false L5 - jump L6 - - L5: - load_var2 6 2 - call openai.internal._chat_media_part - store_var _36 - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var2 3 14 - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var2 12 2 - call openai.internal._chat_media_part - store_var _31 - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var2 3 13 - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var2 10 2 - call openai.internal._chat_media_part - store_var _25 - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var2 3 11 - call baml.Array.push - pop 1 - jump L0 - - L8: - load_var2 8 2 - call openai.internal._chat_media_part - store_var _19 - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var2 3 9 - call baml.Array.push - pop 1 - jump L0 - - L9: - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var parts - load_const "text" - load_var _10 - init_instance openai.internal.ChatTextPart .type, .text - call baml.Array.push - pop 1 - jump L0 - - L10: - load_var parts - return -} - -function openai.internal._chat_prune_nulls(j: baml.json.json) -> baml.json.json { - load_var j - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L3 - - L0: - load_var j - store_var _31 - load_var _31 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var j - jump L10 - - L2: - load_type baml.json.json - load_type baml.json.json - load_type never - load_var _31 - make_closure ., 0 - call baml.Array.map - jump L10 - - L3: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L4: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L9 - - L5: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var value - load_var value - load_const null - cmp_op == - pop_jump_if_false L6 - jump L4 - - L6: - load_var key - call openai.internal._chat_is_opaque_key - pop_jump_if_false L7 - jump L8 - - L7: - load_var value - call openai.internal._chat_prune_nulls - store_var _27 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _27 - call baml.Map.set - pop 1 - jump L4 - - L8: - load_type string - load_type baml.json.json - load_var2 4 7 - load_var value - call baml.Map.set - pop 1 - jump L4 - - L9: - load_var out - - L10: - return -} - -function openai.internal._chat_push_tool_uses(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media)[], calls: openai.internal.CcToolCall[], provider: string) -> void { - load_var calls - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L15 - - L1: - load_var _5 - store_var call - load_type string - load_type unknown - alloc_map 0 - store_var empty - load_var call - load_field .fn - load_const null - cmp_op == - pop_jump_if_false L2 - jump L3 - - L2: - load_var call - load_field .fn - load_field .1 - jump L4 - - L3: - load_const null - - L4: - store_var _15 - load_var _15 - narrow_bind string, slot=9 - pop_jump_if_false L5 - jump L6 - - L5: - load_var empty - store_var args - jump L9 - - L6: - load_var _15 - store_var raw - load_var raw - call baml.String.trim - load_const "" - cmp_op == - pop_jump_if_false L7 - jump L8 - - L7: - load_var2 10 3 - call openai.internal._chat_tool_args - store_var args - jump L9 - - L8: - load_var empty - store_var args - - L9: - load_var call - load_field .id - store_var_load_var _23 - load_const null - cmp_op == - pop_jump_if_false L10 - load_const "" - store_var _23 - - L10: - load_var _23 - store_var _22 - load_var call - load_field .fn - load_const null - cmp_op == - pop_jump_if_false L11 - jump L12 - - L11: - load_var call - load_field .fn - load_field .0 - jump L13 - - L12: - load_const null - - L13: - store_var_load_var _27 - load_const null - cmp_op == - pop_jump_if_false L14 - load_const "" - store_var _27 - - L14: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 1 11 - load_var2 13 8 - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L0 - - L15: - load_const null - return -} - -function openai.internal._chat_send(request: baml.http.Request, provider: string, audio_mime: string) -> ai.ModelTurn { - load_var audio_mime - load_const - cmp_op == - pop_jump_if_false L0 - load_const "audio/wav" - store_var audio_mime - - L0: - load_var request - load_const - call baml.http.send - store_var response - jump L1 - load_var e - throw_if_panic - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _10 - load_type string - load_var _10 - call baml.String.from - store_var _9 - load_var provider - load_const "transport failed before a response arrived: " - load_var _9 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L1: - load_var response - sys_op baml.http.Response.text - store_var text - jump L2 - load_var e - throw_if_panic - load_var provider - load_const "the response body could not be read completely" - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L2: - load_var response - call baml.http.Response.ok - unary_op ! - pop_jump_if_false L3 - jump L5 - - L3: - load_var text - call baml.json.parse - store_var _24 - load_type openai.internal.CcResponse - load_var _24 - call baml.json.to - jump L4 - load_var e - throw_if_panic - load_var2 2 8 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L4: - load_var2 2 8 - load_var audio_mime - call openai.internal.chat_parse - return - - L5: - load_var2 2 4 - load_field .status_code - load_var2 8 4 - load_field .headers - call ai.errors.classify_http - throw -} - -function openai.internal._chat_stream_failure(provider: string, detail: string) -> ai.errors.Failure { - load_var detail - load_const "SSE request failed with status " - call baml.String.index_of - store_var _6 - load_var _6 - narrow_bind int, slot=3 - pop_jump_if_false L1 - load_var _6 - store_var _10 - load_const "SSE request failed with status " - call baml.String.length - load_var _10 - add_int - store_var _9 - load_var detail - call baml.String.length - store_var _12 - load_var2 2 5 - load_var _12 - call baml.String.slice - store_var rest - load_var rest - load_const ":" - call baml.String.index_of - store_var _14 - load_var _14 - narrow_bind int, slot=8 - pop_jump_if_false L1 - load_var _14 - store_var colon - load_var rest - load_const 0 - load_var colon - call baml.String.slice - call baml.Int.parse - store_var code - jump L0 - load_var e - throw_if_panic - load_const 0 - store_var code - - L0: - load_var code - load_const 0 - cmp_int_op > - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var detail - call baml.String.from - store_var _29 - load_var provider - load_const "transport failed before a response arrived: " - load_var _29 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L3 - - L2: - load_var code - store_var _22 - load_var colon - load_const 1 - add_int - store_var _25 - load_var rest - call baml.String.length - store_var _27 - load_var2 4 14 - load_var _27 - call baml.String.slice - call baml.String.trim - store_var _23 - load_var2 1 12 - load_var _23 - load_const - call ai.errors.classify_http - - L3: - return -} - -function openai.internal._chat_tool_args(raw: string, provider: string) -> map { - load_type map - load_var raw - call baml.json.from_string - jump L0 - load_var e - throw_if_panic - load_var2 2 1 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L0: - return -} - -function openai.internal._chat_tools(toolbox: ai.tools.Toolbox) -> openai.internal.ChatTool[] | null { - load_var toolbox - call ai.tools.Toolbox.is_empty - pop_jump_if_false L0 - jump L4 - - L0: - load_type openai.internal.ChatTool - alloc_array 0 - store_var tools - load_var toolbox - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L1: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_var _6 - store_var tool - load_var tool - load_field .name - store_var _13 - load_var tool - load_field .description - store_var _14 - load_type map - load_var tool - load_field .input_schema - call baml.json.to_json - store_var _15 - load_type openai.internal.ChatTool - load_var tools - load_const "function" - load_var2 6 7 - load_var _15 - init_instance openai.internal.ChatToolFunction .name, .description, .parameters - init_instance openai.internal.ChatTool .type, .fn - call baml.Array.push - pop 1 - jump L1 - - L3: - load_var tools - jump L5 - - L4: - load_const null - - L5: - return -} - -function openai.internal._chat_url(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - load_type string - load_type string - alloc_map 0 - store_var query - load_type string - load_type string - load_var compat - load_field .compat_query - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L0: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _9 - store_var key - load_type string - load_type string - load_var compat - load_field .compat_query - load_var key - call baml.Map.get - store_var_load_var _16 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _16 - - L2: - load_type string - load_type string - load_var2 3 6 - load_var _16 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var params - load_field .query_params - store_var _26 - load_var _26 - narrow_bind map, slot=8 - pop_jump_if_false L7 - load_var _26 - store_var user_query - load_type string - load_type string - load_var user_query - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _31 - - L4: - load_var _31 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _32 - load_var _32 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L7 - - L5: - load_var _32 - store_var key - load_type string - load_type string - load_var2 9 12 - call baml.Map.get - store_var_load_var _39 - load_const null - cmp_op == - pop_jump_if_false L6 - load_const "" - store_var _39 - - L6: - load_type string - load_type string - load_var2 3 12 - load_var _39 - call baml.Map.set - pop 1 - jump L4 - - L7: - load_type string - load_var compat - load_field .base_url - call baml.String.from - store_var _48 - load_type string - load_var compat - load_field .path - call baml.String.from - store_var _51 - load_var2 15 16 - bin_op + - store_var url - load_type string - load_type string - load_var query - call baml.Map.keys - container_len - store_var _55 - load_var _55 - load_const 0 - cmp_int_op == - pop_jump_if_false L8 - jump L13 - - L8: - load_type string - alloc_array 0 - store_var pairs - load_type string - load_type string - load_var query - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _63 - - L9: - load_var _63 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _64 - load_var _64 - is_type baml.iter.Done - pop_jump_if_false L10 - jump L12 - - L10: - load_var _64 - store_var_load_var key - call openai.internal._chat_percent_encode - store_var _72 - load_type string - load_var _72 - call baml.String.from - store_var _71 - load_type string - load_type string - load_var2 3 21 - call baml.Map.get - store_var_load_var _78 - load_const null - cmp_op == - pop_jump_if_false L11 - load_const "" - store_var _78 - - L11: - load_var _78 - call openai.internal._chat_percent_encode - store_var _76 - load_type string - load_var _76 - call baml.String.from - store_var _75 - load_type string - load_var2 18 22 - load_const "=" - bin_op + - load_var _75 - bin_op + - call baml.Array.push - pop 1 - jump L9 - - L12: - load_type string - load_var url - call baml.String.from - store_var _87 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _91 - load_type string - load_var _91 - call baml.String.from - store_var _90 - load_var _87 - load_const "?" - bin_op + - load_var _90 - bin_op + - jump L14 - - L13: - load_var url - - L14: - return -} - -function openai.internal._oai_images_block(datum: openai.internal.OaImageDatum, mime: string) -> ai.content.Media | null { - load_var datum - load_field .b64_json - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L3 - - L0: - load_var datum - load_field .url - store_var _10 - load_var _10 - narrow_bind string, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_const null - jump L4 - - L2: - load_var2 4 2 - call openai.internal._oai_images_fetch_inline - load_const - load_var datum - load_field .revised_prompt - call ai.content.Media.new - jump L4 - - L3: - load_var2 3 2 - call baml.media.Image.from_base64 - load_const - load_var datum - load_field .revised_prompt - call ai.content.Media.new - - L4: - return -} - -function openai.internal._oai_images_client_id(c: openai.ImageClient) -> string { - load_type string - load_var c - load_field .model - call baml.String.from - store_var _3 - load_const "openai-images/" - load_var _3 - bin_op + - return -} - -function openai.internal._oai_images_drop_nulls(value: baml.json.json) -> baml.json.json { - load_var value - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var value - store_var _24 - load_var _24 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var value - jump L11 - - L2: - load_type baml.json.json - alloc_array 0 - store_var out - load_var _24 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L3: - load_var _28 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _29 - call openai.internal._oai_images_drop_nulls - store_var _34 - load_type baml.json.json - load_var2 11 14 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - jump L11 - - L6: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L7: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L10 - - L8: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var entry - load_var entry - load_const null - cmp_op == - pop_jump_if_false L9 - jump L7 - - L9: - load_var entry - call openai.internal._oai_images_drop_nulls - store_var _20 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _20 - call baml.Map.set - pop 1 - jump L7 - - L10: - load_var out - - L11: - return -} - -function openai.internal._oai_images_escape_query(raw: string) -> string { - load_var raw - load_const "%" - load_const "%25" - call baml.String.replace_all - load_const " " - load_const "%20" - call baml.String.replace_all - load_const "&" - load_const "%26" - call baml.String.replace_all - load_const "=" - load_const "%3D" - call baml.String.replace_all - load_const "?" - load_const "%3F" - call baml.String.replace_all - load_const "#" - load_const "%23" - call baml.String.replace_all - return -} - -function openai.internal._oai_images_fetch_inline(location: string, fallback_mime: string) -> image { - load_var location - load_const - call baml.http.fetch - store_var response - jump L0 - load_var e - throw_if_panic - load_type string - load_var location - call baml.String.from - store_var _9 - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _12 - load_type string - load_var _12 - call baml.String.from - store_var _11 - load_const "openai-images" - load_const "fetching the generated image at " - load_var _9 - bin_op + - load_const " failed: " - bin_op + - load_var _11 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw - - L0: - load_var response - call baml.http.Response.ok - unary_op ! - pop_jump_if_false L1 - jump L7 - - L1: - load_type string - load_type string - load_var response - load_field .headers - load_const "content-type" - call baml.Map.get - store_var_load_var _31 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _31 - - L2: - load_var _31 - load_const ";" - call baml.String.split - store_var _29 - load_type string - load_var _29 - load_const 0 - call baml.Array.at - store_var_load_var _27 - load_const null - cmp_op == - pop_jump_if_false L3 - load_const "" - store_var _27 - - L3: - load_var _27 - store_var reported - load_var reported - call baml.String.trim - load_const "" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_var reported - call baml.String.trim - store_var mime - jump L6 - - L5: - load_var fallback_mime - store_var mime - - L6: - load_var response - sys_op baml.http.Response.bytes - call baml.Uint8Array.to_base64 - load_var mime - call baml.media.Image.from_base64 - return - - L7: - load_type string - load_var location - call baml.String.from - store_var _21 - load_type int - load_var response - load_field .status_code - call baml.String.from - store_var _23 - load_const "openai-images" - load_const "fetching the generated image at " - load_var _21 - bin_op + - load_const " returned HTTP " - bin_op + - load_var _23 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - throw -} - -function openai.internal._oai_images_headers(c: openai.ImageClient) -> map { - load_const "application/json" - load_const "content-type" - load_type string - load_type string - alloc_map 1 - store_var headers - load_var c - load_field .headers - store_var _4 - load_var _4 - narrow_bind map, slot=3 - pop_jump_if_false L3 - load_var _4 - store_var extra - load_type string - load_type string - load_var extra - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var name - load_var name - call baml.String.to_lower_case - store_var _15 - load_type string - load_type string - load_var2 4 7 - call baml.Map.get - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _17 - - L2: - load_type string - load_type string - load_var2 2 8 - load_var _17 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var c - call openai.ImageClient.resolved_api_key - store_var _28 - load_type string - load_var _28 - call baml.String.from - store_var _27 - load_type string - load_type string - load_var headers - load_const "authorization" - load_const "Bearer " - load_var _27 - bin_op + - call baml.Map.set - pop 1 - load_var headers - return -} - -function openai.internal._oai_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - load_type string - load_var kind - call baml.String.from - store_var _4 - load_const "openai-images" - load_const null - load_const "Images API only supports text prompts; found " - load_var _4 - bin_op + - load_const " input" - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function openai.internal._oai_images_mime(format: string | null) -> string { - load_var format - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "png" - store_var _4 - - L0: - load_var _4 - call baml.String.to_lower_case - store_var normalized - load_var normalized - load_const "jpeg" - cmp_op == - pop_jump_if_false L1 - jump L8 - - L1: - load_var normalized - load_const "jpg" - cmp_op == - pop_jump_if_false L2 - jump L7 - - L2: - load_var normalized - load_const "webp" - cmp_op == - pop_jump_if_false L3 - jump L6 - - L3: - load_var normalized - load_const "gif" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_const "image/png" - jump L9 - - L5: - load_const "image/gif" - jump L9 - - L6: - load_const "image/webp" - jump L9 - - L7: - load_const "image/jpeg" - jump L9 - - L8: - load_const "image/jpeg" - - L9: - return -} - -function openai.internal._oai_images_prompt_text(prompt: ai.Prompt, journal: ai.Journal) -> string { - load_type string - alloc_array 0 - store_var parts - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L12 - - L1: - load_var _6 - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - - L2: - load_var _11 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var _12 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L0 - - L3: - load_var _12 - store_var part - load_var part - store_var _16 - load_var _16 - narrow_bind string, slot=9 - pop_jump_if_false L4 - jump L11 - - L4: - load_var part - store_var _24 - load_var _24 - narrow_bind baml.media.Image, slot=11 - pop_jump_if_false L5 - jump L10 - - L5: - load_var part - store_var _26 - load_var _26 - narrow_bind baml.media.Audio, slot=12 - pop_jump_if_false L6 - jump L9 - - L6: - load_var part - store_var _28 - load_var _28 - narrow_bind baml.media.Video, slot=13 - pop_jump_if_false L7 - jump L8 - - L7: - load_const "pdf" - call openai.internal._oai_images_media_rejected - throw - - L8: - load_const "video" - call openai.internal._oai_images_media_rejected - throw - - L9: - load_const "audio" - call openai.internal._oai_images_media_rejected - throw - - L10: - load_const "image" - call openai.internal._oai_images_media_rejected - throw - - L11: - load_var _16 - call baml.String.trim - store_var trimmed - load_var trimmed - load_const "" - cmp_op != - pop_jump_if_false L2 - load_type string - load_var2 3 10 - call baml.Array.push - pop 1 - jump L2 - - L12: - load_var journal - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _32 - - L13: - load_var _32 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _33 - load_var _33 - is_type baml.iter.Done - pop_jump_if_false L14 - jump L15 - - L14: - load_var _33 - store_var _37 - load_var _37 - narrow_bind ai.events.UserMessage, slot=16 - pop_jump_if_false L13 - load_var _37 - load_field .content - call baml.String.trim - store_var trimmed - load_var trimmed - load_const "" - cmp_op != - pop_jump_if_false L13 - load_type string - load_var2 3 17 - call baml.Array.push - pop 1 - jump L13 - - L15: - load_type string - load_var parts - load_const "\n\n" - call baml.Array.join - store_var joined - load_var joined - load_const "" - cmp_op == - pop_jump_if_false L16 - jump L17 - - L16: - load_var joined - return - - L17: - load_const "openai-images" - load_const null - load_const "Images API request requires a text prompt" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function openai.internal._oai_images_response_format(model: string, explicit: string | null) -> string | null { - load_var explicit - store_var _3 - load_var _3 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L3 - - L0: - load_var model - load_const "gpt-image" - call baml.String.starts_with - pop_jump_if_false L1 - jump L2 - - L1: - load_const "b64_json" - jump L4 - - L2: - load_const null - jump L4 - - L3: - load_var _3 - - L4: - return -} - -function openai.internal._oai_images_trim_slash(url: string) -> string { - load_var url - load_const "/" - call baml.String.ends_with - pop_jump_if_false L0 - jump L1 - - L0: - load_var url - jump L2 - - L1: - load_var url - call baml.String.length - store_var _4 - load_var url - load_const 0 - load_var _4 - load_const 1 - sub_int - call baml.String.slice - - L2: - return -} - -function openai.internal._oai_images_with_query(url: string, params: map | null) -> string { - load_type string - alloc_array 0 - store_var pairs - load_var params - store_var _4 - load_var _4 - narrow_bind map, slot=4 - pop_jump_if_false L3 - load_var _4 - store_var configured - load_type string - load_type string - load_var configured - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var_load_var key - call openai.internal._oai_images_escape_query - store_var _18 - load_type string - load_var _18 - call baml.String.from - store_var _17 - load_type string - load_type string - load_var2 5 8 - call baml.Map.get - store_var_load_var _24 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _24 - - L2: - load_var _24 - call openai.internal._oai_images_escape_query - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_type string - load_var2 3 9 - load_const "=" - bin_op + - load_var _21 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var pairs - container_len - store_var _33 - load_var _33 - load_const 0 - cmp_int_op == - pop_jump_if_false L4 - jump L8 - - L4: - load_var url - load_const "?" - call baml.String.includes - pop_jump_if_false L5 - jump L6 - - L5: - load_const "?" - store_var separator - jump L7 - - L6: - load_const "&" - store_var separator - - L7: - load_type string - load_var url - call baml.String.from - store_var _37 - load_type string - load_var separator - call baml.String.from - store_var _39 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _43 - load_type string - load_var _43 - call baml.String.from - store_var _42 - load_var2 16 17 - bin_op + - load_var _42 - bin_op + - jump L9 - - L8: - load_var url - - L9: - return -} - -function openai.internal._openai_apply_message_metadata(body: baml.json.json, metadata: map[]) -> baml.json.json { - load_var body - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L3 - load_type string - load_type baml.json.json - load_var _3 - load_const "input" - call baml.Map.get - store_var _8 - load_var _8 - narrow_bind baml.json.json[], slot=4 - pop_jump_if_false L3 - load_var _8 - store_var items - load_const 0 - store_var index - load_var metadata - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - - L0: - load_var _11 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var _12 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _12 - store_var directives - load_type string - load_type baml.json.json - load_var directives - call baml.Map.keys - container_len - store_var _17 - load_var _17 - load_const 0 - cmp_int_op > - pop_jump_if_false L2 - load_type baml.json.json - load_var2 5 6 - call baml.Array.at - load_var directives - call openai.internal._openai_merge_onto_last_part - pop 1 - - L2: - load_var index - load_const 1 - add_int - store_var index - jump L0 - - L3: - load_var body - return -} - -function openai.internal._openai_audio_format(mime_type: string) -> string { - load_var mime_type - load_const "audio/wav" - cmp_op == - pop_jump_if_false L0 - jump L15 - - L0: - load_var mime_type - load_const "audio/x-wav" - cmp_op == - pop_jump_if_false L1 - jump L14 - - L1: - load_var mime_type - load_const "audio/mpeg" - cmp_op == - pop_jump_if_false L2 - jump L13 - - L2: - load_var mime_type - load_const "audio/mp3" - cmp_op == - pop_jump_if_false L3 - jump L12 - - L3: - load_var mime_type - load_const "audio/flac" - cmp_op == - pop_jump_if_false L4 - jump L11 - - L4: - load_var mime_type - load_const "audio/x-flac" - cmp_op == - pop_jump_if_false L5 - jump L10 - - L5: - load_var mime_type - load_const "audio/ogg" - cmp_op == - pop_jump_if_false L6 - jump L9 - - L6: - load_var mime_type - load_const "audio/webm" - cmp_op == - pop_jump_if_false L7 - jump L8 - - L7: - load_var mime_type - jump L16 - - L8: - load_const "webm" - jump L16 - - L9: - load_const "ogg" - jump L16 - - L10: - load_const "flac" - jump L16 - - L11: - load_const "flac" - jump L16 - - L12: - load_const "mp3" - jump L16 - - L13: - load_const "mp3" - jump L16 - - L14: - load_const "wav" - jump L16 - - L15: - load_const "wav" - - L16: - return -} - -function openai.internal._openai_decode_batch(batch: string, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - store_var out - load_var batch - call ai.stream.decode_sse_batch - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L5 - - L1: - load_var _6 - store_var_load_var raw - load_field .data - store_var _11 - load_var _11 - narrow_bind string, slot=7 - pop_jump_if_false L0 - load_type openai.internal.OaStreamEvent - load_var _11 - call baml.json.from_string - jump L2 - load_var e - throw_if_panic - load_const null - - L2: - store_var _17 - load_var _17 - narrow_bind openai.internal.OaStreamEvent, slot=9 - pop_jump_if_false L0 - load_var2 9 6 - load_field .event - load_var state - call openai.internal._openai_stream_events - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _22 - - L3: - load_var _22 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _23 - load_var _23 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L0 - - L4: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 3 11 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - return -} - -function openai.internal._openai_error_failure(err: openai.internal.OaErrorBody) -> ai.errors.Failure { - load_var err - load_field .code - store_var_load_var _6 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _6 - - L0: - load_var _6 - load_const " " - bin_op + - store_var _4 - load_var err - load_field .type - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "" - store_var _10 - - L1: - load_var2 3 5 - bin_op + - call baml.String.to_lower_case - store_var code - load_var err - load_field .message - store_var_load_var _14 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "the OpenAI Responses request failed" - store_var _14 - - L2: - load_var _14 - store_var detail - load_type openai.internal.OaErrorBody - load_var err - call baml.json.to_json - call baml.json.stringify - store_var raw - load_var code - load_const "rate_limit" - call baml.String.includes - jump_if_false L3 - jump L4 - - L3: - pop 1 - load_var code - load_const "quota" - call baml.String.includes - - L4: - jump_if_false L5 - jump L6 - - L5: - pop 1 - load_var code - load_const "credit_balance" - call baml.String.includes - - L6: - pop_jump_if_false L7 - jump L16 - - L7: - load_var code - load_const "content_filter" - call baml.String.includes - jump_if_false L8 - jump L9 - - L8: - pop 1 - load_var code - load_const "moderation" - call baml.String.includes - - L9: - jump_if_false L10 - jump L11 - - L10: - pop 1 - load_var code - load_const "refusal" - call baml.String.includes - - L11: - pop_jump_if_false L12 - jump L15 - - L12: - load_var code - call openai.internal._openai_transient_code - pop_jump_if_false L13 - jump L14 - - L13: - load_const "openai" - load_const null - load_var2 6 8 - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - jump L17 - - L14: - load_const "openai" - load_var2 6 8 - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L17 - - L15: - load_const "openai" - load_var2 6 8 - init_instance ai.errors.Refused .provider, .reason, .raw_body - jump L17 - - L16: - load_const "openai" - load_const null - load_var raw - init_instance ai.errors.RateLimited .provider, .retry_after_ms, .raw_body - - L17: - return -} - -function openai.internal._openai_event_key(event: openai.internal.OaStreamEvent) -> string { - load_var event - load_field .item_id - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L3 - - L0: - load_var event - load_field .output_index - store_var _7 - load_var _7 - narrow_bind int, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_const "" - store_var item - jump L4 - - L2: - load_type int - load_var _7 - call baml.String.from - store_var _9 - load_const "#" - load_var _9 - bin_op + - store_var item - jump L4 - - L3: - load_var _4 - store_var item - - L4: - load_var event - load_field .content_index - store_var _13 - load_var _13 - narrow_bind int, slot=6 - pop_jump_if_false L5 - jump L6 - - L5: - load_var item - jump L7 - - L6: - load_var _13 - store_var part - load_type string - load_var item - call baml.String.from - store_var _16 - load_type int - load_var part - call baml.String.from - store_var _19 - load_var _16 - load_const ":" - bin_op + - load_var _19 - bin_op + - - L7: - return -} - -function openai.internal._openai_file_name(source: string | null) -> string { - load_var source - store_var _2 - load_var _2 - narrow_bind string, slot=2 - pop_jump_if_false L2 - load_var _2 - store_var raw - load_var raw - load_const "?" - call baml.String.split - store_var _7 - load_type string - load_var _7 - load_const 0 - call baml.Array.at - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var raw - store_var _5 - - L0: - load_var _5 - load_const "/" - call baml.String.split - store_var segments - load_var segments - container_len - store_var _15 - load_type string - load_var2 6 9 - load_const 1 - sub_int - call baml.Array.at - store_var_load_var _12 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "" - store_var _12 - - L1: - load_var _12 - store_var last - load_var last - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L2 - jump L3 - - L2: - load_const "document.pdf" - jump L4 - - L3: - load_var last - call baml.String.trim - - L4: - return -} - -function openai.internal._openai_headers(c: openai.ResponsesClient) -> map { - load_const "application/json" - load_const "content-type" - load_type string - load_type string - alloc_map 1 - store_var headers - load_var c - load_field .headers - store_var _4 - load_var _4 - narrow_bind map, slot=3 - pop_jump_if_false L3 - load_var _4 - store_var extra - load_type string - load_type string - load_var extra - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var name - load_var name - call baml.String.to_lower_case - store_var _15 - load_type string - load_type string - load_var2 4 7 - call baml.Map.get - store_var_load_var _17 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _17 - - L2: - load_type string - load_type string - load_var2 2 8 - load_var _17 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var c - call openai.ResponsesClient.resolved_api_key - store_var _28 - load_type string - load_var _28 - call baml.String.from - store_var _27 - load_type string - load_type string - load_var headers - load_const "authorization" - load_const "Bearer " - load_var _27 - bin_op + - call baml.Map.set - pop 1 - load_var headers - return -} - -function openai.internal._openai_image_mime(output_format: string | null) -> string { - load_var output_format - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _5 - - L0: - load_var _5 - call baml.String.trim - call baml.String.to_lower_case - store_var format - load_var format - load_const "jpeg" - cmp_op == - pop_jump_if_false L1 - jump L6 - - L1: - load_var format - load_const "jpg" - cmp_op == - pop_jump_if_false L2 - jump L5 - - L2: - load_var format - load_const "webp" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_const "image/png" - jump L7 - - L4: - load_const "image/webp" - jump L7 - - L5: - load_const "image/jpeg" - jump L7 - - L6: - load_const "image/jpeg" - - L7: - return -} - -function openai.internal._openai_media_role_error(kind: string, role: string) -> ai.errors.Failure { - load_type string - load_var kind - call baml.String.from - store_var _6 - load_type string - load_var role - call baml.String.from - store_var _8 - load_const "openai" - load_const null - load_const "OpenAI Responses only supports " - load_var _6 - bin_op + - load_const " input in user messages, found " - bin_op + - load_var _8 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function openai.internal._openai_merge_onto_last_part(item: baml.json.json, directives: map) -> void { - load_var item - store_var _3 - load_var _3 - narrow_bind map, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_const null - jump L9 - - L1: - load_type string - load_type baml.json.json - load_var _3 - load_const "content" - call baml.Map.get - store_var _8 - load_var _8 - narrow_bind baml.json.json[], slot=4 - pop_jump_if_false L2 - jump L3 - - L2: - load_const null - jump L9 - - L3: - load_var _8 - store_var parts - load_var parts - container_len - store_var _12 - load_type baml.json.json - load_var2 5 6 - load_const 1 - sub_int - call baml.Array.at - store_var _14 - load_var _14 - narrow_bind map, slot=7 - pop_jump_if_false L4 - jump L5 - - L4: - load_const null - jump L9 - - L5: - load_var _14 - store_var part - load_type string - load_type baml.json.json - load_var directives - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L6: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L7 - jump L8 - - L7: - load_var _20 - store_var key - load_type string - load_type baml.json.json - load_var2 2 11 - call baml.Map.get - store_var _26 - load_type string - load_type baml.json.json - load_var2 8 11 - load_var _26 - call baml.Map.set - pop 1 - jump L6 - - L8: - load_const null - - L9: - return -} - -function openai.internal._openai_percent_encode(raw: string) -> string { - load_const "" - store_var out - load_var raw - call baml.String.to_utf8 - call baml.Uint8Array.to_array - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L17 - - L1: - load_var _6 - store_var_load_var byte - load_const 48 - cmp_int_op >= - jump_if_false L2 - pop 1 - load_var byte - load_const 57 - cmp_int_op <= - - L2: - jump_if_false L3 - jump L4 - - L3: - pop 1 - load_var byte - load_const 65 - cmp_int_op >= - jump_if_false L4 - pop 1 - load_var byte - load_const 90 - cmp_int_op <= - - L4: - jump_if_false L5 - jump L6 - - L5: - pop 1 - load_var byte - load_const 97 - cmp_int_op >= - jump_if_false L6 - pop 1 - load_var byte - load_const 122 - cmp_int_op <= - - L6: - jump_if_false L7 - jump L8 - - L7: - pop 1 - load_var byte - load_const 45 - cmp_int_op == - - L8: - jump_if_false L9 - jump L10 - - L9: - pop 1 - load_var byte - load_const 46 - cmp_int_op == - - L10: - jump_if_false L11 - jump L12 - - L11: - pop 1 - load_var byte - load_const 95 - cmp_int_op == - - L12: - jump_if_false L13 - jump L14 - - L13: - pop 1 - load_var byte - load_const 126 - cmp_int_op == - - L14: - pop_jump_if_false L15 - jump L16 - - L15: - load_var byte - load_type int - alloc_array 1 - call baml.Uint8Array.from_array - call baml.Uint8Array.to_hex - call baml.String.to_upper_case - store_var _35 - load_var out - load_const "%" - load_var _35 - bin_op + - bin_op + - store_var out - jump L0 - - L16: - load_var byte - load_type int - alloc_array 1 - call baml.String.from_code_points - store_var _31 - load_var2 2 6 - bin_op + - store_var out - jump L0 - - L17: - load_var out - return -} - -function openai.internal._openai_prompt_content(message: ai.PromptMessage, role: string) -> (openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile)[] { - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - alloc_array 0 - store_var content - load_var message - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L25 - - L1: - load_var _6 - store_var part - load_var part - store_var _10 - load_var _10 - narrow_bind string, slot=7 - pop_jump_if_false L2 - jump L22 - - L2: - load_var part - store_var _21 - load_var _21 - narrow_bind baml.media.Image, slot=9 - pop_jump_if_false L3 - jump L17 - - L3: - load_var part - store_var _46 - load_var _46 - narrow_bind baml.media.Audio, slot=16 - pop_jump_if_false L4 - jump L13 - - L4: - load_var part - store_var _62 - load_var _62 - narrow_bind baml.media.Pdf, slot=22 - pop_jump_if_false L5 - jump L6 - - L5: - load_const "openai" - load_const null - load_const "OpenAI Responses does not support video prompt input" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L6: - load_var _62 - store_var pdf - load_var role - load_const "user" - cmp_op != - pop_jump_if_false L7 - jump L12 - - L7: - load_var pdf - load_const false - call ai.wire.resolve_media - store_var resolved - load_var pdf - call baml.media.Pdf.file - store_var_load_var _70 - load_const null - cmp_op == - pop_jump_if_false L8 - load_var pdf - call baml.media.Pdf.url - store_var _70 - - L8: - load_var _70 - call openai.internal._openai_file_name - store_var name - load_var resolved - load_field .url - store_var _74 - load_var _74 - narrow_bind string, slot=27 - pop_jump_if_false L9 - jump L11 - - L9: - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _87 - load_var resolved - load_field .base64 - store_var_load_var _92 - load_const null - cmp_op == - pop_jump_if_false L10 - load_const "" - store_var _92 - - L10: - load_type string - load_var _92 - call baml.String.from - store_var _90 - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "input_file" - load_var name - load_const "data:" - load_var _87 - bin_op + - load_const ";base64," - bin_op + - load_var _90 - bin_op + - load_const null - load_const null - init_instance openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id - call baml.Array.push - pop 1 - jump L0 - - L11: - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "input_file" - load_var name - load_const null - load_var _74 - load_const null - init_instance openai.internal.OaInputFile .type, .filename, .file_data, .file_url, .file_id - call baml.Array.push - pop 1 - jump L0 - - L12: - load_const "PDF" - load_var role - call openai.internal._openai_media_role_error - throw - - L13: - load_var _46 - store_var audio - load_var role - load_const "user" - cmp_op != - pop_jump_if_false L14 - jump L16 - - L14: - load_var audio - load_const true - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .base64 - store_var_load_var _56 - load_const null - cmp_op == - pop_jump_if_false L15 - load_const "" - store_var _56 - - L15: - load_var _56 - store_var _55 - load_var resolved - load_field .mime_type - call openai.internal._openai_audio_format - store_var _59 - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "input_audio" - load_var2 19 21 - init_instance openai.internal.OaAudioPayload .data, .format - init_instance openai.internal.OaInputAudio .type, .input_audio - call baml.Array.push - pop 1 - jump L0 - - L16: - load_const "audio" - load_var role - call openai.internal._openai_media_role_error - throw - - L17: - load_var _21 - store_var image - load_var role - load_const "user" - cmp_op != - pop_jump_if_false L18 - jump L21 - - L18: - load_var image - load_const false - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .url - store_var_load_var _28 - load_const null - cmp_op == - pop_jump_if_false L20 - load_type string - load_var resolved - load_field .mime_type - call baml.String.from - store_var _33 - load_var resolved - load_field .base64 - store_var_load_var _38 - load_const null - cmp_op == - pop_jump_if_false L19 - load_const "" - store_var _38 - - L19: - load_type string - load_var _38 - call baml.String.from - store_var _36 - load_const "data:" - load_var _33 - bin_op + - load_const ";base64," - bin_op + - load_var _36 - bin_op + - store_var _28 - - L20: - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "input_image" - load_var _28 - load_const null - load_const "auto" - init_instance openai.internal.OaInputImage .type, .image_url, .file_id, .detail - call baml.Array.push - pop 1 - jump L0 - - L21: - load_const "image" - load_var role - call openai.internal._openai_media_role_error - throw - - L22: - load_var _10 - store_var text - load_var role - load_const "assistant" - cmp_op == - pop_jump_if_false L23 - jump L24 - - L23: - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "input_text" - load_var text - init_instance openai.internal.OaInputText .type, .text - call baml.Array.push - pop 1 - jump L0 - - L24: - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - load_var content - load_const "output_text" - load_var text - init_instance openai.internal.OaOutputText .type, .text - call baml.Array.push - pop 1 - jump L0 - - L25: - load_var content - return -} - -function openai.internal._openai_prune_nulls(value: baml.json.json) -> baml.json.json { - load_var value - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var value - store_var _24 - load_var _24 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var value - jump L11 - - L2: - load_type baml.json.json - alloc_array 0 - store_var out - load_var _24 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L3: - load_var _28 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _29 - call openai.internal._openai_prune_nulls - store_var _34 - load_type baml.json.json - load_var2 11 14 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - jump L11 - - L6: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L7: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L10 - - L8: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var entry - load_var entry - load_const null - cmp_op == - pop_jump_if_false L9 - jump L7 - - L9: - load_var entry - call openai.internal._openai_prune_nulls - store_var _20 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _20 - call baml.Map.set - pop 1 - jump L7 - - L10: - load_var out - - L11: - return -} - -function openai.internal._openai_reasoning(c: openai.ResponsesClient) -> openai.internal.OaReasoningParams | null { - load_var c - load_field .reasoning_effort - load_const null - call baml.ops.equals_equals - jump_if_false L0 - pop 1 - load_var c - load_field .reasoning_summary - load_const null - call baml.ops.equals_equals - - L0: - pop_jump_if_false L1 - jump L2 - - L1: - load_var c - load_field .reasoning_effort - load_var c - load_field .reasoning_summary - init_instance openai.internal.OaReasoningParams .effort, .summary - jump L3 - - L2: - load_const null - - L3: - return -} - -function openai.internal._openai_request(c: openai.ResponsesClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - load_var input - load_field .prompt - store_var _5 - load_var input - load_field .output_type - call ai.wire.render_output_format - load_var _5 - call_indirect - store_var prompt - load_var prompt - call openai.internal.openai_lower_prompt - store_var items - load_var input - load_field .journal - store_var _11 - load_var c - load_type ai.Client - load_const "id" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var2 7 8 - call ai.wire.sanitize_for_client - call openai.internal.openai_lower_journal - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _15 - - L0: - load_var _15 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _16 - load_var _16 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var2 6 10 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var input - load_field .output_type - call openai.internal._openai_wants_image - store_var wants_image - load_var input - load_field .toolbox - load_var wants_image - call openai.internal._openai_tools - store_var tools - load_var c - load_field .model - store_var _29 - load_var c - load_field .store - store_var _31 - load_var stream - pop_jump_if_false L3 - jump L4 - - L3: - load_const null - store_var _32 - jump L5 - - L4: - load_const true - store_var _32 - - L5: - load_var c - load_field .temperature - store_var _33 - load_var c - load_field .top_p - store_var _34 - load_var c - load_field .max_output_tokens - store_var _35 - load_var c - call openai.internal._openai_reasoning - store_var _36 - load_var c - call openai.internal._openai_text - store_var _37 - load_var c - load_field .parallel_tool_calls - store_var _38 - load_var2 12 11 - call openai.internal._openai_tool_choice - store_var _40 - load_type openai.internal.OaResponsesRequest - load_var2 13 6 - load_var2 14 15 - load_var2 16 17 - load_var2 18 19 - load_var2 20 21 - load_var2 12 22 - init_instance openai.internal.OaResponsesRequest .model, .input, .store, .stream, .temperature, .top_p, .max_output_tokens, .reasoning, .text, .parallel_tool_calls, .tools, .tool_choice - call baml.json.to_json - call openai.internal._openai_prune_nulls - load_var tools - call openai.internal._openai_restore_tool_schemas - store_var pruned - load_var prompt - call openai.internal.openai_prompt_metadata - store_var _52 - load_var2 23 25 - call openai.internal._openai_apply_message_metadata - load_var c - load_field .request_body - call ai.wire.merge_request_body - store_var body - load_var c - call openai.internal._openai_url - store_var _55 - load_var c - call openai.internal._openai_headers - store_var _56 - load_var body - call baml.json.stringify - store_var _57 - load_const "POST" - load_var2 26 27 - load_var _57 - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function openai.internal._openai_response_failure(resp: openai.internal.OaResponse) -> ai.errors.Failure { - load_var resp - load_field .error - store_var _3 - load_var _3 - narrow_bind openai.internal.OaErrorBody, slot=2 - pop_jump_if_false L0 - jump L2 - - L0: - load_var resp - load_field .status - store_var_load_var _10 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "failed" - store_var _10 - - L1: - load_type string - load_var _10 - call baml.String.from - store_var _8 - load_const null - load_const "the response ended with status " - load_var _8 - bin_op + - load_const null - init_instance openai.internal.OaErrorBody .code, .message, .type - call openai.internal._openai_error_failure - jump L3 - - L2: - load_var _3 - call openai.internal._openai_error_failure - - L3: - return -} - -function openai.internal._openai_restore_tool_schemas(body: baml.json.json, tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null) -> baml.json.json { - load_var tools - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_type openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool - alloc_array 0 - store_var _4 - - L0: - load_var _4 - store_var list - load_var list - container_len - store_var _7 - load_var _7 - load_const 0 - cmp_int_op == - pop_jump_if_false L1 - jump L6 - - L1: - load_var body - store_var _8 - load_var _8 - narrow_bind map, slot=6 - pop_jump_if_false L5 - load_type string - load_type baml.json.json - load_var _8 - load_const "tools" - call baml.Map.get - store_var _13 - load_var _13 - narrow_bind baml.json.json[], slot=7 - pop_jump_if_false L5 - load_var _13 - store_var wire - load_const 0 - store_var index - load_var list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L2: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L5 - - L3: - load_var _18 - store_var _22 - load_var _22 - narrow_bind openai.internal.OaFunctionTool, slot=12 - pop_jump_if_false L4 - load_var _22 - store_var fn - load_type baml.json.json - load_var2 8 9 - call baml.Array.at - store_var _27 - load_var _27 - narrow_bind map, slot=14 - pop_jump_if_false L4 - load_type string - load_type baml.json.json - load_var _27 - load_const "parameters" - load_var fn - load_field .parameters - call baml.Map.set - pop 1 - - L4: - load_var index - load_const 1 - add_int - store_var index - jump L2 - - L5: - load_var body - jump L7 - - L6: - load_var body - - L7: - return -} - -function openai.internal._openai_sse_failure(error: unknown) -> ai.errors.Failure { - load_var error - store_var _3 - load_var _3 - narrow_bind baml.errors.Io, slot=3 - pop_jump_if_false L0 - jump L1 - - L0: - load_type unknown - load_var error - call baml.String.from - store_var text - jump L2 - - L1: - load_var _3 - load_field .message - store_var text - - L2: - load_var text - load_const "SSE request failed with status " - call baml.String.index_of - store_var _9 - load_var _9 - narrow_bind int, slot=4 - pop_jump_if_false L4 - load_var _9 - store_var _13 - load_const "SSE request failed with status " - call baml.String.length - load_var _13 - add_int - store_var _12 - load_var text - call baml.String.length - store_var _15 - load_var2 2 6 - load_var _15 - call baml.String.slice - store_var rest - load_var rest - load_const ":" - call baml.String.index_of - store_var _17 - load_var _17 - narrow_bind int, slot=9 - pop_jump_if_false L4 - load_var _17 - store_var separator - load_var rest - load_const 0 - load_var separator - call baml.String.slice - call baml.String.trim - call baml.Int.parse - store_var code - jump L3 - load_var e - throw_if_panic - load_const 0 - store_var code - - L3: - load_var code - load_const 0 - cmp_int_op > - pop_jump_if_false L4 - jump L5 - - L4: - load_type string - load_var text - call baml.String.from - store_var _33 - load_const "openai" - load_const "transport failed before a response arrived: " - load_var _33 - bin_op + - load_const null - init_instance ai.errors.NetworkFailure .provider, .detail, .raw_body - jump L6 - - L5: - load_var code - store_var _26 - load_var separator - load_const 1 - add_int - store_var _29 - load_var rest - call baml.String.length - store_var _31 - load_var2 5 15 - load_var _31 - call baml.String.slice - call baml.String.trim - store_var _27 - load_const "openai" - load_var2 13 14 - load_const - call ai.errors.classify_http - - L6: - return -} - -function openai.internal._openai_stream_events(event: openai.internal.OaStreamEvent, sse_name: string | null, state: openai.internal.OaStreamState) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - alloc_array 0 - store_var out - load_var event - load_field .type - store_var_load_var _8 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var sse_name - store_var _8 - - L0: - load_var _8 - store_var_load_var _6 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "" - store_var _6 - - L1: - load_var _6 - store_var_load_var kind - load_const "response.failed" - cmp_op != - jump_if_false L2 - pop 1 - load_var kind - load_const "error" - cmp_op != - - L2: - pop_jump_if_false L3 - load_var event - load_field .error - store_var _17 - load_var _17 - narrow_bind openai.internal.OaErrorBody, slot=8 - pop_jump_if_false L3 - jump L39 - - L3: - load_var kind - load_const "response.created" - cmp_op == - pop_jump_if_false L4 - jump L37 - - L4: - load_var kind - load_const "response.in_progress" - cmp_op == - pop_jump_if_false L5 - jump L36 - - L5: - load_var kind - load_const "response.output_text.delta" - cmp_op == - pop_jump_if_false L6 - jump L35 - - L6: - load_var kind - load_const "response.output_text.done" - cmp_op == - pop_jump_if_false L7 - jump L33 - - L7: - load_var kind - load_const "response.function_call_arguments.delta" - cmp_op == - pop_jump_if_false L8 - jump L31 - - L8: - load_var kind - load_const "response.function_call_arguments.done" - cmp_op == - pop_jump_if_false L9 - jump L30 - - L9: - load_var kind - load_const "response.failed" - cmp_op == - pop_jump_if_false L10 - jump L29 - - L10: - load_var kind - load_const "error" - cmp_op == - pop_jump_if_false L11 - jump L28 - - L11: - load_var kind - load_const "response.completed" - cmp_op == - pop_jump_if_false L12 - jump L20 - - L12: - load_var kind - load_const "response.incomplete" - cmp_op == - pop_jump_if_false L38 - load_var event - load_field .response - store_var _122 - load_var _122 - narrow_bind openai.internal.OaResponse, slot=33 - pop_jump_if_false L19 - load_var _122 - call openai.internal.openai_parse - store_var turn - load_var turn - load_field .stop_reason - store_var _128 - load_var turn - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_var turn - load_field .usage - load_field .0 - store_var _129 - jump L15 - - L14: - load_const null - store_var _129 - - L15: - load_var turn - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L16 - jump L17 - - L16: - load_var turn - load_field .usage - load_field .1 - store_var _133 - jump L18 - - L17: - load_const null - store_var _133 - - L18: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 4 35 - load_var2 36 37 - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - - L19: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - alloc_instance ai.stream.TurnDone - call baml.Array.push - pop 1 - jump L38 - - L20: - load_var event - load_field .response - store_var _101 - load_var _101 - narrow_bind openai.internal.OaResponse, slot=28 - pop_jump_if_false L27 - load_var _101 - call openai.internal.openai_parse - store_var turn - load_var turn - load_field .stop_reason - store_var _107 - load_var turn - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L21 - jump L22 - - L21: - load_var turn - load_field .usage - load_field .0 - store_var _108 - jump L23 - - L22: - load_const null - store_var _108 - - L23: - load_var turn - load_field .usage - load_const null - cmp_op == - pop_jump_if_false L24 - jump L25 - - L24: - load_var turn - load_field .usage - load_field .1 - store_var _112 - jump L26 - - L25: - load_const null - store_var _112 - - L26: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 4 30 - load_var2 31 32 - init_instance ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens - call baml.Array.push - pop 1 - - L27: - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var out - alloc_instance ai.stream.TurnDone - call baml.Array.push - pop 1 - jump L38 - - L28: - load_var event - call openai.internal._openai_stream_failure - throw - - L29: - load_var event - call openai.internal._openai_stream_failure - throw - - L30: - load_var event - load_field .arguments - store_var _87 - load_var _87 - narrow_bind string, slot=24 - pop_jump_if_false L38 - load_var _87 - store_var full - load_var state - load_field .call_arguments - store_var _90 - load_var event - call openai.internal._openai_event_key - store_var _91 - load_type string - load_type string - load_var2 26 27 - load_var full - call baml.Map.set - pop 1 - jump L38 - - L31: - load_var event - load_field .delta - store_var _67 - load_var _67 - narrow_bind string, slot=19 - pop_jump_if_false L38 - load_var _67 - store_var delta - load_var event - call openai.internal._openai_event_key - store_var key - load_var state - load_field .call_arguments - store_var _71 - load_type string - load_type string - load_var state - load_field .call_arguments - load_var key - call baml.Map.get - store_var_load_var _75 - load_const null - cmp_op == - pop_jump_if_false L32 - load_const "" - store_var _75 - - L32: - load_type string - load_type string - load_var2 22 21 - load_var2 23 20 - bin_op + - call baml.Map.set - pop 1 - jump L38 - - L33: - load_var event - call openai.internal._openai_event_key - store_var key - load_type string - load_type bool - load_var state - load_field .text_started - load_var key - call baml.Map.get - store_var_load_var _46 - load_const null - cmp_op == - pop_jump_if_false L34 - load_const false - store_var _46 - - L34: - load_var _46 - unary_op ! - pop_jump_if_false L38 - load_var event - load_field .text - store_var _54 - load_var _54 - narrow_bind string, slot=17 - pop_jump_if_false L38 - load_var _54 - store_var full - load_type string - load_type bool - load_var state - load_field .text_started - load_var key - load_const true - call baml.Map.set - pop 1 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 4 18 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - jump L38 - - L35: - load_var event - load_field .delta - store_var _31 - load_var _31 - narrow_bind string, slot=11 - pop_jump_if_false L38 - load_var _31 - store_var delta - load_var state - load_field .text_started - store_var _34 - load_var event - call openai.internal._openai_event_key - store_var _35 - load_type string - load_type bool - load_var2 13 14 - load_const true - call baml.Map.set - pop 1 - load_type ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone - load_var2 4 12 - init_instance ai.stream.TextDelta .text - call baml.Array.push - pop 1 - jump L38 - - L36: - load_var event - load_field .response - store_var _27 - load_var _27 - narrow_bind openai.internal.OaResponse, slot=10 - pop_jump_if_false L38 - load_var2 3 10 - load_field .model - store_field .model - jump L38 - - L37: - load_var event - load_field .response - store_var _23 - load_var _23 - narrow_bind openai.internal.OaResponse, slot=9 - pop_jump_if_false L38 - load_var2 3 9 - load_field .model - store_field .model - - L38: - load_var out - return - - L39: - load_var _17 - call openai.internal._openai_error_failure - throw -} - -function openai.internal._openai_stream_failure(event: openai.internal.OaStreamEvent) -> ai.errors.Failure { - load_var event - load_field .response - store_var _3 - load_var _3 - narrow_bind openai.internal.OaResponse, slot=2 - pop_jump_if_false L0 - jump L3 - - L0: - load_var event - load_field .error - store_var _7 - load_var _7 - narrow_bind openai.internal.OaErrorBody, slot=3 - pop_jump_if_false L1 - jump L2 - - L1: - load_var event - load_field .code - load_var event - load_field .message - load_const null - init_instance openai.internal.OaErrorBody .code, .message, .type - call openai.internal._openai_error_failure - jump L4 - - L2: - load_var _7 - call openai.internal._openai_error_failure - jump L4 - - L3: - load_var _3 - call openai.internal._openai_response_failure - - L4: - return -} - -function openai.internal._openai_text(c: openai.ResponsesClient) -> openai.internal.OaTextParams | null { - load_var c - load_field .verbosity - load_const null - call baml.ops.equals_equals - pop_jump_if_false L0 - jump L1 - - L0: - load_var c - load_field .verbosity - init_instance openai.internal.OaTextParams .verbosity - jump L2 - - L1: - load_const null - - L2: - return -} - -function openai.internal._openai_tool_choice(tools: (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null, wants_image: bool) -> string | openai.internal.OaToolChoiceObject | null { - load_var wants_image - pop_jump_if_false L0 - jump L3 - - L0: - load_var tools - load_const null - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_const "auto" - jump L4 - - L2: - load_const null - jump L4 - - L3: - load_const "image_generation" - init_instance openai.internal.OaToolChoiceObject .type - - L4: - return -} - -function openai.internal._openai_tools(toolbox: ai.tools.Toolbox, wants_image: bool) -> (openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool)[] | null { - load_type openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool - alloc_array 0 - store_var tools - load_var toolbox - call ai.tools.Toolbox.list - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _6 - store_var t - load_var t - load_field .name - store_var _12 - load_var t - load_field .description - store_var _13 - load_type map - load_var t - load_field .input_schema - call baml.json.to_json - store_var _14 - load_type openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool - load_var tools - load_const "function" - load_var2 7 8 - load_var _14 - load_const false - init_instance openai.internal.OaFunctionTool .type, .name, .description, .parameters, .strict - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var wants_image - pop_jump_if_false L3 - load_type openai.internal.OaFunctionTool | openai.internal.OaBuiltinTool - load_var tools - load_const "image_generation" - init_instance openai.internal.OaBuiltinTool .type - call baml.Array.push - pop 1 - - L3: - load_var tools - container_len - store_var _22 - load_var _22 - load_const 0 - cmp_int_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_var tools - jump L6 - - L5: - load_const null - - L6: - return -} - -function openai.internal._openai_transient_code(code: string) -> bool { - load_var code - load_const "server_error" - call baml.String.includes - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_var code - load_const "timeout" - call baml.String.includes - - L1: - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var code - load_const "timed_out" - call baml.String.includes - - L3: - jump_if_false L4 - jump L5 - - L4: - pop 1 - load_var code - load_const "overloaded" - call baml.String.includes - - L5: - jump_if_false L6 - jump L7 - - L6: - pop 1 - load_var code - load_const "unavailable" - call baml.String.includes - - L7: - jump_if_false L8 - jump L9 - - L8: - pop 1 - load_var code - load_const "try_again" - call baml.String.includes - - L9: - return -} - -function openai.internal._openai_url(c: openai.ResponsesClient) -> string { - load_var c - call openai.ResponsesClient.resolved_base_url - store_var_load_var _3 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "https://api.openai.com/v1" - store_var _3 - - L0: - load_var _3 - store_var base - load_var base - load_const "/" - call baml.String.ends_with - pop_jump_if_false L1 - jump L2 - - L1: - load_var base - store_var trimmed - jump L3 - - L2: - load_var base - call baml.String.length - store_var _9 - load_var base - load_const 0 - load_var _9 - load_const 1 - sub_int - call baml.String.slice - store_var trimmed - - L3: - load_type string - load_var trimmed - call baml.String.from - load_const "/responses" - bin_op + - store_var url - load_var c - load_field .query_params - store_var _15 - load_var _15 - narrow_bind map, slot=7 - pop_jump_if_false L8 - load_var _15 - store_var params - load_type string - alloc_array 0 - store_var pairs - load_type string - load_type string - load_var params - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _21 - - L4: - load_var _21 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _22 - load_var _22 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L7 - - L5: - load_var _22 - store_var_load_var key - call openai.internal._openai_percent_encode - store_var _30 - load_type string - load_var _30 - call baml.String.from - store_var _29 - load_type string - load_type string - load_var2 8 12 - call baml.Map.get - store_var_load_var _36 - load_const null - cmp_op == - pop_jump_if_false L6 - load_const "" - store_var _36 - - L6: - load_var _36 - call openai.internal._openai_percent_encode - store_var _34 - load_type string - load_var _34 - call baml.String.from - store_var _33 - load_type string - load_var2 9 13 - load_const "=" - bin_op + - load_var _33 - bin_op + - call baml.Array.push - pop 1 - jump L4 - - L7: - load_var pairs - container_len - store_var _45 - load_var _45 - load_const 0 - cmp_int_op > - pop_jump_if_false L8 - jump L9 - - L8: - load_var url - jump L10 - - L9: - load_type string - load_var url - call baml.String.from - store_var _47 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _51 - load_type string - load_var _51 - call baml.String.from - store_var _50 - load_var _47 - load_const "?" - bin_op + - load_var _50 - bin_op + - - L10: - return -} - -function openai.internal._openai_wants_image(output_type: type) -> bool { - load_var output_type - call ai.internal._media_shape - load_const ":image" - call baml.String.ends_with - return -} - -function openai.internal._reject(provider: string, detail: string) -> ai.errors.InvalidRequest { - load_var provider - load_const null - load_var detail - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function openai.internal.chat_build_request(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> openai.internal.ChatRequest { - load_var input - load_field .prompt - store_var _6 - load_var input - load_field .output_type - call ai.wire.render_output_format - load_var _6 - call_indirect - load_var compat - call openai.internal.chat_lower_prompt - store_var messages - load_var input - load_field .journal - store_var _12 - load_var2 1 2 - call openai.internal.chat_client_id - store_var _13 - load_var2 7 8 - call ai.wire.sanitize_for_client - call openai.internal.chat_lower_journal - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _16 - - L0: - load_var _16 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - load_var _17 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type openai.internal.ChatMessage - load_var2 6 10 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var compat - load_field .max_tokens_key - load_const "max_completion_tokens" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_var params - load_field .max_tokens - store_var max_tokens - jump L5 - - L4: - load_const null - store_var max_tokens - - L5: - load_var compat - load_field .max_tokens_key - load_const "max_completion_tokens" - cmp_op == - pop_jump_if_false L6 - jump L7 - - L6: - load_var params - load_field .max_completion_tokens - store_var max_completion_tokens - jump L9 - - L7: - load_var params - load_field .max_completion_tokens - store_var_load_var _30 - load_const null - cmp_op == - pop_jump_if_false L8 - load_var params - load_field .max_tokens - store_var _30 - - L8: - load_var _30 - store_var max_completion_tokens - - L9: - load_var max_tokens - load_const null - call baml.ops.equals_equals - jump_if_false L10 - pop 1 - load_var max_completion_tokens - load_const null - call baml.ops.equals_equals - - L10: - jump_if_false L11 - pop 1 - load_var params - load_field .request_body - load_const "max_tokens" - call openai.internal._chat_body_mentions - unary_op ! - - L11: - jump_if_false L12 - pop 1 - load_var params - load_field .request_body - load_const "max_completion_tokens" - call openai.internal._chat_body_mentions - unary_op ! - - L12: - pop_jump_if_false L15 - load_var compat - load_field .default_max_tokens - store_var _44 - load_var _44 - narrow_bind int, slot=14 - pop_jump_if_false L15 - load_var _44 - store_var floor - load_var compat - load_field .max_tokens_key - load_const "max_completion_tokens" - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_var floor - store_var max_tokens - jump L15 - - L14: - load_var floor - store_var max_completion_tokens - - L15: - load_var input - load_field .toolbox - call openai.internal._chat_tools - store_var tools - load_var tools - load_const null - call baml.ops.equals_equals - pop_jump_if_false L16 - jump L17 - - L16: - load_const "auto" - store_var tool_choice - jump L18 - - L17: - load_const null - store_var tool_choice - - L18: - load_var stream - pop_jump_if_false L19 - jump L20 - - L19: - load_const null - store_var stream_flag - jump L21 - - L20: - load_const true - store_var stream_flag - - L21: - load_var stream - jump_if_false L22 - pop 1 - load_var compat - load_field .send_stream_options - - L22: - pop_jump_if_false L23 - jump L24 - - L23: - load_const null - store_var stream_options - jump L25 - - L24: - load_const true - init_instance openai.internal.ChatStreamOptions .include_usage - store_var stream_options - - L25: - load_var params - load_field .model - load_var2 6 2 - load_field .temperature - load_var2 11 12 - load_var params - load_field .top_p - load_var params - load_field .stop - load_var params - load_field .seed - load_var2 16 17 - load_var2 18 19 - init_instance openai.internal.ChatRequest .model, .messages, .temperature, .max_tokens, .max_completion_tokens, .top_p, .stop, .seed, .tools, .tool_choice, .stream, .stream_options - return -} - -function openai.internal.chat_client_id(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams) -> string { - load_type string - load_var compat - load_field .provider - call baml.String.from - store_var _4 - load_type string - load_var params - load_field .model - call baml.String.from - store_var _7 - load_var _4 - load_const "/" - bin_op + - load_var _7 - bin_op + - return -} - -function openai.internal.chat_invoke(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - load_var input - load_const false - call openai.internal.chat_render - store_var request - load_var compat - load_field .provider - store_var _6 - load_var params - load_field .request_body - call openai.internal._chat_audio_output_mime - store_var _7 - load_var2 4 5 - load_var _7 - call openai.internal._chat_send - return -} - -function openai.internal.chat_invoke_stream(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var ?5 - make_cell - store_var ?5 - load_var2 1 2 - load_var input - load_const true - call openai.internal.chat_render - store_var request - load_var compat - load_field .provider - call openai.internal.ChatStreamDecoder.new - store_deref ?5 - load_var request - sys_op baml.http.fetch_sse - jump L0 - load_var e - throw_if_panic - load_var compat - load_field .provider - store_var _11 - load_type baml.errors.Io | baml.errors.Timeout - load_var e - call baml.String.from - store_var _12 - load_var2 7 8 - call openai.internal._chat_stream_failure - throw - - L0: - load_var decoder - make_closure ., 1 - load_var compat - load_field .provider - call ai.stream.TurnStream.from_sse - return -} - -function openai.internal.chat_lower_journal(j: ai.Journal) -> openai.internal.ChatMessage[] { - load_type openai.internal.ChatMessage - alloc_array 0 - store_var out - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L21 - - L1: - load_var _5 - store_var event - load_var event - store_var _9 - load_var _9 - narrow_bind ai.events.UserMessage, slot=6 - pop_jump_if_false L2 - jump L20 - - L2: - load_var event - store_var _15 - load_var _15 - narrow_bind ai.events.AssistantMessage, slot=7 - pop_jump_if_false L3 - jump L6 - - L3: - load_var event - store_var _62 - load_var _62 - narrow_bind ai.events.ToolCompleted, slot=25 - pop_jump_if_false L4 - jump L5 - - L4: - load_var event - store_var _69 - load_var _69 - narrow_bind ai.events.ToolFailed, slot=27 - pop_jump_if_false L0 - load_var _69 - store_var failed - load_type map - load_var failed - load_field .message - load_const "error" - load_type string - load_type string - alloc_map 1 - call baml.json.to_json - call baml.json.stringify - store_var _75 - load_type openai.internal.ChatMessage - load_var out - load_const "tool" - load_var _75 - load_const null - load_var failed - load_field .id - init_instance openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _62 - store_var completed - load_type openai.internal.ChatMessage - load_var out - load_const "tool" - load_var completed - load_field .output - load_const null - load_var completed - load_field .id - init_instance openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id - call baml.Array.push - pop 1 - jump L0 - - L6: - load_const "" - store_var text - load_type openai.internal.ChatToolCall - alloc_array 0 - store_var calls - load_var _15 - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - - L7: - load_var _20 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _21 - load_var _21 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L11 - - L8: - load_var _21 - store_var block - load_var block - store_var _25 - load_var _25 - narrow_bind ai.content.Text, slot=13 - pop_jump_if_false L9 - jump L10 - - L9: - load_var block - store_var _33 - load_var _33 - narrow_bind ai.content.ToolUse, slot=17 - pop_jump_if_false L7 - load_var _33 - store_var use - load_var use - load_field .id - store_var _37 - load_var use - load_field .name - store_var _39 - load_type map - load_var use - load_field .args - call baml.json.to_json - call baml.json.stringify - store_var _40 - load_type openai.internal.ChatToolCall - load_var2 9 19 - load_const "function" - load_var2 20 21 - init_instance openai.internal.ChatToolCallFunction .name, .arguments - init_instance openai.internal.ChatToolCall .id, .type, .fn - call baml.Array.push - pop 1 - jump L7 - - L10: - load_var _25 - store_var t - load_type string - load_var text - call baml.String.from - store_var _27 - load_type string - load_var t - load_field .text - call baml.String.from - store_var _30 - load_var2 15 16 - bin_op + - store_var text - jump L7 - - L11: - load_var text - load_const "" - cmp_op == - pop_jump_if_false L12 - jump L13 - - L12: - load_var text - store_var content - jump L14 - - L13: - load_const null - store_var content - - L14: - load_var calls - container_len - store_var _50 - load_var _50 - load_const 0 - cmp_int_op == - pop_jump_if_false L15 - jump L16 - - L15: - load_var calls - store_var tool_calls - jump L17 - - L16: - load_const null - store_var tool_calls - - L17: - load_var content - load_const null - call baml.ops.equals_equals - unary_op ! - jump_if_false L18 - jump L19 - - L18: - pop 1 - load_var tool_calls - load_const null - call baml.ops.equals_equals - unary_op ! - - L19: - pop_jump_if_false L0 - load_type openai.internal.ChatMessage - load_var out - load_const "assistant" - load_var2 22 23 - load_const null - init_instance openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id - call baml.Array.push - pop 1 - jump L0 - - L20: - load_type openai.internal.ChatMessage - load_var out - load_const "user" - load_var _9 - load_field .content - load_const null - load_const null - init_instance openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id - call baml.Array.push - pop 1 - jump L0 - - L21: - load_var out - return -} - -function openai.internal.chat_lower_prompt(prompt: ai.Prompt, compat: openai.internal.ChatCompat) -> openai.internal.ChatMessage[] { - load_type openai.internal.ChatPromptMessage - alloc_array 0 - store_var lowered - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L11 - - L1: - load_var _6 - store_var message - load_var message - load_field .role - store_var_load_var _11 - load_const "" - cmp_op == - pop_jump_if_false L2 - jump L5 - - L2: - load_var _11 - load_const "tool" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_var message - load_field .role - store_var role - jump L6 - - L4: - load_const "user" - store_var role - jump L6 - - L5: - load_var compat - load_field .default_role - store_var role - - L6: - load_var2 6 2 - call openai.internal._chat_prompt_parts - store_var parts - load_var2 9 6 - load_field .metadata - call openai.internal._chat_apply_metadata - pop 1 - load_const false - store_var merged - load_var lowered - container_len - store_var _22 - load_type openai.internal.ChatPromptMessage - load_var2 3 11 - load_const 1 - sub_int - call baml.Array.at - store_var _24 - load_var _24 - narrow_bind openai.internal.ChatPromptMessage, slot=12 - pop_jump_if_false L10 - load_var _24 - store_var_load_var last - load_field .role - load_var role - cmp_op == - pop_jump_if_false L10 - load_var parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _30 - - L7: - load_var _30 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _31 - load_var _31 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L9 - - L8: - load_type openai.internal.ChatTextPart | openai.internal.ChatImagePart | openai.internal.ChatAudioPart | openai.internal.ChatFilePart | openai.internal.ChatExtraPart - load_var last - load_field .parts - load_var _31 - call baml.Array.push - pop 1 - jump L7 - - L9: - load_const true - store_var merged - - L10: - load_var merged - unary_op ! - pop_jump_if_false L0 - load_type openai.internal.ChatPromptMessage - load_var2 3 7 - load_var parts - init_instance openai.internal.ChatPromptMessage .role, .parts - call baml.Array.push - pop 1 - jump L0 - - L11: - load_type openai.internal.ChatMessage - alloc_array 0 - store_var out - load_var lowered - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _48 - - L12: - load_var _48 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _49 - load_var _49 - is_type baml.iter.Done - pop_jump_if_false L13 - jump L14 - - L13: - load_var _49 - store_var message - load_var message - load_field .role - store_var _55 - load_var message - load_field .parts - load_var compat - load_field .collapse_text_content - call openai.internal._chat_content - store_var _56 - load_type openai.internal.ChatMessage - load_var2 16 20 - load_var _56 - load_const null - load_const null - init_instance openai.internal.ChatMessage .role, .content, .tool_calls, .tool_call_id - call baml.Array.push - pop 1 - jump L12 - - L14: - load_var out - return -} - -function openai.internal.chat_parse(response: openai.internal.CcResponse, provider: string, raw: string, audio_mime: string) -> ai.ModelTurn { - load_var audio_mime - load_const - cmp_op == - pop_jump_if_false L0 - load_const "audio/wav" - store_var audio_mime - - L0: - load_var response - load_field .choices - store_var_load_var _7 - load_const null - cmp_op == - pop_jump_if_false L1 - load_type openai.internal.CcChoice - alloc_array 0 - store_var _7 - - L1: - load_type openai.internal.CcChoice - load_var _7 - load_const 0 - call baml.Array.at - store_var _13 - load_var _13 - narrow_bind openai.internal.CcChoice, slot=7 - pop_jump_if_false L2 - jump L3 - - L2: - load_var2 2 3 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L3: - load_var _13 - store_var choice - load_var choice - load_field .message - store_var _18 - load_var _18 - narrow_bind openai.internal.CcMessage, slot=9 - pop_jump_if_false L4 - jump L5 - - L4: - load_var2 2 3 - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L5: - load_var _18 - store_var message - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_var message - load_field .reasoning_content - store_var _23 - load_var _23 - narrow_bind string, slot=11 - pop_jump_if_false L6 - load_var _23 - store_var_load_var reasoning - load_const "" - cmp_op != - pop_jump_if_false L6 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 12 - init_instance ai.content.Reasoning .summary - call baml.Array.push - pop 1 - - L6: - load_var message - load_field .content - store_var _31 - load_var _31 - store_var _32 - load_var _32 - narrow_bind string, slot=14 - pop_jump_if_false L7 - jump L16 - - L7: - load_var _31 - store_var _38 - load_var _38 - narrow_bind openai.internal.CcContentPart[], slot=15 - pop_jump_if_false L17 - load_var _38 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _41 - - L8: - load_var _41 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _42 - load_var _42 - is_type baml.iter.Done - pop_jump_if_false L9 - jump L17 - - L9: - load_var _42 - store_var_load_var part - load_field .type - store_var_load_var _47 - load_const null - cmp_op == - pop_jump_if_false L10 - load_const "" - store_var _47 - - L10: - load_var _47 - load_const "image_url" - cmp_op == - pop_jump_if_false L11 - jump L12 - - L11: - load_var part - load_field .text - store_var _63 - load_var _63 - narrow_bind string, slot=22 - pop_jump_if_false L8 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 22 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L8 - - L12: - load_var part - load_field .image_url - load_const null - cmp_op == - pop_jump_if_false L13 - jump L14 - - L13: - load_var part - load_field .image_url - load_field .0 - jump L15 - - L14: - load_const null - - L15: - store_var _56 - load_var _56 - narrow_bind string, slot=20 - pop_jump_if_false L8 - load_var _56 - call openai.internal._chat_media_block - store_var _59 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 21 - call baml.Array.push - pop 1 - jump L8 - - L16: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 14 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - - L17: - load_var message - load_field .images - store_var_load_var _70 - load_const null - cmp_op == - pop_jump_if_false L18 - load_type openai.internal.CcMessageImage - alloc_array 0 - store_var _70 - - L18: - load_var _70 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _74 - - L19: - load_var _74 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _75 - load_var _75 - is_type baml.iter.Done - pop_jump_if_false L20 - jump L25 - - L20: - load_var _75 - store_var_load_var image - load_field .image_url - load_const null - cmp_op == - pop_jump_if_false L21 - jump L22 - - L21: - load_var image - load_field .image_url - load_field .0 - jump L23 - - L22: - load_const null - - L23: - store_var_load_var _80 - load_const null - cmp_op == - pop_jump_if_false L24 - load_var image - load_field .url - store_var _80 - - L24: - load_var _80 - store_var _86 - load_var _86 - narrow_bind string, slot=28 - pop_jump_if_false L19 - load_var _86 - call openai.internal._chat_media_block - store_var _89 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 29 - call baml.Array.push - pop 1 - jump L19 - - L25: - load_var message - load_field .audio - store_var _93 - load_var _93 - narrow_bind openai.internal.CcMessageAudio, slot=30 - pop_jump_if_false L27 - load_var _93 - store_var_load_var audio - load_field .transcript - store_var _96 - load_var _96 - narrow_bind string, slot=32 - pop_jump_if_false L26 - load_var _96 - store_var_load_var transcript - load_const "" - cmp_op != - pop_jump_if_false L26 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 33 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - - L26: - load_var audio - load_field .data - store_var _105 - load_var _105 - narrow_bind string, slot=34 - pop_jump_if_false L27 - load_var _105 - store_var_load_var data - load_const "" - cmp_op != - pop_jump_if_false L27 - load_var2 35 4 - call baml.media.Audio.from_base64 - load_var audio - load_field .id - load_const - call ai.content.Media.new - store_var _110 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 36 - call baml.Array.push - pop 1 - - L27: - load_var message - load_field .tool_calls - store_var_load_var _116 - load_const null - cmp_op == - pop_jump_if_false L28 - load_type openai.internal.CcToolCall - alloc_array 0 - store_var _116 - - L28: - load_var _116 - store_var calls - load_var2 10 37 - load_var provider - call openai.internal._chat_push_tool_uses - pop 1 - load_var message - load_field .refusal - store_var _123 - load_var _123 - narrow_bind string, slot=39 - pop_jump_if_false L29 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 39 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - - L29: - load_var calls - container_len - store_var _131 - load_var _131 - load_const 0 - cmp_int_op > - pop_jump_if_false L30 - jump L35 - - L30: - load_var message - load_field .refusal - load_const null - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L31 - jump L34 - - L31: - load_var choice - load_field .finish_reason - store_var _136 - load_var _136 - narrow_bind string, slot=42 - pop_jump_if_false L32 - jump L33 - - L32: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - jump L36 - - L33: - load_var _136 - call openai.internal.chat_stop_reason - store_var stop - jump L36 - - L34: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - store_var stop - jump L36 - - L35: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - store_var stop - - L36: - load_var response - load_field .usage - store_var _141 - load_var _141 - narrow_bind openai.internal.CcUsage, slot=44 - pop_jump_if_false L37 - jump L38 - - L37: - load_const null - store_var usage - jump L47 - - L38: - load_var _141 - store_var_load_var u - load_field .prompt_tokens - store_var_load_var _144 - load_const null - cmp_op == - pop_jump_if_false L39 - load_const 0 - store_var _144 - - L39: - load_var _144 - store_var _143 - load_var u - load_field .completion_tokens - store_var_load_var _148 - load_const null - cmp_op == - pop_jump_if_false L40 - load_const 0 - store_var _148 - - L40: - load_var _148 - store_var _147 - load_var u - load_field .prompt_tokens_details - load_const null - cmp_op == - pop_jump_if_false L41 - jump L42 - - L41: - load_var u - load_field .prompt_tokens_details - load_field .0 - store_var _151 - jump L43 - - L42: - load_const null - store_var _151 - - L43: - load_var u - load_field .completion_tokens_details - load_const null - cmp_op == - pop_jump_if_false L44 - jump L45 - - L44: - load_var u - load_field .completion_tokens_details - load_field .0 - store_var _155 - jump L46 - - L45: - load_const null - store_var _155 - - L46: - load_var2 46 48 - load_var2 50 51 - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L47: - load_var2 10 40 - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return -} - -function openai.internal.chat_render(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { - load_var2 1 2 - load_var2 3 4 - call openai.internal.chat_build_request - store_var request - load_var2 1 2 - call openai.internal._chat_url - store_var _6 - load_var2 1 2 - call openai.internal._chat_headers - store_var _7 - load_var2 1 2 - load_var request - call openai.internal.chat_render_body - store_var _8 - load_const "POST" - load_var2 6 7 - load_var _8 - init_instance baml.http.Request .method, .url, .headers, .body - return -} - -function openai.internal.chat_render_body(compat: openai.internal.ChatCompat, params: openai.internal.ChatParams, request: openai.internal.ChatRequest) -> string { - load_type openai.internal.ChatRequest - load_var request - call baml.json.from - call openai.internal._chat_prune_nulls - call openai.internal._chat_apply_directives - load_var params - load_field .request_body - call ai.wire.merge_request_body - call baml.json.stringify - return -} - -function openai.internal.chat_stop_reason(reason: string) -> ai.content.StopReason { - load_var reason - load_const "tool_calls" - cmp_op == - pop_jump_if_false L0 - jump L9 - - L0: - load_var reason - load_const "function_call" - cmp_op == - pop_jump_if_false L1 - jump L8 - - L1: - load_var reason - load_const "length" - cmp_op == - pop_jump_if_false L2 - jump L7 - - L2: - load_var reason - load_const "max_tokens" - cmp_op == - pop_jump_if_false L3 - jump L6 - - L3: - load_var reason - load_const "content_filter" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - jump L10 - - L5: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - jump L10 - - L6: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L10 - - L7: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - jump L10 - - L8: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - jump L10 - - L9: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - - L10: - return -} - -function openai.internal.images_invoke(c: openai.ImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call openai.internal.images_render - store_var req - load_type openai.internal.OaImagesResponse - load_var req - load_const "openai-images" - call ai.wire.send_as - store_var resp - load_var2 1 4 - call openai.internal.images_parse - return -} - -function openai.internal.images_parse(c: openai.ImageClient, resp: openai.internal.OaImagesResponse) -> ai.ModelTurn { - load_var resp - load_field .output_format - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var c - load_field .output_format - store_var _5 - - L0: - load_var _5 - call openai.internal._oai_images_mime - store_var mime - load_var resp - load_field .data - store_var_load_var _9 - load_const null - cmp_op == - pop_jump_if_false L1 - load_type openai.internal.OaImageDatum - alloc_array 0 - store_var _9 - - L1: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_var _9 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _14 - - L2: - load_var _14 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _15 - load_var _15 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L4 - - L3: - load_var2 8 3 - call openai.internal._oai_images_block - store_var _22 - load_var _22 - narrow_bind ai.content.Media, slot=9 - pop_jump_if_false L2 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 6 9 - call baml.Array.push - pop 1 - jump L2 - - L4: - load_var content - container_len - store_var _28 - load_var _28 - load_const 0 - cmp_int_op == - pop_jump_if_false L5 - jump L11 - - L5: - load_var resp - load_field .usage - store_var _32 - load_var _32 - narrow_bind openai.internal.OaImagesUsage, slot=12 - pop_jump_if_false L6 - jump L7 - - L6: - load_const null - store_var usage - jump L10 - - L7: - load_var _32 - store_var_load_var reported - load_field .input_tokens - store_var_load_var _35 - load_const null - cmp_op == - pop_jump_if_false L8 - load_const 0 - store_var _35 - - L8: - load_var _35 - store_var _34 - load_var reported - load_field .output_tokens - store_var_load_var _39 - load_const null - cmp_op == - pop_jump_if_false L9 - load_const 0 - store_var _39 - - L9: - load_var2 14 16 - load_const null - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L10: - load_var content - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return - - L11: - load_const "openai-images" - load_const "the images response contained no image data in data[]" - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function openai.internal.images_render(c: openai.ImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var input - load_field .toolbox - call ai.tools.Toolbox.is_empty - unary_op ! - pop_jump_if_false L0 - jump L2 - - L0: - load_var input - load_field .journal - store_var _8 - load_var c - call openai.internal._oai_images_client_id - store_var _9 - load_var2 4 5 - call ai.wire.sanitize_for_client - store_var journal - load_const "" - load_var input - load_field .prompt - call_indirect - load_var journal - call openai.internal._oai_images_prompt_text - store_var text - load_var c - load_field .model - store_var _15 - load_var c - load_field .n - store_var _17 - load_var c - load_field .size - store_var _18 - load_var c - load_field .quality - store_var _19 - load_var c - load_field .background - store_var _20 - load_var c - load_field .output_format - store_var _21 - load_var c - load_field .output_compression - store_var _22 - load_var c - load_field .moderation - store_var _23 - load_var c - load_field .style - store_var _24 - load_var c - load_field .user - store_var _25 - load_var c - load_field .model - load_var c - load_field .response_format - call openai.internal._oai_images_response_format - store_var _26 - load_type openai.internal.OaImagesRequest - load_var2 7 6 - load_var2 8 9 - load_var2 10 11 - load_var2 12 13 - load_var2 14 15 - load_var2 16 17 - init_instance openai.internal.OaImagesRequest .model, .prompt, .n, .size, .quality, .background, .output_format, .output_compression, .moderation, .style, .user, .response_format - call baml.json.to_json - call openai.internal._oai_images_drop_nulls - load_var c - load_field .request_body - call ai.wire.merge_request_body - store_var merged - load_var c - call openai.ImageClient.resolved_base_url - store_var_load_var _41 - load_const null - cmp_op == - pop_jump_if_false L1 - load_const "https://api.openai.com/v1" - store_var _41 - - L1: - load_var _41 - call openai.internal._oai_images_trim_slash - store_var _39 - load_type string - load_var _39 - call baml.String.from - load_const "/images/generations" - bin_op + - load_var c - load_field .query_params - call openai.internal._oai_images_with_query - store_var url - load_var c - call openai.internal._oai_images_headers - store_var _47 - load_var merged - call baml.json.stringify - store_var _48 - load_const "POST" - load_var2 19 22 - load_var _48 - init_instance baml.http.Request .method, .url, .headers, .body - return - - L2: - load_const "openai-images" - load_const null - load_const "the Images API has no tool calling; run tools with a chat client instead" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function openai.internal.invoke(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call openai.internal.openai_render - store_var req - load_type openai.internal.OaResponse - load_var req - load_const "openai" - call ai.wire.send_as - call openai.internal.openai_parse - return -} - -function openai.internal.invoke_stream(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { - load_var ?5 - make_cell - store_var ?5 - load_var2 1 2 - load_const true - call openai.internal._openai_request - sys_op baml.http.fetch_sse - store_var sse - jump L0 - load_var e - throw_if_panic - load_var e - call openai.internal._openai_sse_failure - throw - - L0: - call openai.internal.OaStreamState.new - store_deref ?5 - load_var2 3 5 - make_closure ., 1 - load_const "openai" - call ai.stream.TurnStream.from_sse - return -} - -function openai.internal.openai_lower_journal(j: ai.Journal) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - alloc_array 0 - store_var items - load_var j - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L12 - - L1: - load_var _5 - store_var e - load_var e - store_var _9 - load_var _9 - narrow_bind ai.events.UserMessage, slot=6 - pop_jump_if_false L2 - jump L11 - - L2: - load_var e - store_var _17 - load_var _17 - narrow_bind ai.events.AssistantMessage, slot=7 - pop_jump_if_false L3 - jump L6 - - L3: - load_var e - store_var _44 - load_var _44 - narrow_bind ai.events.ToolCompleted, slot=17 - pop_jump_if_false L4 - jump L5 - - L4: - load_var e - store_var _51 - load_var _51 - narrow_bind ai.events.ToolFailed, slot=19 - pop_jump_if_false L0 - load_var _51 - store_var f - load_type string - load_type unknown - alloc_map 0 - store_var err - load_type string - load_type unknown - load_var err - load_const "error" - load_var f - load_field .message - call baml.Map.set - pop 1 - load_var f - load_field .id - store_var _60 - load_type map - load_var err - call baml.json.to_json - call baml.json.stringify - store_var _61 - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var items - load_const "function_call_output" - load_var2 22 23 - init_instance openai.internal.OaFunctionCallOutputItem .type, .call_id, .output - call baml.Array.push - pop 1 - jump L0 - - L5: - load_var _44 - store_var c - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var items - load_const "function_call_output" - load_var c - load_field .id - load_var c - load_field .output - init_instance openai.internal.OaFunctionCallOutputItem .type, .call_id, .output - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var _17 - load_field .content - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - - L7: - load_var _20 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _21 - load_var _21 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L0 - - L8: - load_var _21 - store_var b - load_var b - store_var _25 - load_var _25 - narrow_bind ai.content.Text, slot=11 - pop_jump_if_false L9 - jump L10 - - L9: - load_var b - store_var _33 - load_var _33 - narrow_bind ai.content.ToolUse, slot=12 - pop_jump_if_false L7 - load_var _33 - store_var use - load_var use - load_field .id - store_var _37 - load_var use - load_field .name - store_var _38 - load_type map - load_var use - load_field .args - call baml.json.to_json - call baml.json.stringify - store_var _39 - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var items - load_const "function_call" - load_var2 14 15 - load_var _39 - init_instance openai.internal.OaFunctionCallItem .type, .call_id, .name, .arguments - call baml.Array.push - pop 1 - jump L7 - - L10: - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var items - load_const "assistant" - load_const "output_text" - load_var _25 - load_field .text - init_instance openai.internal.OaOutputText .type, .text - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - alloc_array 1 - init_instance openai.internal.OaMessageItem .role, .content - call baml.Array.push - pop 1 - jump L7 - - L11: - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var items - load_const "user" - load_const "input_text" - load_var _9 - load_field .content - init_instance openai.internal.OaInputText .type, .text - load_type openai.internal.OaInputText | openai.internal.OaOutputText | openai.internal.OaInputImage | openai.internal.OaInputAudio | openai.internal.OaInputFile - alloc_array 1 - init_instance openai.internal.OaMessageItem .role, .content - call baml.Array.push - pop 1 - jump L0 - - L12: - load_var items - return -} - -function openai.internal.openai_lower_prompt(prompt: ai.Prompt) -> (openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem)[] { - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - alloc_array 0 - store_var items - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L7 - - L1: - load_var _5 - store_var message - load_var message - load_field .role - store_var_load_var _10 - load_const "" - cmp_op == - pop_jump_if_false L2 - jump L5 - - L2: - load_var _10 - load_const "tool" - cmp_op == - pop_jump_if_false L3 - jump L4 - - L3: - load_var message - load_field .role - store_var role - jump L6 - - L4: - load_const "user" - store_var role - jump L6 - - L5: - load_const "user" - store_var role - - L6: - load_var role - store_var _15 - load_var2 5 6 - call openai.internal._openai_prompt_content - store_var _16 - load_type openai.internal.OaMessageItem | openai.internal.OaFunctionCallItem | openai.internal.OaFunctionCallOutputItem - load_var2 2 8 - load_var _16 - init_instance openai.internal.OaMessageItem .role, .content - call baml.Array.push - pop 1 - jump L0 - - L7: - load_var items - return -} - -function openai.internal.openai_parse(resp: openai.internal.OaResponse) -> ai.ModelTurn { - load_var resp - load_field .status - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "" - store_var _5 - - L0: - load_var _5 - load_const "failed" - cmp_op == - jump_if_false L1 - jump L2 - - L1: - pop 1 - load_var resp - load_field .error - load_const null - call baml.ops.equals_equals - unary_op ! - - L2: - pop_jump_if_false L3 - jump L53 - - L3: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_const false - store_var has_call - load_const false - store_var refused - load_var resp - load_field .output - store_var_load_var _15 - load_const null - cmp_op == - pop_jump_if_false L4 - load_type openai.internal.OaOutputItem - alloc_array 0 - store_var _15 - - L4: - load_var _15 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L5: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L27 - - L6: - load_var _20 - store_var item - load_var item - load_field .type - store_var_load_var _24 - load_const "function_call" - cmp_op == - pop_jump_if_false L7 - jump L23 - - L7: - load_var _24 - load_const "message" - cmp_op == - pop_jump_if_false L8 - jump L14 - - L8: - load_var _24 - load_const "reasoning" - cmp_op == - pop_jump_if_false L9 - jump L10 - - L9: - load_var _24 - load_const "image_generation_call" - cmp_op == - pop_jump_if_false L5 - load_var item - load_field .result - store_var _98 - load_var _98 - narrow_bind string, slot=30 - pop_jump_if_false L5 - load_var _98 - store_var encoded - load_var item - load_field .output_format - call openai.internal._openai_image_mime - store_var mime - load_var2 31 32 - call baml.media.Image.from_base64 - load_var item - load_field .id - load_var item - load_field .revised_prompt - call ai.content.Media.new - store_var _103 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 33 - call baml.Array.push - pop 1 - jump L5 - - L10: - load_var item - load_field .summary - store_var_load_var _80 - load_const null - cmp_op == - pop_jump_if_false L11 - load_type openai.internal.OaContentPart - alloc_array 0 - store_var _80 - - L11: - load_var _80 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _84 - - L12: - load_var _84 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _85 - load_var _85 - is_type baml.iter.Done - pop_jump_if_false L13 - jump L5 - - L13: - load_var _85 - load_field .text - store_var _90 - load_var _90 - narrow_bind string, slot=29 - pop_jump_if_false L12 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 29 - init_instance ai.content.Reasoning .summary - call baml.Array.push - pop 1 - jump L12 - - L14: - load_var item - load_field .content - store_var_load_var _49 - load_const null - cmp_op == - pop_jump_if_false L15 - load_type openai.internal.OaContentPart - alloc_array 0 - store_var _49 - - L15: - load_var _49 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _53 - - L16: - load_var _53 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _54 - load_var _54 - is_type baml.iter.Done - pop_jump_if_false L17 - jump L5 - - L17: - load_var _54 - store_var_load_var part - load_field .type - store_var_load_var _59 - load_const null - cmp_op == - pop_jump_if_false L18 - load_const "" - store_var _59 - - L18: - load_var _59 - store_var_load_var kind - load_const "output_text" - cmp_op == - pop_jump_if_false L19 - jump L21 - - L19: - load_var kind - load_const "refusal" - cmp_op == - pop_jump_if_false L16 - load_const true - store_var refused - load_var part - load_field .refusal - store_var_load_var _74 - load_const null - cmp_op == - pop_jump_if_false L20 - load_const "" - store_var _74 - - L20: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 25 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L16 - - L21: - load_var part - load_field .text - store_var_load_var _66 - load_const null - cmp_op == - pop_jump_if_false L22 - load_const "" - store_var _66 - - L22: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 24 - init_instance ai.content.Text .text - call baml.Array.push - pop 1 - jump L16 - - L23: - load_const true - store_var has_call - load_type string - load_type unknown - alloc_map 0 - store_var args - load_var item - load_field .arguments - store_var _28 - load_var _28 - narrow_bind string, slot=12 - pop_jump_if_false L24 - load_var _28 - store_var s - load_type map - load_var s - call baml.json.from_string - store_var args - jump L24 - load_var e - throw_if_panic - load_const "openai" - load_var s - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L24: - load_var item - load_field .call_id - store_var_load_var _38 - load_const null - cmp_op == - pop_jump_if_false L25 - load_const "" - store_var _38 - - L25: - load_var _38 - store_var _37 - load_var item - load_field .name - store_var_load_var _42 - load_const null - cmp_op == - pop_jump_if_false L26 - load_const "" - store_var _42 - - L26: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 3 15 - load_var2 17 11 - init_instance ai.content.ToolUse .id, .name, .args - call baml.Array.push - pop 1 - jump L5 - - L27: - load_var has_call - pop_jump_if_false L28 - jump L40 - - L28: - load_var refused - pop_jump_if_false L29 - jump L39 - - L29: - load_var resp - load_field .status - store_var_load_var _115 - load_const null - cmp_op == - pop_jump_if_false L30 - load_const "" - store_var _115 - - L30: - load_var _115 - load_const "incomplete" - cmp_op == - pop_jump_if_false L31 - jump L32 - - L31: - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - store_var stop - jump L41 - - L32: - load_var resp - load_field .incomplete_details - load_const null - cmp_op == - pop_jump_if_false L33 - jump L34 - - L33: - load_var resp - load_field .incomplete_details - load_field .0 - jump L35 - - L34: - load_const null - - L35: - store_var_load_var _120 - load_const null - cmp_op == - pop_jump_if_false L36 - load_const "" - store_var _120 - - L36: - load_var _120 - load_const "content_filter" - cmp_op == - pop_jump_if_false L37 - jump L38 - - L37: - load_const ai.content.StopReason.MaxTokens - alloc_variant ai.content.StopReason - store_var stop - jump L41 - - L38: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - store_var stop - jump L41 - - L39: - load_const ai.content.StopReason.Refused - alloc_variant ai.content.StopReason - store_var stop - jump L41 - - L40: - load_const ai.content.StopReason.ToolUse - alloc_variant ai.content.StopReason - store_var stop - - L41: - load_var resp - load_field .usage - store_var _128 - load_var _128 - narrow_bind openai.internal.OaUsage, slot=38 - pop_jump_if_false L42 - jump L43 - - L42: - load_const null - store_var usage - jump L52 - - L43: - load_var _128 - store_var_load_var u - load_field .input_tokens - store_var_load_var _131 - load_const null - cmp_op == - pop_jump_if_false L44 - load_const 0 - store_var _131 - - L44: - load_var _131 - store_var _130 - load_var u - load_field .output_tokens - store_var_load_var _135 - load_const null - cmp_op == - pop_jump_if_false L45 - load_const 0 - store_var _135 - - L45: - load_var _135 - store_var _134 - load_var u - load_field .input_tokens_details - load_const null - cmp_op == - pop_jump_if_false L46 - jump L47 - - L46: - load_var u - load_field .input_tokens_details - load_field .0 - store_var _138 - jump L48 - - L47: - load_const null - store_var _138 - - L48: - load_var u - load_field .output_tokens_details - load_const null - cmp_op == - pop_jump_if_false L49 - jump L50 - - L49: - load_var u - load_field .output_tokens_details - load_field .0 - store_var _142 - jump L51 - - L50: - load_const null - store_var _142 - - L51: - load_var2 40 42 - load_var2 44 45 - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L52: - load_var2 3 34 - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return - - L53: - load_var resp - call openai.internal._openai_response_failure - throw -} - -function openai.internal.openai_prompt_metadata(prompt: ai.Prompt) -> map[] { - load_type map - alloc_array 0 - store_var out - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type map - load_var2 2 4 - load_field .metadata - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var out - return -} - -function openai.internal.openai_render(c: openai.ResponsesClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var2 1 2 - load_const false - call openai.internal._openai_request - return -} - -function testing.$invoke_collector(collector: (testing.TestCollector) -> void throws unknown, c: testing.TestCollector) -> void { - load_var2 2 1 - call_indirect - return -} - -function testing.FailFast() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - make_closure ., 0 - return -} - -function testing.PassRate(threshold: float) -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - load_var ?1 - make_cell - store_var ?1 - load_deref ?1 - load_const 0.0 - cmp_float_op < - jump_if_false L0 - jump L1 - - L0: - pop 1 - load_deref ?1 - load_const 1.0 - cmp_float_op > - - L1: - pop_jump_if_false L2 - load_const "testing.PassRate requires 0.0 <= threshold <= 1.0" - call baml.sys.panic - pop 1 - - L2: - load_var threshold - make_closure ., 1 - return -} - -function testing.Quorum(n: int, m: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - load_var ?1 - make_cell - store_var ?1 - load_var ?2 - make_cell - store_var ?2 - load_deref ?1 - load_const 0 - cmp_int_op <= - pop_jump_if_false L0 - jump L3 - - L0: - load_deref ?2 - load_const 0 - cmp_int_op < - jump_if_false L1 - jump L2 - - L1: - pop 1 - load_deref ?2 - load_deref ?1 - cmp_int_op > - - L2: - pop_jump_if_false L4 - load_const "testing.Quorum requires 0 <= m <= n" - call baml.sys.panic - pop 1 - jump L4 - - L3: - load_const "testing.Quorum requires n > 0" - call baml.sys.panic - pop 1 - - L4: - load_var2 1 2 - make_closure ., 2 - return -} - -function testing.Retry(max_attempts: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { - load_var ?1 - make_cell - store_var ?1 - load_deref ?1 - load_const 0 - cmp_int_op <= - pop_jump_if_false L0 - load_const "testing.Retry requires max_attempts > 0" - call baml.sys.panic - pop 1 - - L0: - load_var max_attempts - make_closure ., 1 - return -} - -function testing.Sequential() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { - make_closure ., 0 - return -} - -function testing.TestCollector.find_test(self: testing.TestCollector, name: string) -> testing.TestRegistration { - load_var self - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var t - load_field .name - load_var name - cmp_op == - pop_jump_if_false L0 - load_var t - return - - L2: - load_const "Test not found: " - load_var name - bin_op + - throw -} - -function testing.TestCollector.find_testset(self: testing.TestCollector, name: string) -> testing.TestSetRegistration { - load_var self - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var ts - load_field .name - load_var name - cmp_op == - pop_jump_if_false L0 - load_var ts - return - - L2: - load_const "TestSet not found: " - load_var name - bin_op + - throw -} - -function testing.TestCollector.new(prefix: string) -> testing.TestCollector { - load_var prefix - load_type testing.TestRegistration - alloc_array 0 - load_type testing.TestSetRegistration - alloc_array 0 - init_instance testing.TestCollector .prefix, .tests, .testsets - return -} - -function testing.TestCollector.register_test(self: testing.TestCollector, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - load_var name - load_const "::" - call baml.String.includes - pop_jump_if_false L0 - jump L12 - - L0: - load_var self - load_field .prefix - load_const "" - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var self - load_field .prefix - load_const "::" - bin_op + - load_var name - bin_op + - store_var full_name - jump L3 - - L2: - load_var name - store_var full_name - - L3: - load_const 0 - store_var count - load_var full_name - load_const "#" - bin_op + - store_var hash_prefix - load_var self - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L4: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L8 - - L5: - load_var _18 - store_var_load_var t - load_field .name - load_var full_name - cmp_op == - jump_if_false L6 - jump L7 - - L6: - pop 1 - load_var t - load_field .name - load_var hash_prefix - call baml.String.starts_with - - L7: - pop_jump_if_false L4 - load_var count - load_const 1 - add_int - store_var count - jump L4 - - L8: - load_var count - load_const 0 - cmp_int_op > - pop_jump_if_false L9 - jump L10 - - L9: - load_var full_name - store_var final_name - jump L11 - - L10: - load_var full_name - load_const "#" - bin_op + - store_var _31 - load_type int - load_var count - load_const 1 - add_int - call baml.String.from - store_var _33 - load_var2 12 13 - bin_op + - store_var final_name - - L11: - load_type testing.TestRegistration - load_var self - load_field .tests - load_var2 11 3 - load_var runner - init_instance testing.TestRegistration .name, .body, .runner - call baml.Array.push - pop 1 - load_const null - return - - L12: - load_const "test name may not contain reserved separator `::`: " - load_var name - bin_op + - init_instance testing.InvalidTestName .message - throw -} - -function testing.TestCollector.register_test_at(self: testing.TestCollector, owner: string, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { - load_var2 2 1 - load_field .tests - load_var self - load_field .testsets - init_instance testing.TestCollector .prefix, .tests, .testsets - load_var2 3 4 - load_var runner - call testing.TestCollector.register_test - return -} - -function testing.TestCollector.register_test_set(self: testing.TestCollector, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - load_var name - load_const "::" - call baml.String.includes - pop_jump_if_false L0 - jump L12 - - L0: - load_var self - load_field .prefix - load_const "" - cmp_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var self - load_field .prefix - load_const "::" - bin_op + - load_var name - bin_op + - store_var full_name - jump L3 - - L2: - load_var name - store_var full_name - - L3: - load_const 0 - store_var count - load_var full_name - load_const "#" - bin_op + - store_var hash_prefix - load_var self - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L4: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L8 - - L5: - load_var _18 - store_var_load_var ts - load_field .name - load_var full_name - cmp_op == - jump_if_false L6 - jump L7 - - L6: - pop 1 - load_var ts - load_field .name - load_var hash_prefix - call baml.String.starts_with - - L7: - pop_jump_if_false L4 - load_var count - load_const 1 - add_int - store_var count - jump L4 - - L8: - load_var count - load_const 0 - cmp_int_op > - pop_jump_if_false L9 - jump L10 - - L9: - load_var full_name - store_var final_name - jump L11 - - L10: - load_var full_name - load_const "#" - bin_op + - store_var _31 - load_type int - load_var count - load_const 1 - add_int - call baml.String.from - store_var _33 - load_var2 12 13 - bin_op + - store_var final_name - - L11: - load_type testing.TestSetRegistration - load_var self - load_field .testsets - load_var2 11 3 - load_var runner - init_instance testing.TestSetRegistration .name, .collector, .runner - call baml.Array.push - pop 1 - load_const null - return - - L12: - load_const "testset name may not contain reserved separator `::`: " - load_var name - bin_op + - init_instance testing.InvalidTestName .message - throw -} - -function testing.TestCollector.register_test_set_at(self: testing.TestCollector, owner: string, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { - load_var2 2 1 - load_field .tests - load_var self - load_field .testsets - init_instance testing.TestCollector .prefix, .tests, .testsets - load_var2 3 4 - load_var runner - call testing.TestCollector.register_test_set - return -} - -function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: string) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - load_var self - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var ts - load_field .name - load_var name - cmp_op == - pop_jump_if_false L0 - load_var2 1 5 - call testing.TestRegistry.expand_testset_registry - pop 1 - load_var self - call testing.TestRegistry.serialize - jump L5 - - L2: - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L3: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L6 - - L4: - load_var _18 - store_var k - load_var self - load_field .expansions - load_var k - load_map_element - store_var sub - load_var2 2 8 - load_const "::" - bin_op + - call baml.String.starts_with - pop_jump_if_false L3 - load_var2 9 2 - call testing.TestRegistry.expand_set - - L5: - return - - L6: - load_const "TestSet not found for expansion: " - load_var name - bin_op + - throw -} - -function testing.TestRegistry.expand_testset_registry(self: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestRegistry { - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - load_var ts - load_field .name - call baml.Map.get - store_var _8 - load_var _8 - narrow_bind testing.TestRegistry, slot=3 - pop_jump_if_false L0 - jump L4 - - L0: - sys_op baml.time.Instant.now - store_var start - load_var ts - load_field .name - load_type testing.TestRegistration - alloc_array 0 - load_type testing.TestSetRegistration - alloc_array 0 - init_instance testing.TestCollector .prefix, .tests, .testsets - store_var_load_var sub_collector - load_var ts - load_field .collector - call_indirect - pop 1 - load_var start - call baml.time.Instant.elapsed - call baml.time.Duration.to_milliseconds - call baml.Bigint.to_int - store_var elapsed - jump L3 - load_var _ - is_type baml.errors.InvalidArgument - pop_jump_if_false L1 - jump L2 - - L1: - load_var _ - rethrow - - L2: - load_const "testing: expansion duration: " - load_var _ - load_field .0 - bin_op + - call baml.sys.panic - store_var elapsed - - L3: - load_var sub_collector - load_type string - load_type testing.TestRegistry - alloc_map 0 - load_var elapsed - init_instance testing.TestRegistry .collector, .expansions, .loading_time_ms - store_var sub_registry - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - load_var ts - load_field .name - load_var sub_registry - call baml.Map.set - pop 1 - load_var sub_registry - jump L5 - - L4: - load_var _8 - - L5: - return -} - -function testing.TestRegistry.list_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - load_var2 1 2 - load_var2 3 4 - load_var cli_exclude - call testing.select_names_layered - return -} - -function testing.TestRegistry.new(collector: testing.TestCollector) -> testing.TestRegistry { - load_var collector - load_type string - load_type testing.TestRegistry - alloc_map 0 - load_const 0 - init_instance testing.TestRegistry .collector, .expansions, .loading_time_ms - return -} - -function testing.TestRegistry.run_all(self: testing.TestRegistry) -> testing.TestSetReport { - load_var self - call testing.testset_children - load_const null - call testing.run_testset - return -} - -function testing.TestRegistry.run_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> testing.FlatTestReport { - load_var2 1 2 - load_var2 3 4 - load_var cli_exclude - call testing.select_names_layered - store_var selected_names - load_var profile_include - container_len - store_var _12 - load_var _12 - load_const 0 - cmp_int_op == - jump_if_false L0 - pop 1 - load_var profile_exclude - container_len - store_var _13 - load_var _13 - load_const 0 - cmp_int_op == - - L0: - jump_if_false L1 - pop 1 - load_var cli_include - container_len - store_var _14 - load_var _14 - load_const 0 - cmp_int_op == - - L1: - jump_if_false L2 - pop 1 - load_var cli_exclude - container_len - store_var _15 - load_var _15 - load_const 0 - cmp_int_op == - - L2: - pop_jump_if_false L3 - jump L4 - - L3: - load_var2 1 6 - call testing.TestRegistry.run_selected - jump L5 - - L4: - load_var self - call testing.TestRegistry.run_all - - L5: - load_var selected_names - call testing.flatten_with_tolerated - return -} - -function testing.TestRegistry.run_selected(self: testing.TestRegistry, names: string[]) -> testing.TestSetReport { - load_var2 1 2 - call testing.testset_children_selected - load_const null - call testing.run_testset - return -} - -function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) -> testing.TestReport { - load_var self - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var t - load_field .name - load_var name - cmp_op == - pop_jump_if_false L0 - load_var t - load_field .body - load_var t - load_field .runner - call testing.run_test - jump L5 - - L2: - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - - L3: - load_var _17 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _18 - load_var _18 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L6 - - L4: - load_var _18 - store_var k - load_var self - load_field .expansions - load_var k - load_map_element - store_var sub - load_var2 2 8 - load_const "::" - bin_op + - call baml.String.starts_with - pop_jump_if_false L3 - load_var2 9 2 - call testing.TestRegistry.run_test - - L5: - return - - L6: - load_const "Test not found: " - load_var name - bin_op + - throw -} - -function testing.TestRegistry.run_testset(self: testing.TestRegistry, name: string) -> testing.TestSetReport { - load_var self - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var ts - load_field .name - load_var name - cmp_op == - pop_jump_if_false L0 - load_var2 1 5 - call testing.TestRegistry.expand_testset_registry - call testing.testset_children - load_var ts - load_field .runner - call testing.run_testset - jump L5 - - L2: - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L3: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L6 - - L4: - load_var _20 - store_var k - load_var self - load_field .expansions - load_var k - load_map_element - store_var sub - load_var2 2 8 - load_const "::" - bin_op + - call baml.String.starts_with - pop_jump_if_false L3 - load_var2 9 2 - call testing.TestRegistry.run_testset - - L5: - return - - L6: - load_const "TestSet not found: " - load_var name - bin_op + - throw -} - -function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing.SerializedTest | testing.SerializedTestSet)[] { - load_type testing.SerializedTest | testing.SerializedTestSet - alloc_array 0 - store_var items - load_var self - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type testing.SerializedTest | testing.SerializedTestSet - load_var items - load_const "test" - load_var _5 - load_field .name - init_instance testing.SerializedTest .type, .name - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var self - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _14 - - L3: - load_var _14 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _15 - load_var _15 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L7 - - L4: - load_var _15 - store_var ts - load_type string - load_type testing.TestRegistry - load_var self - load_field .expansions - load_var ts - load_field .name - call baml.Map.get - store_var _25 - load_var _25 - narrow_bind testing.TestRegistry, slot=8 - pop_jump_if_false L5 - jump L6 - - L5: - load_type testing.SerializedTest | testing.SerializedTestSet - load_var items - load_const "lazyTestSet" - load_var ts - load_field .name - init_instance testing.SerializedTest .type, .name - call baml.Array.push - pop 1 - jump L3 - - L6: - load_var _25 - store_var sub - load_var ts - load_field .name - store_var _28 - load_var sub - call testing.TestRegistry.serialize - store_var _29 - load_type testing.SerializedTest | testing.SerializedTestSet - load_var2 2 10 - load_var2 11 9 - load_field .loading_time_ms - init_instance testing.SerializedTestSet .name, .items, .loadingTimeMs - call baml.Array.push - pop 1 - jump L3 - - L7: - load_var items - return -} - -function testing._has_selected_descendant(prefix: string, names: string[]) -> bool { - load_var names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 4 1 - load_const "::" - bin_op + - call baml.String.starts_with - pop_jump_if_false L0 - load_const true - jump L3 - - L2: - load_const false - - L3: - return -} - -function testing._int_to_float(value: int) -> float { - load_type int - load_var value - call baml.String.from - call baml.Float.parse - jump L0 - load_var e - throw_if_panic - load_const "failed to convert int to float" - call baml.sys.panic - - L0: - return -} - -function testing._name_selected(name: string, names: string[]) -> bool { - load_var names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 4 1 - cmp_op == - pop_jump_if_false L0 - load_const true - jump L3 - - L2: - load_const false - - L3: - return -} - -function testing.aggregate_reports(named_results: testing.NamedChildReport[]) -> testing.TestSetReport { - load_const 0 - store_var passed - load_const 0 - store_var failed - load_const false - store_var has_error - load_type string - alloc_array 0 - store_var failed_names - load_type testing.TestReport | testing.TestSetReport - alloc_array 0 - store_var results - load_type string - alloc_array 0 - store_var result_names - load_var named_results - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L0: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L15 - - L1: - load_var _9 - store_var named_result - load_var named_result - load_field .report - store_var result - load_type testing.TestReport | testing.TestSetReport - load_var2 6 11 - call baml.Array.push - pop 1 - load_type string - load_var2 7 10 - load_field .name - call baml.Array.push - pop 1 - load_var result - store_var _21 - load_var _21 - narrow_bind testing.TestReport, slot=13 - pop_jump_if_false L2 - jump L3 - - L2: - load_var result - load_field .outcome - store_var outcome - jump L4 - - L3: - load_var _21 - load_field .outcome - store_var outcome - - L4: - load_var outcome - load_const "pass" - call baml.ops.equals_equals - pop_jump_if_false L5 - jump L14 - - L5: - load_var failed - load_const 1 - add_int - store_var failed - load_var result - store_var _27 - load_var _27 - narrow_bind testing.TestReport, slot=14 - pop_jump_if_false L6 - jump L9 - - L6: - load_var result - store_var_load_var report - load_field .failed_names - container_len - store_var _31 - load_var _31 - load_const 0 - cmp_int_op > - pop_jump_if_false L7 - jump L8 - - L7: - load_var named_result - load_field .name - load_type string - alloc_array 1 - jump L10 - - L8: - load_var report - load_field .failed_names - jump L10 - - L9: - load_var named_result - load_field .name - load_type string - alloc_array 1 - - L10: - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _35 - - L11: - load_var _35 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _36 - load_var _36 - is_type baml.iter.Done - pop_jump_if_false L12 - jump L13 - - L12: - load_type string - load_var2 5 18 - call baml.Array.push - pop 1 - jump L11 - - L13: - load_var outcome - load_const "error" - call baml.ops.equals_equals - pop_jump_if_false L0 - load_const true - store_var has_error - jump L0 - - L14: - load_var passed - load_const 1 - add_int - store_var passed - jump L0 - - L15: - load_var has_error - pop_jump_if_false L16 - jump L19 - - L16: - load_var failed - load_const 0 - cmp_int_op == - pop_jump_if_false L17 - jump L18 - - L17: - load_const "fail" - jump L20 - - L18: - load_const "pass" - jump L20 - - L19: - load_const "error" - - L20: - store_var _49 - load_var passed - store_var _50 - load_var failed - store_var _51 - load_var results - container_len - store_var _52 - load_var2 19 20 - load_var2 21 22 - load_var2 5 6 - load_var result_names - init_instance testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names - return -} - -function testing.any_pattern_matches(pats: string[], canonical_id: string) -> bool { - load_var pats - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 2 4 - call testing.glob_match - pop_jump_if_false L0 - load_const true - jump L3 - - L2: - load_const false - - L3: - return -} - -function testing.classify_selected_names(selected_names: string[], hard_failed_names: string[], all_failed_names: string[]) -> testing.LeafIdentities { - load_type string - alloc_array 0 - load_type string - alloc_array 0 - load_type string - alloc_array 0 - init_instance testing.LeafIdentities .passed, .failed, .tolerated - store_var out - load_var selected_names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L0: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _9 - store_var_load_var name - load_var all_failed_names - call testing.failure_matches_selected - pop_jump_if_false L2 - jump L3 - - L2: - load_type string - load_var out - load_field .passed - load_var name - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var2 7 2 - call testing.failure_matches_selected - pop_jump_if_false L4 - jump L5 - - L4: - load_type string - load_var out - load_field .tolerated - load_var name - call baml.Array.push - pop 1 - jump L0 - - L5: - load_type string - load_var out - load_field .failed - load_var name - call baml.Array.push - pop 1 - jump L0 - - L6: - load_var out - return -} - -function testing.collect_all_failed_names(report: testing.TestSetReport, out: string[]) -> void { - load_var report - load_field .failed_names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var name - load_var out - call testing.name_in - unary_op ! - pop_jump_if_false L0 - load_type string - load_var2 2 5 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var report - load_field .results - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _16 - - L3: - load_var _16 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - load_var _17 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L6 - - L4: - load_var _17 - store_var_load_var child - is_type testing.TestReport - pop_jump_if_false L5 - jump L3 - - L5: - load_var2 8 2 - call testing.collect_all_failed_names - pop 1 - jump L3 - - L6: - load_const null - return -} - -function testing.collect_leaf_identities(report: testing.TestSetReport, tolerated_by_parent: bool, selected_names: string[], out: testing.LeafIdentities) -> void { - load_var report - load_field .result_names - store_var_load_var _5 - load_const null - cmp_op == - pop_jump_if_false L0 - jump L25 - - L0: - load_var _5 - store_var names - load_var names - container_len - store_var _10 - load_var report - load_field .results - container_len - store_var _11 - load_var2 8 9 - cmp_int_op < - pop_jump_if_false L1 - jump L2 - - L1: - load_var report - load_field .results - container_len - store_var limit - jump L3 - - L2: - load_var names - container_len - store_var limit - - L3: - load_const 0 - store_var i - - L4: - load_var2 10 7 - cmp_int_op < - pop_jump_if_false L5 - jump L6 - - L5: - load_const null - jump L26 - - L6: - load_var2 6 10 - load_array_element - store_var name - load_var report - load_field .results - load_var i - load_array_element - store_var _22 - load_var _22 - store_var _25 - load_var _25 - narrow_bind testing.TestReport, slot=13 - pop_jump_if_false L7 - jump L19 - - L7: - load_var _22 - store_var nested - load_var tolerated_by_parent - jump_if_false L8 - store_var nested_tolerated - jump L9 - - L8: - pop 1 - load_var nested - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - store_var nested_tolerated - - L9: - load_var nested - load_field .results - container_len - store_var _42 - load_var _42 - load_const 0 - cmp_int_op > - pop_jump_if_false L10 - jump L18 - - L10: - load_var nested - load_field .failed - load_const 0 - cmp_int_op > - pop_jump_if_false L24 - load_var name - load_const "::(failed to expand)" - bin_op + - store_var_load_var sentinel - load_var selected_names - call testing.name_in - pop_jump_if_false L11 - jump L14 - - L11: - load_var nested - load_field .failed_names - container_len - store_var _54 - load_var _54 - load_const 0 - cmp_int_op > - pop_jump_if_false L12 - jump L13 - - L12: - load_var name - load_const "::(testset error)" - bin_op + - store_var identity - jump L15 - - L13: - load_var nested - load_field .failed_names - load_const 0 - load_array_element - store_var identity - jump L15 - - L14: - load_var sentinel - store_var identity - - L15: - load_var nested_tolerated - pop_jump_if_false L16 - jump L17 - - L16: - load_type string - load_var out - load_field .failed - load_var identity - call baml.Array.push - pop 1 - jump L24 - - L17: - load_type string - load_var out - load_field .tolerated - load_var identity - call baml.Array.push - pop 1 - jump L24 - - L18: - load_var2 14 15 - load_var2 3 4 - call testing.collect_leaf_identities - pop 1 - jump L24 - - L19: - load_var _25 - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - pop_jump_if_false L20 - jump L23 - - L20: - load_var tolerated_by_parent - pop_jump_if_false L21 - jump L22 - - L21: - load_type string - load_var out - load_field .failed - load_var name - call baml.Array.push - pop 1 - jump L24 - - L22: - load_type string - load_var out - load_field .tolerated - load_var name - call baml.Array.push - pop 1 - jump L24 - - L23: - load_type string - load_var out - load_field .passed - load_var name - call baml.Array.push - pop 1 - - L24: - load_var i - load_const 1 - add_int - store_var i - jump L4 - - L25: - load_const null - - L26: - return -} - -function testing.collect_leaf_messages(results: (testing.TestReport | testing.TestSetReport)[], out: string[]) -> void { - load_var results - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _4 - store_var r - load_var r - store_var _8 - load_var _8 - narrow_bind testing.TestReport, slot=6 - pop_jump_if_false L2 - jump L3 - - L2: - load_var r - load_field .results - load_var out - call testing.collect_leaf_messages - pop 1 - jump L0 - - L3: - load_var _8 - load_field .runs - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - - L4: - load_var _11 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - load_var _12 - is_type baml.iter.Done - pop_jump_if_false L5 - jump L0 - - L5: - load_var _12 - store_var_load_var run - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - unary_op ! - pop_jump_if_false L4 - load_var run - load_field .message - store_var _20 - load_var _20 - narrow_bind string, slot=10 - pop_jump_if_false L4 - load_type string - load_var2 2 10 - call baml.Array.push - pop 1 - jump L4 - - L6: - load_const null - return -} - -function testing.collect_leaf_names(registry: testing.TestRegistry) -> string[] { - load_type string - alloc_array 0 - store_var out - load_var registry - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_type string - load_var2 2 4 - load_field .name - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var registry - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _13 - - L3: - load_var _13 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _14 - load_var _14 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L7 - - L4: - load_var2 1 6 - call testing.collect_subtree_names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - - L5: - load_var _20 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _21 - load_var _21 - is_type baml.iter.Done - pop_jump_if_false L6 - jump L3 - - L6: - load_type string - load_var2 2 8 - call baml.Array.push - pop 1 - jump L5 - - L7: - load_var out - return -} - -function testing.collect_subtree_names(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> string[] { - load_var2 1 2 - call testing.TestRegistry.expand_testset_registry - call testing.collect_leaf_names - jump L19 - load_var e - store_var _5 - load_var _5 - narrow_bind testing.InvalidTestName, slot=4 - pop_jump_if_false L0 - jump L18 - - L0: - load_var e - is_type baml.panics.DivisionByZero - pop_jump_if_false L1 - jump L17 - - L1: - load_var e - is_type baml.panics.IndexOutOfBounds - pop_jump_if_false L2 - jump L17 - - L2: - load_var e - is_type baml.panics.InvalidFieldAccess - pop_jump_if_false L3 - jump L17 - - L3: - load_var e - is_type baml.panics.MapKeyNotFound - pop_jump_if_false L4 - jump L17 - - L4: - load_var e - is_type baml.panics.StackOverflow - pop_jump_if_false L5 - jump L17 - - L5: - load_var e - is_type baml.panics.AssertionFailed - pop_jump_if_false L6 - jump L17 - - L6: - load_var e - is_type baml.panics.Unreachable - pop_jump_if_false L7 - jump L17 - - L7: - load_var e - is_type baml.panics.Cancelled - pop_jump_if_false L8 - jump L17 - - L8: - load_var e - is_type baml.panics.UserPanic - pop_jump_if_false L9 - jump L17 - - L9: - load_var e - is_type baml.panics.Exit - pop_jump_if_false L10 - jump L17 - - L10: - load_var e - is_type baml.panics.AllocFailure - pop_jump_if_false L11 - jump L17 - - L11: - load_var e - is_type baml.panics.HostUnavailable - pop_jump_if_false L12 - jump L17 - - L12: - load_var e - is_type baml.panics.NegativeBitShift - pop_jump_if_false L13 - jump L17 - - L13: - load_var e - is_type baml.panics.SdkPanic - pop_jump_if_false L14 - jump L17 - - L14: - load_var e - is_type baml.panics.HostContractViolation - pop_jump_if_false L15 - jump L17 - - L15: - load_var e - is_type baml.panics.IntegerOverflow - pop_jump_if_false L16 - jump L17 - - L16: - load_var e - throw_if_panic - load_var ts - load_field .name - load_const "::(failed to expand)" - bin_op + - load_type string - alloc_array 1 - jump L19 - - L17: - load_var ts - load_field .name - load_const "::(failed to expand)" - bin_op + - load_type string - alloc_array 1 - jump L19 - - L18: - load_var _5 - throw - - L19: - return -} - -function testing.collect_subtree_names_layered(registry: testing.TestRegistry, ts: testing.TestSetRegistration, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - load_var2 1 2 - call testing.TestRegistry.expand_testset_registry - load_var2 3 4 - load_var2 5 6 - call testing.select_names_layered - jump L23 - load_var e - store_var _9 - load_var _9 - narrow_bind testing.InvalidTestName, slot=8 - pop_jump_if_false L0 - jump L22 - - L0: - load_var e - is_type baml.panics.DivisionByZero - pop_jump_if_false L1 - jump L19 - - L1: - load_var e - is_type baml.panics.IndexOutOfBounds - pop_jump_if_false L2 - jump L19 - - L2: - load_var e - is_type baml.panics.InvalidFieldAccess - pop_jump_if_false L3 - jump L19 - - L3: - load_var e - is_type baml.panics.MapKeyNotFound - pop_jump_if_false L4 - jump L19 - - L4: - load_var e - is_type baml.panics.StackOverflow - pop_jump_if_false L5 - jump L19 - - L5: - load_var e - is_type baml.panics.AssertionFailed - pop_jump_if_false L6 - jump L19 - - L6: - load_var e - is_type baml.panics.Unreachable - pop_jump_if_false L7 - jump L19 - - L7: - load_var e - is_type baml.panics.Cancelled - pop_jump_if_false L8 - jump L19 - - L8: - load_var e - is_type baml.panics.UserPanic - pop_jump_if_false L9 - jump L19 - - L9: - load_var e - is_type baml.panics.Exit - pop_jump_if_false L10 - jump L19 - - L10: - load_var e - is_type baml.panics.AllocFailure - pop_jump_if_false L11 - jump L19 - - L11: - load_var e - is_type baml.panics.HostUnavailable - pop_jump_if_false L12 - jump L19 - - L12: - load_var e - is_type baml.panics.NegativeBitShift - pop_jump_if_false L13 - jump L19 - - L13: - load_var e - is_type baml.panics.SdkPanic - pop_jump_if_false L14 - jump L19 - - L14: - load_var e - is_type baml.panics.HostContractViolation - pop_jump_if_false L15 - jump L19 - - L15: - load_var e - is_type baml.panics.IntegerOverflow - pop_jump_if_false L16 - jump L19 - - L16: - load_var e - throw_if_panic - load_var ts - load_field .name - load_const "::(failed to expand)" - bin_op + - store_var_load_var sentinel - load_var2 3 4 - load_var2 5 6 - call testing.leaf_selected_layered - pop_jump_if_false L17 - jump L18 - - L17: - load_type string - alloc_array 0 - jump L23 - - L18: - load_var sentinel - load_type string - alloc_array 1 - jump L23 - - L19: - load_var ts - load_field .name - load_const "::(failed to expand)" - bin_op + - store_var_load_var sentinel - load_var2 3 4 - load_var2 5 6 - call testing.leaf_selected_layered - pop_jump_if_false L20 - jump L21 - - L20: - load_type string - alloc_array 0 - jump L23 - - L21: - load_var sentinel - load_type string - alloc_array 1 - jump L23 - - L22: - load_var _9 - throw - - L23: - return -} - -function testing.count_leaves(results: (testing.TestReport | testing.TestSetReport)[], tolerated_by_parent: bool) -> testing.LeafCounts { - load_const 0 - store_var passed - load_const 0 - store_var failed - load_const 0 - store_var tolerated - load_const 0 - store_var total - load_var results - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L0: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L15 - - L1: - load_var _8 - store_var r - load_var r - store_var _13 - load_var _13 - narrow_bind testing.TestReport, slot=11 - pop_jump_if_false L2 - jump L9 - - L2: - load_var r - store_var tsr - load_var tolerated_by_parent - jump_if_false L3 - store_var ft - jump L4 - - L3: - pop 1 - load_var tsr - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - store_var ft - - L4: - load_var tsr - load_field .results - container_len - store_var _21 - load_var _21 - load_const 0 - cmp_int_op > - pop_jump_if_false L5 - jump L8 - - L5: - load_var ft - pop_jump_if_false L6 - jump L7 - - L6: - load_var tsr - load_field .passed - load_var tsr - load_field .failed - load_const 0 - load_var tsr - load_field .total - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var delta - jump L14 - - L7: - load_var tsr - load_field .passed - load_const 0 - load_var tsr - load_field .failed - load_var tsr - load_field .total - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var delta - jump L14 - - L8: - load_var tsr - load_field .results - load_var ft - call testing.count_leaves - store_var delta - jump L14 - - L9: - load_var _13 - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - pop_jump_if_false L10 - jump L13 - - L10: - load_var tolerated_by_parent - pop_jump_if_false L11 - jump L12 - - L11: - load_const 0 - load_const 1 - load_const 0 - load_const 1 - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var delta - jump L14 - - L12: - load_const 0 - load_const 0 - load_const 1 - load_const 1 - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var delta - jump L14 - - L13: - load_const 1 - load_const 0 - load_const 0 - load_const 1 - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var delta - - L14: - load_var2 3 10 - load_field .passed - add_int - store_var passed - load_var2 4 10 - load_field .failed - add_int - store_var failed - load_var2 5 10 - load_field .tolerated - add_int - store_var tolerated - load_var2 6 10 - load_field .total - add_int - store_var total - jump L0 - - L15: - load_var2 3 4 - load_var2 5 6 - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - return -} - -function testing.expansion_error_report(name: string) -> testing.TestSetReport { - load_const "error" - load_const 0 - load_const 1 - load_const 1 - load_var name - load_const "::(testset error)" - bin_op + - load_type string - alloc_array 1 - load_type testing.TestReport | testing.TestSetReport - alloc_array 0 - load_type string - alloc_array 0 - init_instance testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names - return -} - -function testing.failure_matches_selected(selected: string, failed_names: string[]) -> bool { - load_var2 1 2 - call testing.name_in - pop_jump_if_false L0 - jump L4 - - L0: - load_var selected - load_const "::(failed to expand)" - call baml.String.ends_with - pop_jump_if_false L3 - load_var selected - call baml.String.length - store_var _10 - load_const "::(failed to expand)" - call baml.String.length - store_var _11 - load_var selected - load_const 0 - load_var2 4 5 - sub_int - call baml.String.slice - store_var _8 - load_var failed_names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - - L1: - load_var _12 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _13 - load_var _13 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_var2 7 3 - load_const "::" - bin_op + - call baml.String.starts_with - pop_jump_if_false L1 - load_const true - jump L5 - - L3: - load_const false - jump L5 - - L4: - load_const true - - L5: - return -} - -function testing.flatten_with_tolerated(report: testing.TestSetReport, selected_names: string[]) -> testing.FlatTestReport { - load_var report - load_field .outcome - load_const "pass" - call baml.ops.equals_equals - store_var top_tolerated - load_var report - load_field .results - container_len - store_var _7 - load_var _7 - load_const 0 - cmp_int_op > - pop_jump_if_false L0 - jump L3 - - L0: - load_var top_tolerated - pop_jump_if_false L1 - jump L2 - - L1: - load_var report - load_field .passed - load_var report - load_field .failed - load_const 0 - load_var report - load_field .total - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var counts - jump L4 - - L2: - load_var report - load_field .passed - load_const 0 - load_var report - load_field .failed - load_var report - load_field .total - init_instance testing.LeafCounts .passed, .failed, .tolerated, .total - store_var counts - jump L4 - - L3: - load_var report - load_field .results - load_var top_tolerated - call testing.count_leaves - store_var counts - - L4: - load_type string - alloc_array 0 - store_var messages - load_var report - load_field .results - load_var messages - call testing.collect_leaf_messages - pop 1 - load_type string - alloc_array 0 - store_var all_failed_names - load_var2 1 7 - call testing.collect_all_failed_names - pop 1 - load_type string - alloc_array 0 - load_type string - alloc_array 0 - load_type string - alloc_array 0 - init_instance testing.LeafIdentities .passed, .failed, .tolerated - store_var executed - load_var2 1 3 - load_var2 2 8 - call testing.collect_leaf_identities - pop 1 - load_var executed - load_field .passed - container_len - store_var _36 - load_var2 10 4 - load_field .passed - cmp_int_op == - jump_if_false L5 - pop 1 - load_var executed - load_field .failed - container_len - store_var _39 - load_var2 11 4 - load_field .failed - cmp_int_op == - - L5: - jump_if_false L6 - pop 1 - load_var executed - load_field .tolerated - container_len - store_var _42 - load_var2 12 4 - load_field .tolerated - cmp_int_op == - - L6: - pop_jump_if_false L7 - jump L10 - - L7: - load_var selected_names - container_len - store_var _46 - load_var2 13 4 - load_field .total - cmp_int_op == - pop_jump_if_false L8 - jump L9 - - L8: - load_type string - alloc_array 0 - load_type string - alloc_array 0 - load_type string - alloc_array 0 - init_instance testing.LeafIdentities .passed, .failed, .tolerated - store_var identities - jump L11 - - L9: - load_var2 2 1 - load_field .failed_names - load_var all_failed_names - call testing.classify_selected_names - store_var identities - jump L11 - - L10: - load_var executed - store_var identities - - L11: - load_var report - load_field .outcome - load_var counts - load_field .passed - load_var counts - load_field .failed - load_var counts - load_field .tolerated - load_var counts - load_field .total - load_var identities - load_field .passed - load_var identities - load_field .failed - load_var identities - load_field .tolerated - load_var messages - init_instance testing.FlatTestReport .outcome, .passed, .failed, .tolerated, .total, .passed_names, .failed_names, .tolerated_names, .messages - return -} - -function testing.glob_match(subject: string, pattern: string) -> bool { - load_var pattern - load_const "*" - call baml.String.split - store_var parts - load_var parts - container_len - store_var n - load_var n - load_const 1 - cmp_int_op == - pop_jump_if_false L0 - jump L13 - - L0: - load_var parts - load_const 0 - load_array_element - store_var first - load_var2 3 4 - load_const 1 - sub_int - load_array_element - store_var last - load_var2 1 5 - call baml.String.starts_with - unary_op ! - pop_jump_if_false L1 - jump L12 - - L1: - load_var2 1 6 - call baml.String.ends_with - unary_op ! - pop_jump_if_false L2 - jump L11 - - L2: - load_var first - call baml.String.length - store_var start - load_var subject - call baml.String.length - store_var _24 - load_var last - call baml.String.length - store_var _25 - load_var2 9 10 - sub_int - store_var end_limit - load_var2 7 8 - cmp_int_op > - pop_jump_if_false L3 - jump L10 - - L3: - load_var start - store_var pos - load_const 1 - store_var i - - L4: - load_var2 12 4 - load_const 1 - sub_int - cmp_int_op < - pop_jump_if_false L5 - jump L6 - - L5: - load_const true - jump L14 - - L6: - load_var2 3 12 - load_array_element - store_var_load_var part - load_const "" - cmp_op != - pop_jump_if_false L9 - load_var2 1 11 - load_var end_limit - call baml.String.slice - load_var part - call baml.String.index_of - store_var _45 - load_var _45 - narrow_bind int, slot=14 - pop_jump_if_false L7 - jump L8 - - L7: - load_const false - jump L14 - - L8: - load_var2 11 14 - add_int - store_var _47 - load_var part - call baml.String.length - load_var _47 - add_int - store_var pos - - L9: - load_var i - load_const 1 - add_int - store_var i - jump L4 - - L10: - load_const false - jump L14 - - L11: - load_const false - jump L14 - - L12: - load_const false - jump L14 - - L13: - load_var2 1 2 - call baml.String.index_of - load_const null - call baml.ops.equals_equals - unary_op ! - - L14: - return -} - -function testing.leaf_selected(name: string, include: string[], exclude: string[]) -> bool { - load_var2 3 1 - call testing.any_pattern_matches - pop_jump_if_false L0 - jump L3 - - L0: - load_var include - container_len - store_var _6 - load_var _6 - load_const 0 - cmp_int_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 2 1 - call testing.any_pattern_matches - jump L4 - - L2: - load_const true - jump L4 - - L3: - load_const false - - L4: - return -} - -function testing.leaf_selected_layered(name: string, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> bool { - load_var2 1 2 - load_var profile_exclude - call testing.leaf_selected - jump_if_false L0 - pop 1 - load_var2 1 4 - load_var cli_exclude - call testing.leaf_selected - - L0: - return -} - -function testing.name_in(name: string, names: string[]) -> bool { - load_var names - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var2 4 1 - cmp_op == - pop_jump_if_false L0 - load_const true - jump L3 - - L2: - load_const false - - L3: - return -} - -function testing.pattern_may_match_descendant(pattern: string, prefix: string) -> bool { - load_var prefix - load_const "::" - bin_op + - store_var descendant_prefix - load_var pattern - load_const "*" - call baml.String.index_of - store_var _4 - load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - jump L2 - - L0: - load_var pattern - load_const 0 - load_var _4 - call baml.String.slice - store_var literal - load_var2 3 5 - call baml.String.starts_with - jump_if_false L1 - jump L3 - - L1: - pop 1 - load_var2 5 3 - call baml.String.starts_with - jump L3 - - L2: - load_const true - - L3: - return -} - -function testing.run_children_parallel(children: testing.TestSetChild[]) -> testing.TestSetReport { - load_var ?5 - make_cell - store_var ?5 - load_type future - alloc_array 0 - store_var futures - load_var children - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _3 - - L0: - load_var _3 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - load_var _4 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_const null - make_cell - store_var child - load_var _4 - store_deref ?5 - load_var child - make_closure ., 1 - load_const null - load_const null - load_type testing.NamedChildReport - load_type never - spawn - store_var _11 - load_type future - load_var2 2 6 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_type testing.NamedChildReport - load_type never - load_var futures - call baml.future.all_complete - await - call testing.aggregate_reports - return -} - -function testing.run_children_sequential(children: testing.TestSetChild[], fail_fast: bool) -> testing.TestSetReport { - load_type testing.NamedChildReport - alloc_array 0 - store_var named_results - load_var children - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _5 - store_var_load_var child - load_field .run - call_indirect - store_var report - load_type testing.NamedChildReport - load_var2 3 6 - load_field .name - load_var report - init_instance testing.NamedChildReport .name, .report - call baml.Array.push - pop 1 - load_var report - store_var _17 - load_var _17 - narrow_bind testing.TestReport, slot=9 - pop_jump_if_false L2 - jump L3 - - L2: - load_var report - load_field .outcome - store_var outcome - jump L4 - - L3: - load_var _17 - load_field .outcome - store_var outcome - - L4: - load_var fail_fast - jump_if_false L5 - pop 1 - load_var outcome - load_const "pass" - call baml.ops.equals_equals - unary_op ! - - L5: - pop_jump_if_false L0 - load_var named_results - call testing.aggregate_reports - jump L7 - - L6: - load_var named_results - call testing.aggregate_reports - - L7: - return -} - -function testing.run_test(body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestReport { - load_var ?1 - make_cell - store_var ?1 - load_var body - make_closure ., 1 - store_var base_run - load_var runner - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var2 3 2 - call_indirect - call_indirect - jump L2 - - L1: - load_var base_run - call_indirect - - L2: - return -} - -function testing.run_testset(children: testing.TestSetChild[], runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> testing.TestSetReport { - load_var runner - load_const null - cmp_op == - pop_jump_if_false L0 - jump L1 - - L0: - load_var2 1 2 - call_indirect - jump L2 - - L1: - load_var children - call testing.run_children_parallel - - L2: - return -} - -function testing.select_names(registry: testing.TestRegistry, include: string[], exclude: string[]) -> string[] { - load_var registry - load_type string - alloc_array 0 - load_type string - alloc_array 0 - load_var2 2 3 - call testing.select_names_layered - return -} - -function testing.select_names_layered(registry: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { - load_type string - alloc_array 0 - store_var out - load_var registry - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L0: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _9 - store_var_load_var t - load_field .name - load_var2 2 3 - load_var2 4 5 - call testing.leaf_selected_layered - pop_jump_if_false L0 - load_type string - load_var2 6 9 - load_field .name - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var registry - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L3: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L8 - - L4: - load_var _20 - store_var_load_var ts - load_field .name - load_var2 2 3 - call testing.subtree_may_be_selected - jump_if_false L5 - pop 1 - load_var ts - load_field .name - load_var2 4 5 - call testing.subtree_may_be_selected - - L5: - pop_jump_if_false L3 - load_var2 1 12 - load_var2 2 3 - load_var2 4 5 - call testing.collect_subtree_names_layered - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _31 - - L6: - load_var _31 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _32 - load_var _32 - is_type baml.iter.Done - pop_jump_if_false L7 - jump L3 - - L7: - load_type string - load_var2 6 14 - call baml.Array.push - pop 1 - jump L6 - - L8: - load_var out - return -} - -function testing.subtree_excluded(prefix: string, excludes: string[]) -> bool { - load_var prefix - load_const "::" - bin_op + - store_var descendant_prefix - load_var excludes - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _5 - store_var pattern - load_var pattern - load_const "*" - call baml.String.index_of - load_const null - call baml.ops.equals_equals - jump_if_false L2 - pop 1 - load_var2 3 6 - call baml.String.index_of - load_const null - call baml.ops.equals_equals - unary_op ! - - L2: - pop_jump_if_false L3 - jump L5 - - L3: - load_var pattern - load_const "*" - call baml.String.ends_with - jump_if_false L4 - pop 1 - load_var2 3 6 - call testing.glob_match - - L4: - pop_jump_if_false L0 - load_const true - jump L7 - - L5: - load_const true - jump L7 - - L6: - load_const false - - L7: - return -} - -function testing.subtree_may_be_selected(prefix: string, include: string[], exclude: string[]) -> bool { - load_var2 1 3 - call testing.subtree_excluded - pop_jump_if_false L0 - jump L6 - - L0: - load_var include - container_len - store_var _6 - load_var _6 - load_const 0 - cmp_int_op == - pop_jump_if_false L1 - jump L5 - - L1: - load_var include - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L2: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L4 - - L3: - load_var2 6 1 - call testing.pattern_may_match_descendant - pop_jump_if_false L2 - load_const true - jump L7 - - L4: - load_const false - jump L7 - - L5: - load_const true - jump L7 - - L6: - load_const false - - L7: - return -} - -function testing.test_child(name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestSetChild { - load_var ?2 - make_cell - store_var ?2 - load_var ?3 - make_cell - store_var ?3 - load_var2 1 2 - load_var runner - make_closure ., 2 - init_instance testing.TestSetChild .name, .run - return -} - -function testing.testset_child(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestSetChild { - load_var ?1 - make_cell - store_var ?1 - load_var ?2 - make_cell - store_var ?2 - load_deref ?2 - load_field .name - load_var2 1 2 - make_closure ., 2 - init_instance testing.TestSetChild .name, .run - return -} - -function testing.testset_child_selected(registry: testing.TestRegistry, ts: testing.TestSetRegistration, names: string[]) -> testing.TestSetChild { - load_var ?1 - make_cell - store_var ?1 - load_var ?2 - make_cell - store_var ?2 - load_var ?3 - make_cell - store_var ?3 - load_deref ?2 - load_field .name - load_var2 1 2 - load_var names - make_closure ., 3 - init_instance testing.TestSetChild .name, .run - return -} - -function testing.testset_children(registry: testing.TestRegistry) -> testing.TestSetChild[] { - load_type testing.TestSetChild - alloc_array 0 - store_var children - load_var registry - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - load_var _5 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _5 - store_var_load_var t - load_field .name - load_var t - load_field .body - load_var t - load_field .runner - call testing.test_child - store_var _10 - load_type testing.TestSetChild - load_var2 2 6 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var registry - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _16 - - L3: - load_var _16 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _17 - load_var _17 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var2 1 8 - call testing.testset_child - store_var _22 - load_type testing.TestSetChild - load_var2 2 9 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var children - return -} - -function testing.testset_children_selected(registry: testing.TestRegistry, names: string[]) -> testing.TestSetChild[] { - load_type testing.TestSetChild - alloc_array 0 - store_var children - load_var registry - load_field .collector - load_field .tests - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _5 - - L0: - load_var _5 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - load_var _6 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L2 - - L1: - load_var _6 - store_var_load_var t - load_field .name - load_var names - call testing._name_selected - pop_jump_if_false L0 - load_var t - load_field .name - load_var t - load_field .body - load_var t - load_field .runner - call testing.test_child - store_var _13 - load_type testing.TestSetChild - load_var2 3 7 - call baml.Array.push - pop 1 - jump L0 - - L2: - load_var registry - load_field .collector - load_field .testsets - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _19 - - L3: - load_var _19 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _20 - load_var _20 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _20 - store_var_load_var ts - load_field .name - load_var names - call testing._has_selected_descendant - pop_jump_if_false L3 - load_var2 1 10 - load_var names - call testing.testset_child_selected - store_var _27 - load_type testing.TestSetChild - load_var2 3 11 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var children - return -} - -function user.User.promote(self: User, bonus: int) -> Report { - load_var self - copy 0 - load_field .age - load_const 1 - bin_op + - store_field .age - load_var2 1 2 - call user.score - store_var base - load_var base - load_field .score - load_var bonus - add_int - load_var base - load_field .label - load_var base - load_field .breakdown - init_instance user.Report .score, .label, .breakdown - return -} - -function user.http_status(code: int) -> string { - load_var code - dense_tag [200, 201, 204, 400, 404, 500] - jump_table [L6, L5, L4, L3, L2, L1], default L0 - - L0: - load_const "Unknown" - store_var label - jump L7 - - L1: 500 - load_const "Internal Server Error" - store_var label - jump L7 - - L2: 404 - load_const "Not Found" - store_var label - jump L7 - - L3: 400 - load_const "Bad Request" - store_var label - jump L7 - - L4: 204 - load_const "No Content" - store_var label - jump L7 - - L5: 201 - load_const "Created" - store_var label - jump L7 - - L6: 200 - load_const "OK" - store_var label - - L7: - load_const "HTTP " - load_var label - bin_op + - return -} - -function user.score(input: User | ErrorInfo, threshold: int) -> Report { - load_var input - store_var _4 - load_var _4 - narrow_bind User, slot=4 - pop_jump_if_false L0 - jump L1 - - L0: - load_var input - load_field .message - store_var name - jump L2 - - L1: - load_var _4 - load_field .name - store_var name - - L2: - load_var input - store_var _8 - load_var _8 - narrow_bind User, slot=6 - pop_jump_if_false L3 - jump L4 - - L3: - load_var input - load_field .code - unary_op - - store_var age - jump L5 - - L4: - load_var _8 - load_field .age - store_var age - - L5: - load_var input - store_var _13 - load_var _13 - narrow_bind User, slot=8 - pop_jump_if_false L6 - jump L7 - - L6: - load_var threshold - store_var role_mult - jump L12 - - L7: - load_var _13 - load_field .role - discriminant - jump_table [L11, L10, L9, L8], default L19 - - L8: Role.Guest - load_var threshold - store_var role_mult - jump L12 - - L9: Role.Viewer - load_var threshold - store_var role_mult - jump L12 - - L10: Role.Editor - load_var threshold - store_var role_mult - jump L12 - - L11: Role.Admin - load_var threshold - store_var role_mult - - L12: - load_var age - load_const 2 - mul_int - load_var role_mult - add_int - store_var_load_var base - load_var role_mult - cmp_int_op > - pop_jump_if_false L13 - jump L14 - - L13: - load_var base - store_var capped - jump L15 - - L14: - load_var role_mult - store_var capped - - L15: - load_var2 10 7 - add_int - store_var_load_var total - load_var threshold - cmp_int_op > - load_const true - cmp_op == - pop_jump_if_false L16 - jump L17 - - L16: - load_const " [LOW]" - store_var suffix - jump L18 - - L17: - load_const " [HIGH]" - store_var suffix - - L18: - load_var2 9 10 - load_var total - load_type int - alloc_array 3 - store_var scores - load_var scores - load_const 0 - load_var total - store_array_element - load_var scores - load_const 0 - load_array_element - load_var2 3 12 - bin_op + - load_var2 9 7 - load_const "base" - load_const "role" - load_type string - load_type int - alloc_map 2 - init_instance user.Report .score, .label, .breakdown - return - - L19: - unreachable -} - -function vercel.AiGatewayImageClient.ai.Client.id(self: vercel.AiGatewayImageClient) -> string { - load_var self - call vercel.internal._gw_images_client_id - return -} - -function vercel.AiGatewayImageClient.ai.Client.invoke(self: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call vercel.internal.gateway_images_invoke - jump L0 - load_var e - throw_if_panic - load_var e - call ai.errors.normalize - throw - - L0: - return -} - -function vercel.AiGatewayImageClient.new(model: string, api_key: string | baml.env.Ref | null, base_url: string | baml.env.Ref | null, n: int | null, size: string | null, aspect_ratio: string | null, seed: int | null, request_body: baml.json.json | null, headers: map | null, query_params: map | null) -> vercel.AiGatewayImageClient { - load_var model - load_const - cmp_op == - pop_jump_if_false L0 - load_const "openai/gpt-image-1" - store_var model - - L0: - load_var api_key - load_const - cmp_op == - pop_jump_if_false L1 - load_const null - store_var api_key - - L1: - load_var base_url - load_const - cmp_op == - pop_jump_if_false L2 - load_const null - store_var base_url - - L2: - load_var n - load_const - cmp_op == - pop_jump_if_false L3 - load_const null - store_var n - - L3: - load_var size - load_const - cmp_op == - pop_jump_if_false L4 - load_const null - store_var size - - L4: - load_var aspect_ratio - load_const - cmp_op == - pop_jump_if_false L5 - load_const null - store_var aspect_ratio - - L5: - load_var seed - load_const - cmp_op == - pop_jump_if_false L6 - load_const null - store_var seed - - L6: - load_var request_body - load_const - cmp_op == - pop_jump_if_false L7 - load_const null - store_var request_body - - L7: - load_var headers - load_const - cmp_op == - pop_jump_if_false L8 - load_const null - store_var headers - - L8: - load_var query_params - load_const - cmp_op == - pop_jump_if_false L9 - load_const null - store_var query_params - - L9: - load_var2 1 2 - load_var2 3 4 - load_var2 5 6 - load_var2 7 8 - load_var2 9 10 - init_instance vercel.AiGatewayImageClient .model, .api_key, .base_url, .n, .size, .aspect_ratio, .seed, .request_body, .headers, .query_params - return -} - -function vercel.AiGatewayImageClient.resolved_api_key(self: vercel.AiGatewayImageClient) -> string { - load_var self - load_field .api_key - load_const "AI_GATEWAY_API_KEY" - call ai.wire.resolve_credential - store_var _4 - load_var _4 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 - - L0: - load_var self - load_field .api_key - load_const "AI_GATEWAY_API_KEY" - call ai.wire.credential_sources - store_var _9 - load_type string - load_var _9 - call baml.String.from - store_var _8 - load_const "ai-gateway-images" - load_const null - load_const "no AI Gateway API key: set the client's api_key (a literal or env.NAME), or export one of the variables it consulted — " - load_var _8 - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L1: - load_var _4 - return -} - -function vercel.AiGatewayImageClient.resolved_base_url(self: vercel.AiGatewayImageClient) -> string | null { - load_var self - load_field .base_url - load_const null - call ai.wire.resolve_credential - return -} - -function vercel.internal._gw_images_client_id(c: vercel.AiGatewayImageClient) -> string { - load_type string - load_var c - load_field .model - call baml.String.from - store_var _3 - load_const "ai-gateway-images/" - load_var _3 - bin_op + - return -} - -function vercel.internal._gw_images_drop_nulls(value: baml.json.json) -> baml.json.json { - load_var value - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L0 - jump L6 - - L0: - load_var value - store_var _24 - load_var _24 - narrow_bind baml.json.json[], slot=10 - pop_jump_if_false L1 - jump L2 - - L1: - load_var value - jump L11 - - L2: - load_type baml.json.json - alloc_array 0 - store_var out - load_var _24 - load_type baml.iter.Iterable> - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _28 - - L3: - load_var _28 - load_type baml.iter.Iterator> - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - load_var _29 - is_type baml.iter.Done - pop_jump_if_false L4 - jump L5 - - L4: - load_var _29 - call vercel.internal._gw_images_drop_nulls - store_var _34 - load_type baml.json.json - load_var2 11 14 - call baml.Array.push - pop 1 - jump L3 - - L5: - load_var out - jump L11 - - L6: - load_var _2 - store_var object - load_type string - load_type baml.json.json - alloc_map 0 - store_var out - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L7: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L8 - jump L10 - - L8: - load_var _9 - store_var key - load_type string - load_type baml.json.json - load_var2 3 7 - call baml.Map.get - store_var entry - load_var entry - load_const null - cmp_op == - pop_jump_if_false L9 - jump L7 - - L9: - load_var entry - call vercel.internal._gw_images_drop_nulls - store_var _20 - load_type string - load_type baml.json.json - load_var2 4 7 - load_var _20 - call baml.Map.set - pop 1 - jump L7 - - L10: - load_var out - - L11: - return -} - -function vercel.internal._gw_images_escape_query(raw: string) -> string { - load_var raw - load_const "%" - load_const "%25" - call baml.String.replace_all - load_const " " - load_const "%20" - call baml.String.replace_all - load_const "&" - load_const "%26" - call baml.String.replace_all - load_const "+" - load_const "%2B" - call baml.String.replace_all - load_const "=" - load_const "%3D" - call baml.String.replace_all - load_const "?" - load_const "%3F" - call baml.String.replace_all - load_const "#" - load_const "%23" - call baml.String.replace_all - return -} - -function vercel.internal._gw_images_file(media: baml.media.Image | baml.media.Audio | baml.media.Video | baml.media.Pdf) -> vercel.internal.GwImagesFile { - load_var media - load_const false - call ai.wire.resolve_media - store_var resolved - load_var resolved - load_field .base64 - store_var _4 - load_var _4 - narrow_bind string, slot=3 - pop_jump_if_false L0 - jump L3 - - L0: - load_var resolved - load_field .url - store_var _9 - load_var _9 - narrow_bind string, slot=4 - pop_jump_if_false L1 - jump L2 - - L1: - load_const "ai-gateway-images" - load_const null - load_const "image input carried no base64 content, file, or URL" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw - - L2: - load_const "url" - load_const null - load_const null - load_var _9 - init_instance vercel.internal.GwImagesFile .type, .mediaType, .data, .url - jump L4 - - L3: - load_const "file" - load_var resolved - load_field .mime_type - load_var _4 - load_const null - init_instance vercel.internal.GwImagesFile .type, .mediaType, .data, .url - - L4: - return -} - -function vercel.internal._gw_images_find_output_format(value: baml.json.json | null) -> string | null { - load_var value - store_var _2 - load_var _2 - narrow_bind map, slot=2 - pop_jump_if_false L6 - load_var _2 - store_var object - load_type string - load_type baml.json.json - load_var object - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - - L0: - load_var _7 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - load_var _8 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L6 - - L1: - load_var _8 - store_var key - load_type string - load_type baml.json.json - load_var2 3 6 - call baml.Map.get - store_var entry - load_var key - load_const "outputFormat" - cmp_op == - jump_if_false L2 - jump L3 - - L2: - pop 1 - load_var key - load_const "output_format" - cmp_op == - - L3: - pop_jump_if_false L4 - load_var entry - store_var _20 - load_var _20 - narrow_bind string, slot=8 - pop_jump_if_false L4 - jump L5 - - L4: - load_var entry - call vercel.internal._gw_images_find_output_format - store_var _24 - load_var _24 - narrow_bind string, slot=9 - pop_jump_if_false L0 - load_var _24 - jump L7 - - L5: - load_var _20 - jump L7 - - L6: - load_const null - - L7: - return -} - -function vercel.internal._gw_images_headers(c: vercel.AiGatewayImageClient) -> map { - load_const "application/json" - load_const "0.0.1" - load_const "4" - load_var c - load_field .model - load_const "content-type" - load_const "ai-gateway-protocol-version" - load_const "ai-image-model-specification-version" - load_const "ai-model-id" - load_type string - load_type string - alloc_map 4 - store_var headers - load_var c - load_field .headers - store_var _5 - load_var _5 - narrow_bind map, slot=3 - pop_jump_if_false L3 - load_var _5 - store_var extra - load_type string - load_type string - load_var extra - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - - L0: - load_var _10 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _11 - load_var _11 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _11 - store_var name - load_var name - call baml.String.to_lower_case - store_var _16 - load_type string - load_type string - load_var2 4 7 - call baml.Map.get - store_var_load_var _18 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _18 - - L2: - load_type string - load_type string - load_var2 2 8 - load_var _18 - call baml.Map.set - pop 1 - jump L0 - - L3: - load_var c - call vercel.AiGatewayImageClient.resolved_api_key - store_var _29 - load_type string - load_var _29 - call baml.String.from - store_var _28 - load_type string - load_type string - load_var headers - load_const "authorization" - load_const "Bearer " - load_var _28 - bin_op + - call baml.Map.set - pop 1 - load_type string - load_type string - load_var headers - load_const "ai-gateway-auth-method" - load_const "api-key" - call baml.Map.set - pop 1 - load_var headers - return -} - -function vercel.internal._gw_images_input(prompt: ai.Prompt, journal: ai.Journal) -> vercel.internal.GwImagesInput { - load_type string - alloc_array 0 - store_var parts - load_type vercel.internal.GwImagesFile - alloc_array 0 - store_var files - load_var prompt - call ai.Prompt.messages - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _6 - - L0: - load_var _6 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _7 - load_var _7 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L12 - - L1: - load_var _7 - load_field .parts - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _12 - - L2: - load_var _12 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _13 - load_var _13 - is_type baml.iter.Done - pop_jump_if_false L3 - jump L0 - - L3: - load_var _13 - store_var part - load_var part - store_var _17 - load_var _17 - narrow_bind string, slot=10 - pop_jump_if_false L4 - jump L11 - - L4: - load_var part - store_var _25 - load_var _25 - narrow_bind baml.media.Image, slot=12 - pop_jump_if_false L5 - jump L10 - - L5: - load_var part - store_var _31 - load_var _31 - narrow_bind baml.media.Audio, slot=14 - pop_jump_if_false L6 - jump L9 - - L6: - load_var part - store_var _33 - load_var _33 - narrow_bind baml.media.Video, slot=15 - pop_jump_if_false L7 - jump L8 - - L7: - load_const "pdf" - call vercel.internal._gw_images_media_rejected - throw - - L8: - load_const "video" - call vercel.internal._gw_images_media_rejected - throw - - L9: - load_const "audio" - call vercel.internal._gw_images_media_rejected - throw - - L10: - load_var _25 - call vercel.internal._gw_images_file - store_var _28 - load_type vercel.internal.GwImagesFile - load_var2 4 13 - call baml.Array.push - pop 1 - jump L2 - - L11: - load_var _17 - call baml.String.trim - store_var trimmed - load_var trimmed - load_const "" - cmp_op != - pop_jump_if_false L2 - load_type string - load_var2 3 11 - call baml.Array.push - pop 1 - jump L2 - - L12: - load_var journal - call ai.Journal.entries - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _37 - - L13: - load_var _37 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _38 - load_var _38 - is_type baml.iter.Done - pop_jump_if_false L14 - jump L15 - - L14: - load_var _38 - store_var _42 - load_var _42 - narrow_bind ai.events.UserMessage, slot=18 - pop_jump_if_false L13 - load_var _42 - load_field .content - call baml.String.trim - store_var trimmed - load_var trimmed - load_const "" - cmp_op != - pop_jump_if_false L13 - load_type string - load_var2 3 19 - call baml.Array.push - pop 1 - jump L13 - - L15: - load_type string - load_var parts - load_const "\n\n" - call baml.Array.join - store_var joined - load_var joined - load_const "" - cmp_op == - pop_jump_if_false L16 - jump L17 - - L16: - load_var2 20 4 - init_instance vercel.internal.GwImagesInput .text, .files - return - - L17: - load_const "ai-gateway-images" - load_const null - load_const "Images API request requires a text prompt" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function vercel.internal._gw_images_media_rejected(kind: string) -> ai.errors.InvalidRequest { - load_type string - load_var kind - call baml.String.from - store_var _4 - load_const "ai-gateway-images" - load_const null - load_const "Images API only supports text and image prompts; found " - load_var _4 - bin_op + - load_const " input" - bin_op + - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - return -} - -function vercel.internal._gw_images_mime(format: string | null) -> string { - load_var format - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_const "png" - store_var _4 - - L0: - load_var _4 - call baml.String.to_lower_case - store_var normalized - load_var normalized - load_const "jpeg" - cmp_op == - pop_jump_if_false L1 - jump L8 - - L1: - load_var normalized - load_const "jpg" - cmp_op == - pop_jump_if_false L2 - jump L7 - - L2: - load_var normalized - load_const "webp" - cmp_op == - pop_jump_if_false L3 - jump L6 - - L3: - load_var normalized - load_const "gif" - cmp_op == - pop_jump_if_false L4 - jump L5 - - L4: - load_const "image/png" - jump L9 - - L5: - load_const "image/gif" - jump L9 - - L6: - load_const "image/webp" - jump L9 - - L7: - load_const "image/jpeg" - jump L9 - - L8: - load_const "image/jpeg" - - L9: - return -} - -function vercel.internal._gw_images_trim_slash(url: string) -> string { - load_var url - load_const "/" - call baml.String.ends_with - pop_jump_if_false L0 - jump L1 - - L0: - load_var url - jump L2 - - L1: - load_var url - call baml.String.length - store_var _4 - load_var url - load_const 0 - load_var _4 - load_const 1 - sub_int - call baml.String.slice - - L2: - return -} - -function vercel.internal._gw_images_value(encoded: string, fallback_mime: string) -> image { - load_var encoded - load_const "data:" - call baml.String.starts_with - pop_jump_if_false L0 - jump L1 - - L0: - load_var2 1 2 - call baml.media.Image.from_base64 - jump L7 - - L1: - load_var encoded - load_const ";base64," - call baml.String.index_of - store_var _5 - load_var _5 - narrow_bind int, slot=3 - pop_jump_if_false L2 - jump L6 - - L2: - load_var encoded - call baml.String.length - load_const 48 - cmp_int_op > - pop_jump_if_false L3 - jump L4 - - L3: - load_var encoded - store_var preview - jump L5 - - L4: - load_var encoded - load_const 0 - load_const 48 - call baml.String.slice - store_var _19 - load_type string - load_var _19 - call baml.String.from - load_const "..." - bin_op + - store_var preview - - L5: - load_type string - load_var preview - call baml.String.from - store_var _23 - load_const "ai-gateway-images" - load_const "images[] carried a data: URL with no ;base64, marker: " - load_var _23 - bin_op + - init_instance ai.errors.ParseFailed .provider, .raw_output - throw - - L6: - load_var _5 - store_var marker - load_var encoded - load_const 5 - load_var marker - call baml.String.slice - store_var mime - load_var marker - load_const 8 - add_int - store_var _10 - load_var encoded - call baml.String.length - store_var _12 - load_var2 1 6 - load_var _12 - call baml.String.slice - load_var mime - call baml.media.Image.from_base64 - - L7: - return -} - -function vercel.internal._gw_images_with_query(url: string, params: map | null) -> string { - load_type string - alloc_array 0 - store_var pairs - load_var params - store_var _4 - load_var _4 - narrow_bind map, slot=4 - pop_jump_if_false L3 - load_var _4 - store_var configured - load_type string - load_type string - load_var configured - call baml.Map.keys - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - - L0: - load_var _9 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _10 - load_var _10 - is_type baml.iter.Done - pop_jump_if_false L1 - jump L3 - - L1: - load_var _10 - store_var_load_var key - call vercel.internal._gw_images_escape_query - store_var _18 - load_type string - load_var _18 - call baml.String.from - store_var _17 - load_type string - load_type string - load_var2 5 8 - call baml.Map.get - store_var_load_var _24 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "" - store_var _24 - - L2: - load_var _24 - call vercel.internal._gw_images_escape_query - store_var _22 - load_type string - load_var _22 - call baml.String.from - store_var _21 - load_type string - load_var2 3 9 - load_const "=" - bin_op + - load_var _21 - bin_op + - call baml.Array.push - pop 1 - jump L0 - - L3: - load_var pairs - container_len - store_var _33 - load_var _33 - load_const 0 - cmp_int_op == - pop_jump_if_false L4 - jump L8 - - L4: - load_var url - load_const "?" - call baml.String.includes - pop_jump_if_false L5 - jump L6 - - L5: - load_const "?" - store_var separator - jump L7 - - L6: - load_const "&" - store_var separator - - L7: - load_type string - load_var url - call baml.String.from - store_var _37 - load_type string - load_var separator - call baml.String.from - store_var _39 - load_type string - load_var pairs - load_const "&" - call baml.Array.join - store_var _43 - load_type string - load_var _43 - call baml.String.from - store_var _42 - load_var2 16 17 - bin_op + - load_var _42 - bin_op + - jump L9 - - L8: - load_var url - - L9: - return -} - -function vercel.internal.gateway_images_invoke(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> ai.ModelTurn { - load_var2 1 2 - call vercel.internal.gateway_images_render - store_var req - load_type vercel.internal.GwImagesResponse - load_var req - load_const "ai-gateway-images" - call ai.wire.send_as - store_var resp - load_var2 1 4 - call vercel.internal.gateway_images_parse - return -} - -function vercel.internal.gateway_images_parse(c: vercel.AiGatewayImageClient, resp: vercel.internal.GwImagesResponse) -> ai.ModelTurn { - load_var resp - load_field .warnings - store_var_load_var _4 - load_const null - cmp_op == - pop_jump_if_false L0 - load_type vercel.internal.GwImagesWarning - alloc_array 0 - store_var _4 - - L0: - load_var _4 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _8 - - L1: - load_var _8 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _9 - load_var _9 - is_type baml.iter.Done - pop_jump_if_false L2 - jump L3 - - L2: - load_var _9 - call vercel.internal.gateway_images_warning_text - store_var _13 - load_const "$baml_log" - load_const "warn" - load_var _13 - load_const "level" - load_const "data" - load_type string - load_type unknown - alloc_map 2 - send_event - pop 1 - jump L1 - - L3: - load_var resp - load_field .providerMetadata - call vercel.internal._gw_images_find_output_format - store_var_load_var _16 - load_const null - cmp_op == - pop_jump_if_false L4 - load_var c - load_field .request_body - call vercel.internal._gw_images_find_output_format - store_var _16 - - L4: - load_var _16 - call vercel.internal._gw_images_mime - store_var fallback_mime - load_var resp - load_field .images - store_var_load_var _24 - load_const null - cmp_op == - pop_jump_if_false L5 - load_type string - alloc_array 0 - store_var _24 - - L5: - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - alloc_array 0 - store_var content - load_var _24 - load_type baml.iter.Iterable - load_const "iter" - virtual_call nargs=1 ntypeargs=0 - store_var _29 - - L6: - load_var _29 - load_type baml.iter.Iterator - load_const "next" - virtual_call nargs=1 ntypeargs=0 - store_var _30 - load_var _30 - is_type baml.iter.Done - pop_jump_if_false L7 - jump L8 - - L7: - load_var _30 - store_var encoded - load_var encoded - call baml.String.trim - load_const "" - cmp_op != - pop_jump_if_false L6 - load_var2 13 8 - call vercel.internal._gw_images_value - load_const - load_const - call ai.content.Media.new - store_var _37 - load_type ai.content.Text | ai.content.Reasoning | ai.content.ToolUse | ai.content.Media - load_var2 10 14 - call baml.Array.push - pop 1 - jump L6 - - L8: - load_var content - container_len - store_var _43 - load_var _43 - load_const 0 - cmp_int_op == - pop_jump_if_false L9 - jump L15 - - L9: - load_var resp - load_field .usage - store_var _47 - load_var _47 - narrow_bind vercel.internal.GwImagesUsage, slot=17 - pop_jump_if_false L10 - jump L11 - - L10: - load_const null - store_var usage - jump L14 - - L11: - load_var _47 - store_var_load_var reported - load_field .inputTokens - store_var_load_var _50 - load_const null - cmp_op == - pop_jump_if_false L12 - load_const 0 - store_var _50 - - L12: - load_var _50 - store_var _49 - load_var reported - load_field .outputTokens - store_var_load_var _54 - load_const null - cmp_op == - pop_jump_if_false L13 - load_const 0 - store_var _54 - - L13: - load_var2 19 21 - load_const null - load_const null - init_instance ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens - store_var usage - - L14: - load_var content - load_const ai.content.StopReason.Complete - alloc_variant ai.content.StopReason - load_var usage - init_instance ai.ModelTurn .content, .stop_reason, .usage - return - - L15: - load_const "ai-gateway-images" - load_const "response contained no images in images[]" - init_instance ai.errors.ParseFailed .provider, .raw_output - throw -} - -function vercel.internal.gateway_images_render(c: vercel.AiGatewayImageClient, input: ai.ModelTurnInput) -> baml.http.Request { - load_var input - load_field .toolbox - call ai.tools.Toolbox.is_empty - unary_op ! - pop_jump_if_false L0 - jump L6 - - L0: - load_var input - load_field .journal - store_var _8 - load_var c - call vercel.internal._gw_images_client_id - store_var _9 - load_var2 4 5 - call ai.wire.sanitize_for_client - store_var journal - load_const "" - load_var input - load_field .prompt - call_indirect - load_var journal - call vercel.internal._gw_images_input - store_var lowered - load_var lowered - load_field .files - container_len - store_var _16 - load_var _16 - load_const 0 - cmp_int_op == - pop_jump_if_false L1 - jump L2 - - L1: - load_var lowered - load_field .files - store_var files - jump L3 - - L2: - load_const null - store_var files - - L3: - load_var lowered - load_field .text - store_var _19 - load_var c - load_field .n - store_var_load_var _21 - load_const null - cmp_op == - pop_jump_if_false L4 - load_const 1 - store_var _21 - - L4: - load_type vercel.internal.GwImagesRequest - load_var2 9 10 - load_var c - load_field .size - load_var c - load_field .aspect_ratio - load_var c - load_field .seed - load_var files - init_instance vercel.internal.GwImagesRequest .prompt, .n, .size, .aspectRatio, .seed, .files - call baml.json.to_json - call vercel.internal._gw_images_drop_nulls - load_var c - load_field .request_body - call ai.wire.merge_request_body - store_var merged - load_var c - call vercel.AiGatewayImageClient.resolved_base_url - store_var_load_var _40 - load_const null - cmp_op == - pop_jump_if_false L5 - load_const "https://ai-gateway.vercel.sh/v4/ai" - store_var _40 - - L5: - load_var _40 - call vercel.internal._gw_images_trim_slash - store_var _38 - load_type string - load_var _38 - call baml.String.from - load_const "/image-model" - bin_op + - load_var c - load_field .query_params - call vercel.internal._gw_images_with_query - store_var url - load_var c - call vercel.internal._gw_images_headers - store_var _46 - load_var merged - call baml.json.stringify - store_var _47 - load_const "POST" - load_var2 12 15 - load_var _47 - init_instance baml.http.Request .method, .url, .headers, .body - return - - L6: - load_const "ai-gateway-images" - load_const null - load_const "the gateway image endpoint has no tool calling; run tools with a chat client instead" - load_const null - init_instance ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body - throw -} - -function vercel.internal.gateway_images_warning_text(warning: vercel.internal.GwImagesWarning) -> string { - load_var warning - load_field .feature - store_var_load_var _3 - load_const null - cmp_op == - pop_jump_if_false L0 - load_var warning - load_field .setting - store_var _3 - - L0: - load_var _3 - store_var subject - load_var warning - load_field .details - store_var_load_var _7 - load_const null - cmp_op == - pop_jump_if_false L1 - load_var warning - load_field .message - store_var _7 - - L1: - load_var _7 - store_var detail - load_var warning - load_field .type - store_var_load_var _14 - load_const null - cmp_op == - pop_jump_if_false L2 - load_const "other" - store_var _14 - - L2: - load_type string - load_var _14 - call baml.String.from - store_var _12 - load_const "ai-gateway-images: " - load_var _12 - bin_op + - load_const " warning" - bin_op + - store_var head - load_var subject - store_var _19 - load_var _19 - narrow_bind string, slot=10 - pop_jump_if_false L3 - jump L4 - - L3: - load_var head - store_var named - jump L5 - - L4: - load_var _19 - store_var subject_name - load_type string - load_var head - call baml.String.from - store_var _22 - load_type string - load_var subject_name - call baml.String.from - store_var _25 - load_var _22 - load_const " for " - bin_op + - load_var _25 - bin_op + - store_var named - - L5: - load_var detail - store_var _28 - load_var _28 - narrow_bind string, slot=14 - pop_jump_if_false L6 - jump L7 - - L6: - load_var named - jump L8 - - L7: - load_var _28 - store_var text - load_type string - load_var named - call baml.String.from - store_var _31 - load_type string - load_var text - call baml.String.from - store_var _34 - load_var _31 - load_const ": " - bin_op + - load_var _34 - bin_op + - - L8: - return -} From cdfb375b887dc350eeedf6f359af64c2e33befb7 Mon Sep 17 00:00:00 2001 From: 2kai2kai2 Date: Wed, 12 Aug 2026 16:14:04 -0700 Subject: [PATCH 2/5] `Read` and `Write` for `File` --- .../baml_std/baml/ns_csv/csv.baml | 40 +- .../baml_std/baml/ns_fs/fs.baml | 50 ++- ...tests__render_builtin_package_listing.snap | 90 ++--- .../baml_tests/baml_src/ns_csv/csv.baml | 2 +- .../crates/baml_tests/baml_src/ns_fs/fs.baml | 67 ++-- .../baml_src/ns_fs/fs_from_rust.baml | 41 +- .../diagnostic_errors/builtin_io/fs_ops.baml | 14 +- .../baml_tests/snapshots/baml_src/csv.snap | 8 +- .../baml_tests/snapshots/baml_src/fs.snap | 349 +++++++++++++----- ...tests__compiles____ai_std____04_5_mir.snap | 4 +- ..._compiles____ai_std____05_diagnostics.snap | 1 - ...sts__compiles____ai_std____06_codegen.snap | 4 +- ...ests__compiles____baml_std____03_ppir.snap | 24 +- ...sts__compiles____baml_std____04_5_mir.snap | 208 ++++++----- ...s__compiles____baml_std____06_codegen.snap | 151 ++++---- ...catchable_parse_error__05_diagnostics.snap | 1 - ...iagnostic_errors__builtin_io__03_ppir.snap | 14 +- ...ors__builtin_io__10_formatter__fs_ops.snap | 14 +- .../baml_tests/src/compiler2_tir/phase6.rs | 2 +- ...__phase5__snapshot_baml_package_items.snap | 2 +- .../crates/bridge_wasm/src/wasm_io_fs.rs | 46 +-- .../crates/sys_auth/src/io_bridge.rs | 9 +- baml_language/crates/sys_auth/src/testing.rs | 31 +- .../crates/sys_native/src/io_impls.rs | 124 +++---- baml_language/crates/sys_ops/src/lib.rs | 73 +--- .../crates/sys_wasm/src/web_sysops.rs | 37 +- .../csharp/phase12_resources/Program.cs | 22 +- .../roundtrip_tests/TestHandles.java | 14 +- .../roundtrip_tests/test_handles.py | 15 +- .../roundtrip_tests/test_handles.rs | 15 +- .../customizable/roundtrip_handles.test.ts | 11 +- .../sdk_tests/harness_setup/src/csharp.rs | 37 +- 32 files changed, 782 insertions(+), 738 deletions(-) diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_csv/csv.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_csv/csv.baml index 6b1bca2b5fc..9f05def10b1 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_csv/csv.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_csv/csv.baml @@ -7,7 +7,7 @@ // // The streaming reader is the only parser; every one-shot is a wrapper over // it. File IO goes through `baml.fs` handles: the reader pumps chunks via -// `File.read_bytes` from thin BAML method bodies, while all tokenization, +// `baml.io.Read` from thin BAML method bodies, while all tokenization, // decoding, and encoding is native. /// Classifies a `CsvError` for portable handling. @@ -405,29 +405,21 @@ class CsvReader { /// (internal) Pull the next chunk from the backing file, or mark EOF for /// in-memory sources. IO errors are stream-scoped and fatal: the reader is /// marked exhausted before the throw, so subsequent `next()` calls return - /// `baml.iter.Done`. - function _read_chunk(self) -> null throws CsvError | root.errors.Io { - match (self._file) { + /// `baml.iter.Done`. A closed handle arrives as one of those IO errors — + /// `baml.io.Read` has no separate channel for it. + function _read_chunk(self) -> void throws root.errors.Io { + let chunk = self._file?.read(65536) catch (e) { + root.errors.Io => { + self._mark_exhausted(); + throw e + }, + }; + match (chunk) { null => { self._feed_eof(); - null }, - let f: root.fs.File => { - let chunk = f.read_bytes(65536) catch (e) { - root.errors.InvalidArgument { message } => { - throw _error(CsvErrorKind.Closed, "underlying file handle is closed: " + message) - }, - root.errors.Io => { - self._mark_exhausted(); - throw e - }, - }; - if (chunk.length() == 0) { - self._feed_eof(); - } else { - self._feed(chunk); - } - null + let bytes: uint8array => { + self._feed(bytes); }, } } @@ -583,11 +575,7 @@ class CsvWriter { null => null, let f: root.fs.File => { if (out.length() > 0) { - f.write(out) catch (_) { - root.errors.InvalidArgument { message } => { - throw root.errors.Io { message: "underlying file handle is closed: " + message } - }, - }; + f.write(out.to_utf8()); } null }, diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_fs/fs.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_fs/fs.baml index b93b9ccdf38..8f276b39b96 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_fs/fs.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_fs/fs.baml @@ -9,29 +9,19 @@ class File { /// Reads the entire remaining file contents as a UTF-8 string. function text( self, - ) -> string throws root.errors.Io | root.errors.InvalidArgument | root.errors.ParseError { - $rust_io_function + ) -> string throws root.errors.Io | root.errors.ParseError { + self.as.read_to_string() } /// Reads the entire remaining file contents as raw bytes. - function bytes(self) -> uint8array throws root.errors.Io | root.errors.InvalidArgument { - $rust_io_function - } - - /// Reads up to `n` bytes from the file and returns them as a UTF-8 string. - function read( - self, - n: int, - ) -> string throws root.errors.Io | root.errors.InvalidArgument | root.errors.ParseError { - $rust_io_function + function bytes(self) -> uint8array throws root.errors.Io { + self.as.read_to_end() } - /// Reads up to `n` bytes from the file and returns them as raw bytes. - function read_bytes( - self, - n: int, - ) -> uint8array throws root.errors.Io | root.errors.InvalidArgument { - $rust_io_function + implements root.io.Read { + function read(self, n: int) -> uint8array? throws root.errors.Io { + $rust_io_function + } } /// Closes the file handle, flushing any pending writes. @@ -51,17 +41,23 @@ class File { $rust_io_function } - /// Writes `data` to the file at the current cursor position. Returns the number of bytes written. - function write(self, data: string) -> int throws root.errors.Io | root.errors.InvalidArgument { - $rust_io_function + implements root.io.Write { + function write(self, data: uint8array) -> int throws root.errors.Io { + $rust_io_function + } + + function flush(self) -> void throws root.errors.Io { + $rust_io_function + } } - /// Writes raw bytes `data` to the file at the current cursor position. Returns the number of bytes written. - function write_bytes( - self, - data: uint8array, - ) -> int throws root.errors.Io | root.errors.InvalidArgument { - $rust_io_function + /// Writes `data` to the file at the current cursor position. Returns the number of bytes written. + function write(self, data: string | uint8array) -> int throws root.errors.Io { + let bytes = match (data) { + string => data.to_utf8(), + uint8array => data, + }; + self.as.write(bytes) } } diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index 4c6c4007bc6..9fb4fd7c406 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -58,36 +58,36 @@ class baml.csv.CsvSkip /baml/ns_csv/csv.baml class baml.csv.CsvHeaders /baml/ns_csv/csv.baml:172 class baml.csv.CsvRecord /baml/ns_csv/csv.baml:181 class baml.csv.CsvReader /baml/ns_csv/csv.baml:246 -class baml.csv.CsvRows /baml/ns_csv/csv.baml:438 -class baml.csv.CsvWriter /baml/ns_csv/csv.baml:484 -function baml.csv.reader /baml/ns_csv/csv.baml:606 -function baml.csv.open /baml/ns_csv/csv.baml:614 -function baml.csv.read /baml/ns_csv/csv.baml:628 -function baml.csv.parse /baml/ns_csv/csv.baml:639 -function baml.csv.decode /baml/ns_csv/csv.baml:665 -function baml.csv.decode_optional /baml/ns_csv/csv.baml:680 -function baml.csv.decode_one /baml/ns_csv/csv.baml:698 -function baml.csv.writer /baml/ns_csv/csv.baml:719 -function baml.csv.create /baml/ns_csv/csv.baml:725 -function baml.csv.buffer /baml/ns_csv/csv.baml:736 -function baml.csv.write /baml/ns_csv/csv.baml:742 -function baml.csv.stringify /baml/ns_csv/csv.baml:754 -function baml.csv.stringify_records /baml/ns_csv/csv.baml:767 -function baml.csv.to_markdown /baml/ns_csv/csv.baml:792 -function baml.csv.to_markdown_records /baml/ns_csv/csv.baml:797 -function baml.csv._reader /baml/ns_csv/csv.baml:809 -function baml.csv._writer /baml/ns_csv/csv.baml:819 -function baml.csv._buffer /baml/ns_csv/csv.baml:829 -function baml.csv._validate_columns /baml/ns_csv/csv.baml:836 -function baml.csv._try_decode /baml/ns_csv/csv.baml:843 -function baml.csv._decode_record /baml/ns_csv/csv.baml:850 -function baml.csv._cell_by_name /baml/ns_csv/csv.baml:856 -function baml.csv._cell_by_index /baml/ns_csv/csv.baml:862 -function baml.csv._encode_row /baml/ns_csv/csv.baml:869 -function baml.csv._encode_rows /baml/ns_csv/csv.baml:876 -function baml.csv._to_markdown /baml/ns_csv/csv.baml:882 -function baml.csv._to_markdown_records /baml/ns_csv/csv.baml:889 -function baml.csv._error /baml/ns_csv/csv.baml:898 +class baml.csv.CsvRows /baml/ns_csv/csv.baml:430 +class baml.csv.CsvWriter /baml/ns_csv/csv.baml:476 +function baml.csv.reader /baml/ns_csv/csv.baml:594 +function baml.csv.open /baml/ns_csv/csv.baml:602 +function baml.csv.read /baml/ns_csv/csv.baml:616 +function baml.csv.parse /baml/ns_csv/csv.baml:627 +function baml.csv.decode /baml/ns_csv/csv.baml:653 +function baml.csv.decode_optional /baml/ns_csv/csv.baml:668 +function baml.csv.decode_one /baml/ns_csv/csv.baml:686 +function baml.csv.writer /baml/ns_csv/csv.baml:707 +function baml.csv.create /baml/ns_csv/csv.baml:713 +function baml.csv.buffer /baml/ns_csv/csv.baml:724 +function baml.csv.write /baml/ns_csv/csv.baml:730 +function baml.csv.stringify /baml/ns_csv/csv.baml:742 +function baml.csv.stringify_records /baml/ns_csv/csv.baml:755 +function baml.csv.to_markdown /baml/ns_csv/csv.baml:780 +function baml.csv.to_markdown_records /baml/ns_csv/csv.baml:785 +function baml.csv._reader /baml/ns_csv/csv.baml:797 +function baml.csv._writer /baml/ns_csv/csv.baml:807 +function baml.csv._buffer /baml/ns_csv/csv.baml:817 +function baml.csv._validate_columns /baml/ns_csv/csv.baml:824 +function baml.csv._try_decode /baml/ns_csv/csv.baml:831 +function baml.csv._decode_record /baml/ns_csv/csv.baml:838 +function baml.csv._cell_by_name /baml/ns_csv/csv.baml:844 +function baml.csv._cell_by_index /baml/ns_csv/csv.baml:850 +function baml.csv._encode_row /baml/ns_csv/csv.baml:857 +function baml.csv._encode_rows /baml/ns_csv/csv.baml:864 +function baml.csv._to_markdown /baml/ns_csv/csv.baml:870 +function baml.csv._to_markdown_records /baml/ns_csv/csv.baml:877 +function baml.csv._error /baml/ns_csv/csv.baml:886 function baml.env.get /baml/ns_env/env.baml:6 function baml.env.get_or_panic /baml/ns_env/env.baml:11 class baml.env.Ref /baml/ns_env/env.baml:29 @@ -112,21 +112,21 @@ class baml.errors.StackFrame /baml/ns_errors/stack class baml.errors.StackTrace /baml/ns_errors/stack_trace.baml:9 class baml.errors.UnknownError /baml/ns_errors/unknown_error.baml:2 class baml.fs.File /baml/ns_fs/fs.baml:6 -function baml.fs.open /baml/ns_fs/fs.baml:72 -function baml.fs.exists /baml/ns_fs/fs.baml:80 -function baml.fs.remove /baml/ns_fs/fs.baml:88 -function baml.fs.size /baml/ns_fs/fs.baml:93 -function baml.fs.read /baml/ns_fs/fs.baml:99 -function baml.fs.write /baml/ns_fs/fs.baml:104 -function baml.fs.write_bytes /baml/ns_fs/fs.baml:109 -class baml.fs.DirEntry /baml/ns_fs/fs.baml:114 -class baml.fs.MkdirOptions /baml/ns_fs/fs.baml:122 -function baml.fs.read_dir /baml/ns_fs/fs.baml:128 -function baml.fs.mkdir /baml/ns_fs/fs.baml:133 -function baml.fs.remove_dir /baml/ns_fs/fs.baml:139 -function baml.fs.remove_dir_all /baml/ns_fs/fs.baml:148 -function baml.fs.chmod /baml/ns_fs/fs.baml:171 -function baml.fs.symlink /baml/ns_fs/fs.baml:191 +function baml.fs.open /baml/ns_fs/fs.baml:68 +function baml.fs.exists /baml/ns_fs/fs.baml:76 +function baml.fs.remove /baml/ns_fs/fs.baml:84 +function baml.fs.size /baml/ns_fs/fs.baml:89 +function baml.fs.read /baml/ns_fs/fs.baml:95 +function baml.fs.write /baml/ns_fs/fs.baml:100 +function baml.fs.write_bytes /baml/ns_fs/fs.baml:105 +class baml.fs.DirEntry /baml/ns_fs/fs.baml:110 +class baml.fs.MkdirOptions /baml/ns_fs/fs.baml:118 +function baml.fs.read_dir /baml/ns_fs/fs.baml:124 +function baml.fs.mkdir /baml/ns_fs/fs.baml:129 +function baml.fs.remove_dir /baml/ns_fs/fs.baml:135 +function baml.fs.remove_dir_all /baml/ns_fs/fs.baml:144 +function baml.fs.chmod /baml/ns_fs/fs.baml:167 +function baml.fs.symlink /baml/ns_fs/fs.baml:187 enum baml.future.FutureState /baml/ns_future/future.baml:21 class baml.future.Future /baml/ns_future/future.baml:28 function baml.future.all_complete /baml/ns_future/future.baml:80 diff --git a/baml_language/crates/baml_tests/baml_src/ns_csv/csv.baml b/baml_language/crates/baml_tests/baml_src/ns_csv/csv.baml index 4a47e0c40ca..6bac7a77906 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_csv/csv.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_csv/csv.baml @@ -1525,7 +1525,7 @@ function csv_caller_owned_handles_stay_open() -> string { w.write_record(record); w.close(); // The caller's handle is still usable after w.close(). - let appended = wf.write("tail\n"); + let appended = wf.write("tail\n".to_utf8()); wf.close(); let content = baml.fs.read(path); baml.fs.remove(path); diff --git a/baml_language/crates/baml_tests/baml_src/ns_fs/fs.baml b/baml_language/crates/baml_tests/baml_src/ns_fs/fs.baml index af34d48ada2..667f7fec332 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_fs/fs.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_fs/fs.baml @@ -18,7 +18,7 @@ // fs_open_nonexistent_file // fs_file_write_on_readonly_errors // fs_remove_nonexistent_errors -// fs_file_read_negative_n_errors +// fs_file_read_non_positive_n_is_empty // fs_file_close_invalidates_handle // fs_write_wrapper_closes_on_error // fs_read_nonexistent_errors @@ -194,7 +194,7 @@ function fs_file_rw_write_and_read_back_fn() -> string { baml.fs.write(path, "Hello from BAML!"); let file = baml.fs.open(path, "r+"); file.seek_from("start", 6); - file.write("to Rust!!"); + file.write("to Rust!!".to_utf8()); file.seek_from("start", 0); let result = file.text(); baml.fs.remove(path); @@ -206,7 +206,7 @@ test "fs_file_rw_write_and_read_back" { } // ============================================================================ -// write_bytes to open file handle +// write raw bytes to an open file handle // ============================================================================ function fs_file_rw_write_bytes_fn() -> bool { @@ -219,7 +219,7 @@ function fs_file_rw_write_bytes_fn() -> bool { let bytes = baml.fs.open(src, "r").bytes(); let file = baml.fs.open(dst, "r+"); file.seek_from("start", 0); - let n = file.write_bytes(bytes); + let n = file.write(bytes); baml.fs.remove(src); baml.fs.remove(dst); // "AB" is 2 bytes @@ -292,48 +292,67 @@ test "fs_size_returns_length" { } // ============================================================================ -// file.read(n) reads up to n bytes as a string +// file.read(n) reads up to n bytes. `?? b""` only stands in for end-of-file, +// which none of these fixtures reach — the assertion still pins the content. // ============================================================================ -function fs_file_read_n_bytes_fn() -> string { +function fs_file_read_n_bytes_fn() -> uint8array { let path = fs_tmp("read_n.txt"); baml.fs.write(path, "Hello, world!"); let f = baml.fs.open(path, "r"); - let result = f.read(5); + let result = f.read(5) ?? b""; baml.fs.remove(path); result } test "fs_file_read_n_bytes" { - assert.equal(fs_file_read_n_bytes_fn(), "Hello") + assert.equal(fs_file_read_n_bytes_fn(), "Hello".to_utf8()) } // ============================================================================ // file.read(n) truncates at EOF (doesn't error when n > file size) // ============================================================================ -function fs_file_read_truncates_at_eof_fn() -> string { +function fs_file_read_truncates_at_eof_fn() -> uint8array { let path = fs_tmp("read_eof.txt"); baml.fs.write(path, "abc"); let f = baml.fs.open(path, "r"); - let result = f.read(100); + let result = f.read(100) ?? b""; baml.fs.remove(path); result } test "fs_file_read_truncates_at_eof" { - assert.equal(fs_file_read_truncates_at_eof_fn(), "abc") + assert.equal(fs_file_read_truncates_at_eof_fn(), "abc".to_utf8()) } // ============================================================================ -// file.read_bytes(n) reads n raw bytes — verified by length +// file.read(n) at the very end of the file signals EOF with `null` +// ============================================================================ + +function fs_file_read_at_eof_is_null_fn() -> bool { + let path = fs_tmp("read_at_eof.txt"); + baml.fs.write(path, "abc"); + let f = baml.fs.open(path, "r"); + f.read(100); + let past_end = f.read(100); + baml.fs.remove(path); + past_end == null +} + +test "fs_file_read_at_eof_is_null" { + assert.is_true(fs_file_read_at_eof_is_null_fn()) +} + +// ============================================================================ +// file.read(n) reads n raw bytes — verified by length // ============================================================================ function fs_file_read_bytes_n_fn() -> bool { let path = fs_tmp("read_bytes_n.bin"); baml.fs.write(path, "ABCDE"); let f = baml.fs.open(path, "r"); - let data = f.read_bytes(3); + let data = f.read(3) ?? b""; baml.fs.remove(path); // should have read exactly 3 bytes data.length() == 3 @@ -347,18 +366,18 @@ test "fs_file_read_bytes_n" { // file.read advances the cursor (sequential reads) // ============================================================================ -function fs_file_read_advances_cursor_fn() -> string { +function fs_file_read_advances_cursor_fn() -> uint8array { let path = fs_tmp("read_advances.txt"); baml.fs.write(path, "ABCDEFGH"); let f = baml.fs.open(path, "r"); f.read(3); - let result = f.read(3); + let result = f.read(3) ?? b""; baml.fs.remove(path); result } test "fs_file_read_advances_cursor" { - assert.equal(fs_file_read_advances_cursor_fn(), "DEF") + assert.equal(fs_file_read_advances_cursor_fn(), "DEF".to_utf8()) } // ============================================================================ @@ -369,7 +388,7 @@ function fs_open_append_creates_and_appends_fn() -> bool { let path = fs_tmp("append.txt"); baml.fs.write(path, "start!"); let f = baml.fs.open(path, "a"); - let n = f.write("more!"); + let n = f.write("more!".to_utf8()); let readback = baml.fs.read(path); baml.fs.remove(path); n == 5 && readback == "start!more!" @@ -389,9 +408,9 @@ function fs_open_append_creates_missing_file_fn() -> bool { // (if it does exist, this test's logic is still correct since we only // check what we wrote — but let's be safe and overwrite) let f = baml.fs.open(path, "w"); - f.write(""); + f.write("".to_utf8()); let f2 = baml.fs.open(path, "a"); - let n = f2.write("hi"); + let n = f2.write("hi".to_utf8()); let readback = baml.fs.read(path); baml.fs.remove(path); n == 2 && readback == "hi" @@ -409,7 +428,7 @@ function fs_open_append_plus_can_read_fn() -> string { let path = fs_tmp("append_plus.txt"); baml.fs.write(path, "existing"); let f = baml.fs.open(path, "a+"); - f.write(" more"); + f.write(" more".to_utf8()); f.seek_from("start", 0); let result = f.text(); baml.fs.remove(path); @@ -461,7 +480,7 @@ function fs_open_w_truncates_existing_fn() -> bool { let path = fs_tmp("open_w_truncate.txt"); baml.fs.write(path, "original content"); let f = baml.fs.open(path, "w"); - let n = f.write("new"); + let n = f.write("new".to_utf8()); let readback = baml.fs.read(path); baml.fs.remove(path); n == 3 && readback == "new" @@ -478,7 +497,7 @@ test "fs_open_w_truncates_existing" { function fs_open_w_creates_missing_file_fn() -> bool { let path = fs_tmp("open_w_new.txt"); let f = baml.fs.open(path, "w"); - let n = f.write("hi"); + let n = f.write("hi".to_utf8()); let readback = baml.fs.read(path); baml.fs.remove(path); n == 2 && readback == "hi" @@ -496,7 +515,7 @@ function fs_open_w_plus_reads_after_write_fn() -> string { let path = fs_tmp("open_w_plus.txt"); baml.fs.write(path, "original"); let f = baml.fs.open(path, "w+"); - f.write("fresh"); + f.write("fresh".to_utf8()); f.seek_from("start", 0); let result = f.text(); baml.fs.remove(path); @@ -514,7 +533,7 @@ test "fs_open_w_plus_reads_after_write" { function fs_open_w_creates_parent_dirs_fn() -> bool { let path = fs_tmp("open_w_parent") + "/nested/dir/new.txt"; let f = baml.fs.open(path, "w"); - let n = f.write("nested"); + let n = f.write("nested".to_utf8()); let readback = baml.fs.read(path); // Can only remove the file; intermediate dirs cannot be removed via baml.fs.remove. // The path is unique per test so re-runs are idempotent (write overwrites). diff --git a/baml_language/crates/baml_tests/baml_src/ns_fs/fs_from_rust.baml b/baml_language/crates/baml_tests/baml_src/ns_fs/fs_from_rust.baml index 7009047200c..38cfb6e4303 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_fs/fs_from_rust.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_fs/fs_from_rust.baml @@ -4,8 +4,13 @@ // Error types (from crates/sys_native/src/io_impls.rs): // open/read/write/remove/remove_dir/remove_dir_all/read_dir/mkdir failures // -> baml.errors.Io -// file.read(negative n) -> baml.errors.InvalidArgument -// operations on a closed handle -> baml.errors.InvalidArgument ("File is closed") +// file.read(n <= 0) -> an empty chunk, NOT an error and NOT the +// `null` that signals end-of-file +// closed handle, via baml.io.Read / baml.io.Write +// -> baml.errors.Io ("File is closed"), the +// only class those interfaces declare +// closed handle, via close / seek_from +// -> baml.errors.InvalidArgument ("File is closed") // seek_from("start", negative) -> baml.errors.InvalidArgument // // HERMETICITY: same idiom as fs.baml — every test builds a unique path via @@ -50,7 +55,7 @@ function fs_file_write_on_readonly_errors_fn() -> bool { baml.fs.write(path, "content"); let file = baml.fs.open(path, "r"); let msg = { - file.write("should fail"); + file.write("should fail".to_utf8()); "no error thrown" } catch (e) { baml.errors.Io => e.message @@ -196,29 +201,31 @@ test "fs_remove_dir_all_on_file_errors" { } // ============================================================================ -// file.read with a negative length errors (InvalidArgument) +// file.read with a non-positive length reads nothing: an EMPTY chunk, which is +// distinct from the `null` that means end-of-file. Reporting EOF here would +// silently truncate `read_to_end`, so the sentinel below ("x", length 1) makes +// a `null` return fail the assertion instead of passing as an empty read. // ============================================================================ -function fs_file_read_negative_n_errors_fn() -> bool { - let path = fs_tmp("read_negative_n.txt"); +function fs_file_read_non_positive_n_is_empty_fn() -> int[] { + let path = fs_tmp("read_non_positive_n.txt"); baml.fs.write(path, "abc"); let f = baml.fs.open(path, "r"); - let threw = { - f.read(-1); - false - } catch (e) { - baml.errors.InvalidArgument => true - }; + let zero = f.read(0) ?? "x".to_utf8(); + let negative = f.read(-1) ?? "x".to_utf8(); + f.close(); baml.fs.remove(path); - threw + [zero.length(), negative.length()] } -test "fs_file_read_negative_n_errors" { - assert.is_true(fs_file_read_negative_n_errors_fn()) +test "fs_file_read_non_positive_n_is_empty" { + assert.equal(fs_file_read_non_positive_n_is_empty_fn(), [0, 0]) } // ============================================================================ -// close invalidates the handle: reading after close errors ("File is closed") +// close invalidates the handle: reading after close errors ("File is closed"). +// `text()` reads through `baml.io.Read`, whose only declared error class is +// `Io` — unlike `close`/`seek_from`, which still raise `InvalidArgument`. // ============================================================================ function fs_file_close_invalidates_handle_fn() -> bool { @@ -230,7 +237,7 @@ function fs_file_close_invalidates_handle_fn() -> bool { f.text(); false } catch (e) { - baml.errors.InvalidArgument => true + baml.errors.Io => true }; baml.fs.remove(path); threw diff --git a/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/fs_ops.baml b/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/fs_ops.baml index 6444f21d931..1cb66ca913b 100644 --- a/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/fs_ops.baml +++ b/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/fs_ops.baml @@ -40,14 +40,14 @@ function ReadFileBytesAndClose() -> uint8array { data } -function ReadChunk() -> string { +function ReadChunk() -> uint8array? { let f = baml.fs.open("log.txt", "r"); f.read(512) } -function ReadChunkBytes() -> uint8array { +function ReadChunkOrEmpty() -> uint8array { let f = baml.fs.open("data.bin", "r"); - f.read_bytes(4096) + f.read(4096) ?? b"" } function WriteFile() -> int { @@ -67,24 +67,24 @@ function SeekAndRead() -> string { function FileWrite() -> int { let f = baml.fs.open("data.txt", "r+"); - f.write("hello") + f.write("hello".to_utf8()) } function FileWriteBytes() -> int { let f = baml.fs.open("data.bin", "r+"); let data = f.bytes(); f.seek_from("start", 0); - f.write_bytes(data) + f.write(data) } function Append() -> int { let f = baml.fs.open("log.txt", "a"); - f.write("line\n") + f.write("line\n".to_utf8()) } function AppendAndRead() -> string { let f = baml.fs.open("log.txt", "a+"); - f.write("line\n"); + f.write("line\n".to_utf8()); f.seek_from("start", 0); f.text() } diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/csv.snap b/baml_language/crates/baml_tests/snapshots/baml_src/csv.snap index 1fc473bfba2..433ff5b0da6 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/csv.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/csv.snap @@ -784,9 +784,13 @@ function csv.csv_caller_owned_handles_stay_open() -> string { load_var w call baml.csv.CsvWriter.close pop 1 - load_var wf load_const "tail\n" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _16 + load_var2 4 7 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var appended load_var wf sys_op baml.fs.File.close diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/fs.snap b/baml_language/crates/baml_tests/snapshots/baml_src/fs.snap index 6e55347ddc7..48409543600 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/fs.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/fs.snap @@ -116,179 +116,186 @@ function fs.$init_test_ns_fs_fs(registry: testing.TestCollector) -> null { pop 1 load_var registry load_const "root.fs" - load_const "fs_file_read_bytes_n" + load_const "fs_file_read_at_eof_is_null" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_file_read_advances_cursor" + load_const "fs_file_read_bytes_n" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_append_creates_and_appends" + load_const "fs_file_read_advances_cursor" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_append_creates_missing_file" + load_const "fs_open_append_creates_and_appends" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_append_plus_can_read" + load_const "fs_open_append_creates_missing_file" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_file_close_is_idempotent" + load_const "fs_open_append_plus_can_read" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_read_returns_contents" + load_const "fs_file_close_is_idempotent" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_w_truncates_existing" + load_const "fs_read_returns_contents" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_w_creates_missing_file" + load_const "fs_open_w_truncates_existing" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_w_plus_reads_after_write" + load_const "fs_open_w_creates_missing_file" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_open_w_creates_parent_dirs" + load_const "fs_open_w_plus_reads_after_write" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_read_dir_returns_entries" + load_const "fs_open_w_creates_parent_dirs" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_read_dir_type_flags" + load_const "fs_read_dir_returns_entries" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_read_dir_empty_dir" + load_const "fs_read_dir_type_flags" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_mkdir_creates_directory" + load_const "fs_read_dir_empty_dir" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_mkdir_recursive_creates_parents" + load_const "fs_mkdir_creates_directory" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_mkdir_recursive_is_idempotent" + load_const "fs_mkdir_recursive_creates_parents" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_remove_dir_removes_empty" + load_const "fs_mkdir_recursive_is_idempotent" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_remove_dir_all_removes_tree" + load_const "fs_remove_dir_removes_empty" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_remove_dir_all_idempotent" + load_const "fs_remove_dir_all_removes_tree" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_chmod_on_existing_file" + load_const "fs_remove_dir_all_idempotent" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_chmod_rejects_high_mode" + load_const "fs_chmod_on_existing_file" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_chmod_rejects_negative_mode" + load_const "fs_chmod_rejects_high_mode" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_chmod_missing_path_errors" + load_const "fs_chmod_rejects_negative_mode" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 load_var registry load_const "root.fs" - load_const "fs_symlink_onto_existing_path_errors" + load_const "fs_chmod_missing_path_errors" make_closure ., 0 load_const null call testing.TestCollector.register_test_at pop 1 + load_var registry + load_const "root.fs" + load_const "fs_symlink_onto_existing_path_errors" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 load_const null return } @@ -352,7 +359,7 @@ function fs.$init_test_ns_fs_fs_from_rust(registry: testing.TestCollector) -> nu pop 1 load_var registry load_const "root.fs" - load_const "fs_file_read_negative_n_errors" + load_const "fs_file_read_non_positive_n_is_empty" make_closure ., 0 load_const null call testing.TestCollector.register_test_at @@ -579,11 +586,11 @@ function fs.fs_file_close_invalidates_handle_fn() -> bool { sys_op baml.fs.File.close pop 1 load_var f - sys_op baml.fs.File.text + call baml.fs.File.text pop 1 jump L2 load_var e - is_type baml.errors.InvalidArgument + is_type baml.errors.Io pop_jump_if_false L0 jump L1 @@ -633,7 +640,7 @@ function fs.fs_file_close_is_idempotent_fn() -> void { return } -function fs.fs_file_read_advances_cursor_fn() -> string { +function fs.fs_file_read_advances_cursor_fn() -> uint8array { load_const "read_advances.txt" call user.fs.fs_tmp store_var path @@ -647,11 +654,27 @@ function fs.fs_file_read_advances_cursor_fn() -> string { store_var f load_var f load_const 3 - sys_op baml.fs.File.read + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 pop 1 load_var f load_const 3 - sys_op baml.fs.File.read + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _9 + load_var _9 + store_var_load_var _8 + load_const null + cmp_op == + pop_jump_if_false L0 + load_const b"" + call baml.deep_copy + store_var _8 + + L0: + load_var _8 store_var result load_var path sys_op baml.fs.remove @@ -660,6 +683,39 @@ function fs.fs_file_read_advances_cursor_fn() -> string { return } +function fs.fs_file_read_at_eof_is_null_fn() -> bool { + load_const "read_at_eof.txt" + call user.fs.fs_tmp + store_var path + load_var path + load_const "abc" + sys_op baml.fs.write + pop 1 + load_var path + load_const "r" + sys_op baml.fs.open + store_var f + load_var f + load_const 100 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + pop 1 + load_var f + load_const 100 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var past_end + load_var path + sys_op baml.fs.remove + pop 1 + load_var past_end + load_const null + call baml.ops.equals_equals + return +} + function fs.fs_file_read_bytes_n_fn() -> bool { load_const "read_bytes_n.bin" call user.fs.fs_tmp @@ -672,21 +728,35 @@ function fs.fs_file_read_bytes_n_fn() -> bool { load_const "r" sys_op baml.fs.open load_const 3 - sys_op baml.fs.File.read_bytes + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _8 + load_var _8 + store_var_load_var _7 + load_const null + cmp_op == + pop_jump_if_false L0 + load_const b"" + call baml.deep_copy + store_var _7 + + L0: + load_var _7 store_var data load_var path sys_op baml.fs.remove pop 1 load_var data container_len - store_var _9 - load_var _9 + store_var _12 + load_var _12 load_const 3 cmp_int_op == return } -function fs.fs_file_read_n_bytes_fn() -> string { +function fs.fs_file_read_n_bytes_fn() -> uint8array { load_const "read_n.txt" call user.fs.fs_tmp store_var path @@ -698,7 +768,21 @@ function fs.fs_file_read_n_bytes_fn() -> string { load_const "r" sys_op baml.fs.open load_const 5 - sys_op baml.fs.File.read + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _8 + load_var _8 + store_var_load_var _7 + load_const null + cmp_op == + pop_jump_if_false L0 + load_const b"" + call baml.deep_copy + store_var _7 + + L0: + load_var _7 store_var result load_var path sys_op baml.fs.remove @@ -707,8 +791,8 @@ function fs.fs_file_read_n_bytes_fn() -> string { return } -function fs.fs_file_read_negative_n_errors_fn() -> bool { - load_const "read_negative_n.txt" +function fs.fs_file_read_non_positive_n_is_empty_fn() -> int[] { + load_const "read_non_positive_n.txt" call user.fs.fs_tmp store_var path load_var path @@ -718,38 +802,63 @@ function fs.fs_file_read_negative_n_errors_fn() -> bool { load_var path load_const "r" sys_op baml.fs.open - load_const 1 - unary_op - - sys_op baml.fs.File.read - pop 1 - jump L2 - load_var e - is_type baml.errors.InvalidArgument + store_var f + load_var f + load_const 0 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _8 + load_var _8 + store_var_load_var _7 + load_const null + cmp_op == pop_jump_if_false L0 - jump L1 + load_const "x" + call baml.String.to_utf8 + store_var _7 L0: - load_var e - rethrow + load_var _7 + store_var zero + load_var f + load_const 1 + unary_op - + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _12 + load_var _12 + store_var_load_var _11 + load_const null + cmp_op == + pop_jump_if_false L1 + load_const "x" + call baml.String.to_utf8 + store_var _11 L1: - load_const true - store_var threw - jump L3 - - L2: - load_const false - store_var threw - - L3: + load_var _11 + store_var negative + load_var f + sys_op baml.fs.File.close + pop 1 load_var path sys_op baml.fs.remove pop 1 - load_var threw + load_var zero + container_len + store_var _18 + load_var negative + container_len + store_var _19 + load_var2 9 10 + load_type int + alloc_array 2 return } -function fs.fs_file_read_truncates_at_eof_fn() -> string { +function fs.fs_file_read_truncates_at_eof_fn() -> uint8array { load_const "read_eof.txt" call user.fs.fs_tmp store_var path @@ -761,7 +870,21 @@ function fs.fs_file_read_truncates_at_eof_fn() -> string { load_const "r" sys_op baml.fs.open load_const 100 - sys_op baml.fs.File.read + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _8 + load_var _8 + store_var_load_var _7 + load_const null + cmp_op == + pop_jump_if_false L0 + load_const b"" + call baml.deep_copy + store_var _7 + + L0: + load_var _7 store_var result load_var path sys_op baml.fs.remove @@ -788,7 +911,7 @@ function fs.fs_file_rw_seek_and_read_fn() -> string { sys_op baml.fs.File.seek_from pop 1 load_var file - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -814,9 +937,13 @@ function fs.fs_file_rw_write_and_read_back_fn() -> string { load_const 6 sys_op baml.fs.File.seek_from pop 1 - load_var file load_const "to Rust!!" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _8 + load_var2 2 3 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 pop 1 load_var file load_const "start" @@ -824,7 +951,7 @@ function fs.fs_file_rw_write_and_read_back_fn() -> string { sys_op baml.fs.File.seek_from pop 1 load_var file - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -851,7 +978,7 @@ function fs.fs_file_rw_write_bytes_fn() -> bool { load_var src load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.bytes + call baml.fs.File.bytes store_var bytes load_var dst load_const "r+" @@ -863,7 +990,9 @@ function fs.fs_file_rw_write_bytes_fn() -> bool { sys_op baml.fs.File.seek_from pop 1 load_var2 4 3 - sys_op baml.fs.File.write_bytes + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var src sys_op baml.fs.remove @@ -931,8 +1060,14 @@ function fs.fs_file_write_on_readonly_errors_fn() -> bool { load_var path load_const "r" sys_op baml.fs.open + store_var file load_const "should fail" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _9 + load_var2 2 5 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 pop 1 jump L2 load_var e @@ -1136,7 +1271,7 @@ function fs.fs_open_and_read_bytes_fn() -> bool { load_var path load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.bytes + call baml.fs.File.bytes store_var data load_var path sys_op baml.fs.remove @@ -1161,7 +1296,7 @@ function fs.fs_open_and_read_fn() -> string { load_var path load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -1181,8 +1316,14 @@ function fs.fs_open_append_creates_and_appends_fn() -> bool { load_var path load_const "a" sys_op baml.fs.open + store_var f load_const "more!" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _7 + load_var2 2 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var path sys_op baml.fs.read @@ -1210,14 +1351,26 @@ function fs.fs_open_append_creates_missing_file_fn() -> bool { load_var path load_const "w" sys_op baml.fs.open + store_var f load_const "" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _5 + load_var2 2 3 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 pop 1 load_var path load_const "a" sys_op baml.fs.open + store_var f2 load_const "hi" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _9 + load_var2 4 6 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var path sys_op baml.fs.read @@ -1250,9 +1403,13 @@ function fs.fs_open_append_plus_can_read_fn() -> string { load_const "a+" sys_op baml.fs.open store_var f - load_var f load_const " more" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _7 + load_var2 2 3 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 pop 1 load_var f load_const "start" @@ -1260,7 +1417,7 @@ function fs.fs_open_append_plus_can_read_fn() -> string { sys_op baml.fs.File.seek_from pop 1 load_var f - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -1276,7 +1433,7 @@ function fs.fs_open_nonexistent_file_fn() -> bool { bin_op + load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.text + call baml.fs.File.text pop 1 jump L2 load_var e @@ -1306,8 +1463,14 @@ function fs.fs_open_w_creates_missing_file_fn() -> bool { load_var path load_const "w" sys_op baml.fs.open + store_var f load_const "hi" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _5 + load_var2 2 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var path sys_op baml.fs.read @@ -1336,8 +1499,14 @@ function fs.fs_open_w_creates_parent_dirs_fn() -> bool { store_var_load_var path load_const "w" sys_op baml.fs.open + store_var f load_const "nested" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _6 + load_var2 2 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var path sys_op baml.fs.read @@ -1370,9 +1539,13 @@ function fs.fs_open_w_plus_reads_after_write_fn() -> string { load_const "w+" sys_op baml.fs.open store_var f - load_var f load_const "fresh" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _7 + load_var2 2 3 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 pop 1 load_var f load_const "start" @@ -1380,7 +1553,7 @@ function fs.fs_open_w_plus_reads_after_write_fn() -> string { sys_op baml.fs.File.seek_from pop 1 load_var f - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -1400,8 +1573,14 @@ function fs.fs_open_w_truncates_existing_fn() -> bool { load_var path load_const "w" sys_op baml.fs.open + store_var f load_const "new" - sys_op baml.fs.File.write + call baml.String.to_utf8 + store_var _7 + load_var2 2 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 store_var n load_var path sys_op baml.fs.read @@ -2036,7 +2215,7 @@ function fs.fs_roundtrip_write_and_read_fn() -> string { load_var path load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.text + call baml.fs.File.text store_var result load_var path sys_op baml.fs.remove @@ -2164,7 +2343,7 @@ function fs.fs_write_bytes_fn() -> bool { load_var src load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.bytes + call baml.fs.File.bytes store_var data load_var2 2 3 sys_op baml.fs.write_bytes @@ -2172,7 +2351,7 @@ function fs.fs_write_bytes_fn() -> bool { load_var dst load_const "r" sys_op baml.fs.open - sys_op baml.fs.File.bytes + call baml.fs.File.bytes store_var readback load_var src sys_op baml.fs.remove diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap index 73fb9a6c09e..5d0ec6641e2 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap @@ -3420,7 +3420,7 @@ fn ai.internal._resolve_media_content(url: string | null, file: string | null, i } bb44: { - _24 = sys_op const fn baml.fs.File.bytes(copy _8) -> bb45 unwind bb54; + _24 = call const fn baml.fs.File.bytes(copy _8) -> [bb45, unwind: bb54]; } bb45: { @@ -3486,7 +3486,7 @@ fn ai.internal._resolve_media_content(url: string | null, file: string | null, i bb57: { _29 = const "media file " + copy _30; _28 = copy _29 + const " could not be read: "; - _35 = load_type(baml.errors.InvalidArgument | baml.errors.Io); + _35 = load_type(baml.errors.Io); _34 = call const fn baml.String.from(copy _23) -> [bb58]; } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____05_diagnostics.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____05_diagnostics.snap index 6a3e68e2bf2..40cf564409c 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____05_diagnostics.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____05_diagnostics.snap @@ -1,6 +1,5 @@ --- source: crates/baml_tests/src/generated_tests.rs -assertion_line: 2591 --- === COMPILER2 DIAGNOSTICS === No errors found. diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap index 8dc10b5f225..337d437e031 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap @@ -4312,7 +4312,7 @@ function ai.internal._resolve_media_content(url: string | null, file: string | n L23: load_var handle - sys_op baml.fs.File.bytes + call baml.fs.File.bytes call baml.Uint8Array.to_base64 store_var data jump L24 @@ -4325,7 +4325,7 @@ function ai.internal._resolve_media_content(url: string | null, file: string | n load_var path call baml.String.from store_var _30 - load_type baml.errors.InvalidArgument | baml.errors.Io + load_type baml.errors.Io load_var e call baml.String.from store_var _34 diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap index b0ac393f1ac..105a605ba21 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap @@ -476,7 +476,7 @@ function baml.csv._cell_by_index(rec: baml.csv.CsvRecord, index: int) -> T? [bu function baml.csv._cell_by_name(rec: baml.csv.CsvRecord, column: string) -> T? [builtin] function baml.csv._decode_record(rec: baml.csv.CsvRecord) -> T [builtin] function baml.csv._emit(self: ?, out: string) -> null [expr] { - { } match (self._file) { null => null, f: root.fs.File => { if (out.length() Gt 0) { f.write(out) catch (_) { root.errors.InvalidArgument { message: message } => { throw root.errors.Io { message: "underlying file h..." Add message } } } } } null } + { } match (self._file) { null => null, f: root.fs.File => { if (out.length() Gt 0) { f.write(out.to_utf8()) } } null } } function baml.csv._encode_header(self: ?, names: string[]) -> string [builtin] function baml.csv._encode_record(self: ?, record: baml.csv.CsvValue[]) -> string [builtin] @@ -492,8 +492,8 @@ function baml.csv._mark_closed(self: ?) -> null [builtin] function baml.csv._mark_exhausted(self: ?) -> null [builtin] function baml.csv._poll(self: ?) -> baml.csv.CsvRecord | baml.csv.CsvSkip | baml.csv.CsvNeedData | root.iter.Done [builtin] function baml.csv._poll_headers(self: ?) -> baml.csv.CsvHeaders | baml.csv.CsvNeedData [builtin] -function baml.csv._read_chunk(self: ?) -> null [expr] { - { } match (self._file) { null => { self._feed_eof() } null, f: root.fs.File => { let chunk = f.read_bytes(65536) catch (e) { root.errors.InvalidArgument { message: message } => { throw _error(CsvErrorKind.Closed, "underlying file h..." Add message) }, root.errors.Io => { self._mark_exhausted(); throw e } }; if (chunk.length() Eq 0) { self._feed_eof() } else { self._feed(chunk) } } null } +function baml.csv._read_chunk(self: ?) -> void [expr] { + { let chunk = self._file?.read(65536) catch (e) { root.errors.Io => { self._mark_exhausted(); throw e } } } match (chunk) { null => { self._feed_eof() }, bytes: uint8array => { self._feed(bytes) } } } function baml.csv._reader(source: string | uint8array | root.fs.File, options: baml.csv.ReaderOptions?, owns_file: bool) -> baml.csv.CsvReader [builtin] function baml.csv._to_markdown(rows: T[], max_rows: int) -> string [builtin] @@ -805,15 +805,17 @@ class baml.fs.MkdirOptions { class baml.fs.MkdirOptions$stream { recursive: bool | null } -function baml.fs.bytes(self: ?) -> uint8array [builtin] +function baml.fs.bytes(self: ?) -> uint8array [expr] { + { } self.as.read_to_end() +} function baml.fs.chmod(path: string, mode: int) -> void [builtin] function baml.fs.close(self: ?) -> null [builtin] function baml.fs.exists(path: string) -> bool [builtin] +function baml.fs.flush(self: ?) -> void [builtin] function baml.fs.mkdir(path: string, options: baml.fs.MkdirOptions) -> null [builtin] function baml.fs.open(path: string, mode: "r" | "r+" | "w" | "w+" | "a" | "a+") -> baml.fs.File [builtin] -function baml.fs.read(self: ?, n: int) -> string [builtin] +function baml.fs.read(self: ?, n: int) -> uint8array? [builtin] function baml.fs.read(path: string) -> string [builtin] -function baml.fs.read_bytes(self: ?, n: int) -> uint8array [builtin] function baml.fs.read_dir(path: string) -> baml.fs.DirEntry[] [builtin] function baml.fs.remove(path: string) -> null [builtin] function baml.fs.remove_dir(path: string) -> null [builtin] @@ -821,10 +823,14 @@ function baml.fs.remove_dir_all(path: string) -> null [builtin] function baml.fs.seek_from(self: ?, whence: "start" | "current" | "end", offset: int) -> int [builtin] function baml.fs.size(path: string) -> int [builtin] function baml.fs.symlink(target: string, path: string) -> void [builtin] -function baml.fs.text(self: ?) -> string [builtin] -function baml.fs.write(self: ?, data: string) -> int [builtin] +function baml.fs.text(self: ?) -> string [expr] { + { } self.as.read_to_string() +} +function baml.fs.write(self: ?, data: uint8array) -> int [builtin] +function baml.fs.write(self: ?, data: string | uint8array) -> int [expr] { + { let bytes = match (data) { string => data.to_utf8(), uint8array => data } } self.as.write(bytes) +} function baml.fs.write(path: string, content: string) -> int [builtin] -function baml.fs.write_bytes(self: ?, data: uint8array) -> int [builtin] function baml.fs.write_bytes(path: string, content: uint8array) -> int [builtin] --- /baml/ns_future/future.baml --- diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index 4e5af863d78..4c7f49c7d64 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -1489,7 +1489,7 @@ fn baml.csv.CsvReader.root.iter.Iterator.next(self: baml.csv.CsvReader) -> baml. let _12: (baml.csv.CsvError) -> null throws never // cb let _13: (baml.csv.CsvError) -> null throws never let _14: baml.csv.CsvError - let _15: null + let _15: void bb0: { goto -> bb1; @@ -1569,7 +1569,7 @@ fn baml.csv.CsvReader.headers(self: baml.csv.CsvReader) -> null | string[] { let _2: baml.csv.CsvHeaders | baml.csv.CsvNeedData let _3: baml.csv.CsvHeaders | baml.csv.CsvNeedData let _4: baml.csv.CsvHeaders // h - let _5: null + let _5: void bb0: { goto -> bb1; @@ -1714,110 +1714,85 @@ fn baml.csv.CsvReader._mark_closed = builtin(vm) fn baml.csv.CsvReader._mark_exhausted = builtin(vm) -fn baml.csv.CsvReader._read_chunk(self: baml.csv.CsvReader) -> null { +fn baml.csv.CsvReader._read_chunk(self: baml.csv.CsvReader) -> void { // Locals: - let _0: null // _0 // return + let _0: void // _0 // return let _1: baml.csv.CsvReader // self // param - let _2: null | baml.fs.File - let _3: bool - let _4: null - let _5: baml.fs.File // f - let _6: uint8array // chunk - let _7: unknown // e + let _2: null | uint8array // chunk + let _3: unknown // e + let _4: (baml.fs.File, int) -> null | uint8array throws baml.errors.Io + let _5: null | baml.fs.File + let _6: bool + let _7: null | baml.fs.File let _8: bool - let _9: bool - let _10: string - let _11: string // message - let _12: baml.csv.CsvError - let _13: string - let _14: string - let _15: null - let _16: bool - let _17: int - let _18: null - let _19: null - let _20: uint8array + let _9: null + let _10: bool + let _11: null + let _12: uint8array // bytes + let _13: null + let _14: uint8array bb0: { - _2 = copy _1.1; - _3 = copy _2 == const null; - branch copy _3 -> [bb7, bb1]; + _5 = copy _1.1; + _6 = copy _5 == const null; + branch copy _6 -> [bb2, bb1]; } bb1: { - _5 = copy _2; - _6 = sys_op const fn baml.fs.File.read_bytes(copy _5, const 65536_i64) -> bb2 unwind bb10; + _7 = copy _1.1; + _4 = make_bound_method baml.fs.File.root.io.Read.read(copy _7); + _2 = call copy _4(const 65536_i64) -> [bb3, unwind: bb9]; } bb2: { - _17 = len(_6); + _2 = const null; goto -> bb3; } bb3: { - _16 = copy _17 == const 0_i64; - branch copy _16 -> [bb5, bb4]; + _10 = copy _2 == const null; + branch copy _10 -> [bb6, bb4]; } bb4: { - _20 = copy _6; - _19 = call const fn baml.csv.CsvReader._feed(copy _1, copy _20) -> [bb6]; + _12 = copy _2; + _14 = copy _12; + _13 = call const fn baml.csv.CsvReader._feed(copy _1, copy _14) -> [bb5]; } bb5: { - _18 = call const fn baml.csv.CsvReader._feed_eof(copy _1) -> [bb6]; + _0 = const null; + goto -> bb8; } bb6: { - _0 = const null; - goto -> bb9; + _11 = call const fn baml.csv.CsvReader._feed_eof(copy _1) -> [bb7]; } bb7: { - _4 = call const fn baml.csv.CsvReader._feed_eof(copy _1) -> [bb8]; + _0 = const null; + goto -> bb8; } bb8: { - _0 = const null; - goto -> bb9; + return; } bb9: { - return; + _8 = is_type(copy _3, baml.errors.Io); + branch copy _8 -> [bb11, bb10]; } bb10: { - _8 = is_type(copy _7, baml.errors.InvalidArgument); - branch copy _8 -> [bb15, bb11]; + rethrow copy _3; } bb11: { - _9 = is_type(copy _7, baml.errors.Io); - branch copy _9 -> [bb13, bb12]; + _9 = call const fn baml.csv.CsvReader._mark_exhausted(copy _1) -> [bb12]; } bb12: { - rethrow copy _7; - } - - bb13: { - _15 = call const fn baml.csv.CsvReader._mark_exhausted(copy _1) -> [bb14]; - } - - bb14: { - rethrow copy _7; - } - - bb15: { - _10 = copy _7.0; - _11 = copy _10; - _14 = copy _11; - _13 = const "underlying file handle is closed: " + copy _14; - _12 = call const fn baml.csv._error(const baml.csv.CsvErrorKind.Closed, copy _13) -> [bb16]; - } - - bb16: { - throw copy _12; + rethrow copy _3; } } @@ -2114,18 +2089,12 @@ fn baml.csv.CsvWriter._emit(self: baml.csv.CsvWriter, out: string) -> null { let _6: bool let _7: int let _8: int - let _9: unknown // _ - let _10: bool - let _11: string - let _12: string // message - let _13: baml.errors.Io - let _14: string - let _15: string + let _9: uint8array bb0: { _3 = copy _1.1; _4 = copy _3 == const null; - branch copy _4 -> [bb5, bb1]; + branch copy _4 -> [bb6, bb1]; } bb1: { @@ -2135,43 +2104,29 @@ fn baml.csv.CsvWriter._emit(self: baml.csv.CsvWriter, out: string) -> null { bb2: { _6 = copy _7 > const 0_i64; - branch copy _6 -> [bb3, bb4]; + branch copy _6 -> [bb3, bb5]; } bb3: { - _8 = sys_op const fn baml.fs.File.write(copy _5, copy _2) -> bb4 unwind bb7; + _9 = call const fn baml.String.to_utf8(copy _2) -> [bb4]; } bb4: { - _0 = const null; - goto -> bb6; + _8 = virtual_call write as baml.io.Write(copy _5, copy _9) -> [bb5]; } bb5: { _0 = const null; - goto -> bb6; + goto -> bb7; } bb6: { - return; + _0 = const null; + goto -> bb7; } bb7: { - _10 = is_type(copy _9, baml.errors.InvalidArgument); - branch copy _10 -> [bb9, bb8]; - } - - bb8: { - rethrow copy _9; - } - - bb9: { - _11 = copy _9.0; - _12 = copy _11; - _15 = copy _12; - _14 = const "underlying file handle is closed: " + copy _15; - _13 = baml.errors.Io { copy _14 }; - throw copy _13; + return; } } @@ -3256,21 +3211,76 @@ fn baml.errors.StackTrace.baml.ToString.to_string(self: baml.errors.StackTrace) fn baml.errors.StackTrace._to_string_impl = builtin(vm) -fn baml.fs.File.text = builtin(io) +fn baml.fs.File.text(self: baml.fs.File) -> string { + // Locals: + let _0: string // _0 // return + let _1: baml.fs.File // self // param + + bb0: { + _0 = virtual_call read_to_string as baml.io.Read(copy _1) -> [bb1]; + } + + bb1: { + return; + } +} -fn baml.fs.File.bytes = builtin(io) +fn baml.fs.File.bytes(self: baml.fs.File) -> uint8array { + // Locals: + let _0: uint8array // _0 // return + let _1: baml.fs.File // self // param + + bb0: { + _0 = virtual_call read_to_end as baml.io.Read(copy _1) -> [bb1]; + } -fn baml.fs.File.read = builtin(io) + bb1: { + return; + } +} -fn baml.fs.File.read_bytes = builtin(io) +fn baml.fs.File.root.io.Read.read = builtin(io) fn baml.fs.File.close = builtin(io) fn baml.fs.File.seek_from = builtin(io) -fn baml.fs.File.write = builtin(io) +fn baml.fs.File.root.io.Write.write = builtin(io) + +fn baml.fs.File.root.io.Write.flush = builtin(io) -fn baml.fs.File.write_bytes = builtin(io) +fn baml.fs.File.write(self: baml.fs.File, data: string | uint8array) -> int { + // Locals: + let _0: int // _0 // return + let _1: baml.fs.File // self // param + let _2: string | uint8array // data // param + let _3: uint8array // bytes + let _4: bool + let _5: uint8array + + bb0: { + _4 = is_type(copy _2, string); + branch copy _4 -> [bb2, bb1]; + } + + bb1: { + _3 = copy _2; + goto -> bb3; + } + + bb2: { + _3 = call const fn baml.String.to_utf8(copy _2) -> [bb3]; + } + + bb3: { + _5 = copy _3; + _0 = virtual_call write as baml.io.Write(copy _1, copy _5) -> [bb4]; + } + + bb4: { + return; + } +} fn baml.fs.open = builtin(io) diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index 87551a5d21a..83e7028ef99 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -1269,85 +1269,63 @@ function baml.csv.CsvReader._poll(self: baml.csv.CsvReader) -> baml.csv.CsvRecor function baml.csv.CsvReader._poll_headers(self: baml.csv.CsvReader) -> baml.csv.CsvHeaders | baml.csv.CsvNeedData { } -function baml.csv.CsvReader._read_chunk(self: baml.csv.CsvReader) -> null { +function baml.csv.CsvReader._read_chunk(self: baml.csv.CsvReader) -> void { load_var self load_field ._file - store_var_load_var _2 load_const null cmp_op == pop_jump_if_false L0 - jump L9 + jump L3 L0: - load_var _2 load_const 65536 - sys_op baml.fs.File.read_bytes + load_var self + load_field ._file + make_bound_method baml.fs.File.root.io.Read.read + call_indirect store_var chunk - jump L5 - load_var e - is_type baml.errors.InvalidArgument - pop_jump_if_false L1 jump L4 - - L1: load_var e is_type baml.errors.Io - pop_jump_if_false L2 - jump L3 + pop_jump_if_false L1 + jump L2 - L2: + L1: load_var e rethrow - L3: + L2: load_var self call baml.csv.CsvReader._mark_exhausted pop 1 load_var e rethrow - L4: - load_const baml.csv.CsvErrorKind.Closed - alloc_variant baml.csv.CsvErrorKind - load_const "underlying file handle is closed: " - load_var e - load_field .0 - bin_op + - call baml.csv._error - throw + L3: + load_const null + store_var chunk - L5: + L4: load_var chunk - container_len - store_var _17 - load_var _17 - load_const 0 - cmp_int_op == - pop_jump_if_false L6 - jump L7 + load_const null + cmp_op == + pop_jump_if_false L5 + jump L6 - L6: - load_var2 1 3 + L5: + load_var2 1 2 call baml.csv.CsvReader._feed pop 1 - jump L8 - - L7: - load_var self - call baml.csv.CsvReader._feed_eof - pop 1 - - L8: load_const null - jump L10 + jump L7 - L9: + L6: load_var self call baml.csv.CsvReader._feed_eof pop 1 load_const null - L10: + L7: return } @@ -1644,43 +1622,31 @@ function baml.csv.CsvWriter._emit(self: baml.csv.CsvWriter, out: string) -> null load_const null cmp_op == pop_jump_if_false L0 - jump L4 + jump L2 L0: load_var out call baml.String.length load_const 0 cmp_int_op > - pop_jump_if_false L3 - load_var2 3 2 - sys_op baml.fs.File.write - pop 1 - jump L3 - load_var _ - is_type baml.errors.InvalidArgument pop_jump_if_false L1 - jump L2 + load_var out + call baml.String.to_utf8 + store_var _9 + load_var2 3 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 + pop 1 L1: - load_var _ - rethrow - - L2: - load_const "underlying file handle is closed: " - load_var _ - load_field .0 - bin_op + - init_instance baml.errors.Io .message - throw - - L3: load_const null - jump L5 + jump L3 - L4: + L2: load_const null - L5: + L3: return } @@ -2481,27 +2447,64 @@ function baml.errors.StackTrace.baml.ToString.to_string(self: baml.errors.StackT } function baml.fs.File.bytes(self: baml.fs.File) -> uint8array { + load_var self + load_type baml.io.Read + load_const "read_to_end" + virtual_call nargs=1 ntypeargs=0 + store_var _0 + load_var _0 + return } function baml.fs.File.close(self: baml.fs.File) -> null { } -function baml.fs.File.read(self: baml.fs.File, n: int) -> string { +function baml.fs.File.root.io.Read.read(self: baml.fs.File, n: int) -> uint8array | null { +} + +function baml.fs.File.root.io.Write.flush(self: baml.fs.File) -> void { } -function baml.fs.File.read_bytes(self: baml.fs.File, n: int) -> uint8array { +function baml.fs.File.root.io.Write.write(self: baml.fs.File, data: uint8array) -> int { } function baml.fs.File.seek_from(self: baml.fs.File, whence: "start" | "current" | "end", offset: int) -> int { } function baml.fs.File.text(self: baml.fs.File) -> string { + load_var self + load_type baml.io.Read + load_const "read_to_string" + virtual_call nargs=1 ntypeargs=0 + store_var _0 + load_var _0 + return } -function baml.fs.File.write(self: baml.fs.File, data: string) -> int { -} +function baml.fs.File.write(self: baml.fs.File, data: string | uint8array) -> int { + load_var data + is_type string + pop_jump_if_false L0 + jump L1 + + L0: + load_var data + store_var bytes + jump L2 -function baml.fs.File.write_bytes(self: baml.fs.File, data: uint8array) -> int { + L1: + load_var data + call baml.String.to_utf8 + store_var bytes + + L2: + load_var2 1 4 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 + store_var _0 + load_var _0 + return } function baml.fs.chmod(path: string, mode: int) -> void { diff --git a/baml_language/crates/baml_tests/snapshots/compiles/llm_parse_catchable_parse_error/baml_tests__compiles__llm_parse_catchable_parse_error__05_diagnostics.snap b/baml_language/crates/baml_tests/snapshots/compiles/llm_parse_catchable_parse_error/baml_tests__compiles__llm_parse_catchable_parse_error__05_diagnostics.snap index 96729487b9d..3ff0219b407 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/llm_parse_catchable_parse_error/baml_tests__compiles__llm_parse_catchable_parse_error__05_diagnostics.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/llm_parse_catchable_parse_error/baml_tests__compiles__llm_parse_catchable_parse_error__05_diagnostics.snap @@ -1,6 +1,5 @@ --- source: crates/baml_tests/src/generated_tests.rs -assertion_line: 16554 --- === COMPILER2 DIAGNOSTICS === [type] E0063 diff --git a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap index e15976e91ce..bf7e2a10d97 100644 --- a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap @@ -3,28 +3,28 @@ source: crates/baml_tests/src/generated_tests.rs --- === PPIR === function user.Append() -> int [expr] { - { let f = baml.fs.open("log.txt", "a") } f.write("line\n") + { let f = baml.fs.open("log.txt", "a") } f.write("line\n".to_utf8()) } function user.AppendAndRead() -> string [expr] { - { let f = baml.fs.open("log.txt", "a+"); f.write("line\n"); f.seek_from("start", 0) } f.text() + { let f = baml.fs.open("log.txt", "a+"); f.write("line\n".to_utf8()); f.seek_from("start", 0) } f.text() } function user.Exists() -> bool [expr] { { } baml.fs.exists("maybe.txt") } function user.FileWrite() -> int [expr] { - { let f = baml.fs.open("data.txt", "r+") } f.write("hello") + { let f = baml.fs.open("data.txt", "r+") } f.write("hello".to_utf8()) } function user.FileWriteBytes() -> int [expr] { - { let f = baml.fs.open("data.bin", "r+"); let data = f.bytes(); f.seek_from("start", 0) } f.write_bytes(data) + { let f = baml.fs.open("data.bin", "r+"); let data = f.bytes(); f.seek_from("start", 0) } f.write(data) } function user.ReadAndClose() -> string [expr] { { let f = baml.fs.open("example.txt", "r"); let content = f.text(); f.close() } content } -function user.ReadChunk() -> string [expr] { +function user.ReadChunk() -> uint8array? [expr] { { let f = baml.fs.open("log.txt", "r") } f.read(512) } -function user.ReadChunkBytes() -> uint8array [expr] { - { let f = baml.fs.open("data.bin", "r") } f.read_bytes(4096) +function user.ReadChunkOrEmpty() -> uint8array [expr] { + { let f = baml.fs.open("data.bin", "r") } f.read(4096) NullCoalesce b"<0 bytes>" } function user.ReadDir() -> baml.fs.DirEntry[] [expr] { { } baml.fs.read_dir("some/path") diff --git a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__fs_ops.snap b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__fs_ops.snap index 10202b083dd..8d6474fdee3 100644 --- a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__fs_ops.snap +++ b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__fs_ops.snap @@ -43,14 +43,14 @@ function ReadFileBytesAndClose() -> uint8array { data } -function ReadChunk() -> string { +function ReadChunk() -> uint8array? { let f = baml.fs.open("log.txt", "r"); f.read(512) } -function ReadChunkBytes() -> uint8array { +function ReadChunkOrEmpty() -> uint8array { let f = baml.fs.open("data.bin", "r"); - f.read_bytes(4096) + f.read(4096) ?? b"" } function WriteFile() -> int { @@ -70,24 +70,24 @@ function SeekAndRead() -> string { function FileWrite() -> int { let f = baml.fs.open("data.txt", "r+"); - f.write("hello") + f.write("hello".to_utf8()) } function FileWriteBytes() -> int { let f = baml.fs.open("data.bin", "r+"); let data = f.bytes(); f.seek_from("start", 0); - f.write_bytes(data) + f.write(data) } function Append() -> int { let f = baml.fs.open("log.txt", "a"); - f.write("line\n") + f.write("line\n".to_utf8()) } function AppendAndRead() -> string { let f = baml.fs.open("log.txt", "a+"); - f.write("line\n"); + f.write("line\n".to_utf8()); f.seek_from("start", 0); f.text() } diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/phase6.rs b/baml_language/crates/baml_tests/src/compiler2_tir/phase6.rs index be721c21f45..ee2b05e4e34 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/phase6.rs +++ b/baml_language/crates/baml_tests/src/compiler2_tir/phase6.rs @@ -1251,7 +1251,7 @@ function f(file: baml.fs.File) -> null { ); let ty = expr_type_in_function(&db, file, "f", "read"); assert!( - ty.starts_with("(n: int) -> string throws "), + ty.starts_with("(n: int) -> uint8array | null throws "), "expected builtin member value to preserve declared throws, got `{ty}`" ); assert!( diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index 9b0560a8e3e..6e03a4a9e43 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -119,7 +119,7 @@ namespace baml.errors: namespace baml.events: namespace baml.fs: class DirEntry { methods: [] } - class File { methods: [text, bytes, read, read_bytes, close, seek_from, write, write_bytes] } + class File { methods: [text, bytes, close, seek_from, write, read, write, flush] } class MkdirOptions { methods: [] } function chmod function exists diff --git a/baml_language/crates/bridge_wasm/src/wasm_io_fs.rs b/baml_language/crates/bridge_wasm/src/wasm_io_fs.rs index b8fea0c1881..76e043ef6ad 100644 --- a/baml_language/crates/bridge_wasm/src/wasm_io_fs.rs +++ b/baml_language/crates/bridge_wasm/src/wasm_io_fs.rs @@ -186,30 +186,6 @@ fn remove_dir_all_recursive(vfs: &WasmVfs, path: &str) -> Result<(), VmBamlError // ============================================================================ impl io::IoClassFsFile for WasmIoFs { - fn text( - &self, - _h: &Arc, - _c: CallId, - _f: owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } - - fn bytes( - &self, - _h: &Arc, - _c: CallId, - _f: owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput> { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } - fn read( &self, _h: &Arc, @@ -217,20 +193,7 @@ impl io::IoClassFsFile for WasmIoFs { _f: owned::fs::File, _n: i64, _ctx: &SysOpContext, - ) -> SysOpOutput { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } - - fn read_bytes( - &self, - _h: &Arc, - _c: CallId, - _f: owned::fs::File, - _n: i64, - _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) @@ -267,7 +230,7 @@ impl io::IoClassFsFile for WasmIoFs { _h: &Arc, _c: CallId, _f: owned::fs::File, - _d: String, + _d: Vec, _ctx: &SysOpContext, ) -> SysOpOutput { SysOpOutput::err(VmBamlError::Unsupported { @@ -275,14 +238,13 @@ impl io::IoClassFsFile for WasmIoFs { }) } - fn write_bytes( + fn flush( &self, _h: &Arc, _c: CallId, _f: owned::fs::File, - _d: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) diff --git a/baml_language/crates/sys_auth/src/io_bridge.rs b/baml_language/crates/sys_auth/src/io_bridge.rs index 01c425bd512..e1b73ac2a47 100644 --- a/baml_language/crates/sys_auth/src/io_bridge.rs +++ b/baml_language/crates/sys_auth/src/io_bridge.rs @@ -34,7 +34,7 @@ use std::sync::Arc; use async_trait::async_trait; use indexmap::IndexMap; -use sys_types::{BexExternalValue, runtime_io::RuntimeIo}; +use sys_types::runtime_io::RuntimeIo; /// Total deadline for one credential HTTP round trip, in nanoseconds (the unit /// `RuntimeIo::http__send` takes). @@ -139,12 +139,7 @@ impl BamlAuthIo { } async fn file_text(&self, path: &str) -> Option { - let handle = self - .io - .fs_open(path.to_string(), BexExternalValue::String("r".into())) - .await - .ok()?; - self.io.fs_file_text(&handle).await.ok() + self.io.fs_read(path.to_string()).await.ok() } /// One HTTP round trip through the runtime, returning `(status, body)`. diff --git a/baml_language/crates/sys_auth/src/testing.rs b/baml_language/crates/sys_auth/src/testing.rs index 73aa0ae9709..6c448e7609e 100644 --- a/baml_language/crates/sys_auth/src/testing.rs +++ b/baml_language/crates/sys_auth/src/testing.rs @@ -18,7 +18,7 @@ use std::{ use indexmap::IndexMap; use sys_types::{ BexExternalValue, - runtime_io::{FsFileHandle, HttpResponseHandle, RuntimeIo, RuntimeIoError}, + runtime_io::{HttpResponseHandle, RuntimeIo, RuntimeIoError}, }; /// Counts the IO a resolution actually performed, so a test can assert that @@ -92,35 +92,14 @@ impl RuntimeIo for StubIo { Box::pin(async move { Ok(value) }) } - fn fs_open( + fn fs_read( &self, path: String, - _mode: BexExternalValue, - ) -> Pin> + Send + '_>> { - self.calls.fs.fetch_add(1, Ordering::SeqCst); - let exists = self.files.contains_key(&path); - Box::pin(async move { - if exists { - // The handle carries the path so `fs_file_text` can resolve it. - Ok(FsFileHandle { - raw: BexExternalValue::String(path.into()), - }) - } else { - Err(RuntimeIoError::Other(format!("no such file: {path}"))) - } - }) - } - - fn fs_file_text( - &self, - file: &FsFileHandle, ) -> Pin> + Send + '_>> { - let contents = match &file.raw { - BexExternalValue::String(path) => self.files.get(&path.to_string()).cloned(), - _ => None, - }; + self.calls.fs.fetch_add(1, Ordering::SeqCst); + let contents = self.files.get(&path).cloned(); Box::pin(async move { - contents.ok_or_else(|| RuntimeIoError::Other("unreadable handle".to_string())) + contents.ok_or_else(|| RuntimeIoError::Other(format!("no such file: {path}"))) }) } diff --git a/baml_language/crates/sys_native/src/io_impls.rs b/baml_language/crates/sys_native/src/io_impls.rs index 767a7c3530e..4cd46888106 100644 --- a/baml_language/crates/sys_native/src/io_impls.rs +++ b/baml_language/crates/sys_native/src/io_impls.rs @@ -415,53 +415,18 @@ fn closed_err() -> VmBamlError { } } -impl io::IoClassFsFile for NativeSysOps { - fn text( - &self, - _heap: &Arc, - _call_id: CallId, - file: owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput { - use tokio::io::AsyncReadExt; - - SysOpOutput::async_op(async move { - let handle = downcast_handle(&file)?; - let mut guard = handle.lock().await; - let f = guard.as_mut().ok_or_else(closed_err)?; - let mut contents = String::new(); - f.read_to_string(&mut contents) - .await - .map_err(|e| VmBamlError::Io { - message: format!("Failed to read file: {e}"), - })?; - Ok(contents) - }) - } - - fn bytes( - &self, - _heap: &Arc, - _call_id: CallId, - file: owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput> { - use tokio::io::AsyncReadExt; - - SysOpOutput::async_op(async move { - let handle = downcast_handle(&file)?; - let mut guard = handle.lock().await; - let f = guard.as_mut().ok_or_else(closed_err)?; - let mut contents = Vec::new(); - f.read_to_end(&mut contents) - .await - .map_err(|e| VmBamlError::Io { - message: format!("Failed to read file: {e}"), - })?; - Ok(contents) - }) +/// The closed-handle failure for the `root.io.Read` / `root.io.Write` methods. +/// +/// Those interfaces declare `throws root.errors.Io` only, so the +/// `InvalidArgument` that `File`'s own methods raise is not in the contract — +/// a closed stream has to surface as an I/O failure instead. +fn closed_io_err() -> VmBamlError { + VmBamlError::Io { + message: "File is closed".into(), } +} +impl io::IoClassFsFile for NativeSysOps { fn read( &self, _heap: &Arc, @@ -469,25 +434,7 @@ impl io::IoClassFsFile for NativeSysOps { file: owned::fs::File, n: i64, _ctx: &SysOpContext, - ) -> SysOpOutput { - SysOpOutput::async_op(async move { - let bytes = read_up_to(&file, n).await?; - String::from_utf8(bytes) - .map_err(|e| VmBamlError::ParseError { - message: format!("Invalid UTF-8 in file: {e}"), - }) - .map_err(VmRustFnError::from) - }) - } - - fn read_bytes( - &self, - _heap: &Arc, - _call_id: CallId, - file: owned::fs::File, - n: i64, - _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { SysOpOutput::async_op( async move { read_up_to(&file, n).await.map_err(VmRustFnError::from) }, ) @@ -560,41 +507,54 @@ impl io::IoClassFsFile for NativeSysOps { _heap: &Arc, _call_id: CallId, file: owned::fs::File, - data: String, + data: Vec, _ctx: &SysOpContext, ) -> SysOpOutput { SysOpOutput::async_op(async move { - write_all_bytes(&file, data.into_bytes()) + write_all_bytes(&file, data) .await .map_err(VmRustFnError::from) }) } - fn write_bytes( + fn flush( &self, _heap: &Arc, _call_id: CallId, file: owned::fs::File, - data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput<()> { + use tokio::io::AsyncWriteExt; + SysOpOutput::async_op(async move { - write_all_bytes(&file, data) - .await - .map_err(VmRustFnError::from) + let handle = downcast_handle(&file)?; + let mut guard = handle.lock().await; + let f = guard.as_mut().ok_or_else(closed_io_err)?; + f.flush().await.map_err(|e| VmBamlError::Io { + message: format!("Failed to flush: {e}"), + })?; + Ok(()) }) } } -async fn read_up_to(file: &owned::fs::File, n: i64) -> Result, VmBamlError> { +/// `root.io.Read.read` over an open handle: at most `n` bytes, or `None` once +/// the cursor has already reached the end of the file. +/// +/// A zero-length read only means end-of-file when bytes were actually asked +/// for, so `n <= 0` yields an empty chunk rather than the end-of-source signal +/// — a caller that requested nothing has learned nothing about the cursor, and +/// reporting EOF there would silently truncate `read_to_end`. +async fn read_up_to(file: &owned::fs::File, n: i64) -> Result>, VmBamlError> { use tokio::io::AsyncReadExt; - let cap = u64::try_from(n).map_err(|_| VmBamlError::InvalidArgument { - message: format!("Negative read length: {n}"), - })?; + let cap = match u64::try_from(n) { + Err(_) | Ok(0) => return Ok(Some(Vec::new())), // read nothing + Ok(cap) => cap, + }; let handle = downcast_handle(file)?; let mut guard = handle.lock().await; - let f = guard.as_mut().ok_or_else(closed_err)?; + let f = guard.as_mut().ok_or_else(closed_io_err)?; let mut buf = Vec::new(); f.take(cap) .read_to_end(&mut buf) @@ -602,15 +562,21 @@ async fn read_up_to(file: &owned::fs::File, n: i64) -> Result, VmBamlErr .map_err(|e| VmBamlError::Io { message: format!("Failed to read file: {e}"), })?; - Ok(buf) + Ok((!buf.is_empty()).then_some(buf)) } +/// `root.io.Write.write` over an open handle. +/// +/// The flush is part of the write rather than something `flush` alone +/// provides: `tokio::fs::File` buffers internally, and callers (plus every +/// existing `fs` test) rely on a completed `write` being visible to a +/// subsequent `seek_from` + `read` on the same handle. async fn write_all_bytes(file: &owned::fs::File, data: Vec) -> Result { use tokio::io::AsyncWriteExt; let handle = downcast_handle(file)?; let mut guard = handle.lock().await; - let f = guard.as_mut().ok_or_else(closed_err)?; + let f = guard.as_mut().ok_or_else(closed_io_err)?; #[allow(clippy::cast_possible_wrap)] let len = data.len() as i64; f.write_all(&data).await.map_err(|e| VmBamlError::Io { diff --git a/baml_language/crates/sys_ops/src/lib.rs b/baml_language/crates/sys_ops/src/lib.rs index d45cb8ef695..c2f73c2ea0a 100644 --- a/baml_language/crates/sys_ops/src/lib.rs +++ b/baml_language/crates/sys_ops/src/lib.rs @@ -871,28 +871,6 @@ impl io::IoClassReflectSession for DefaultIoOps { impl io::IoNamespaceReflect for DefaultIoOps {} impl io::IoClassFsFile for DefaultIoOps { - fn text( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } - fn bytes( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput> { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } fn read( &self, _h: &Arc, @@ -900,19 +878,7 @@ impl io::IoClassFsFile for DefaultIoOps { _f: io::owned::fs::File, _n: i64, _ctx: &SysOpContext, - ) -> SysOpOutput { - SysOpOutput::err(VmBamlError::Unsupported { - message: "Operation not supported on this platform".to_string(), - }) - } - fn read_bytes( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _n: i64, - _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) @@ -946,21 +912,20 @@ impl io::IoClassFsFile for DefaultIoOps { _h: &Arc, _c: CallId, _f: io::owned::fs::File, - _data: String, + _data: Vec, _ctx: &SysOpContext, ) -> SysOpOutput { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) } - fn write_bytes( + fn flush( &self, _h: &Arc, _c: CallId, _f: io::owned::fs::File, - _data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) @@ -2112,28 +2077,10 @@ impl IoSysOpsBuilder { t.__glue_baml_fs_write_bytes(heap, permit, args, ctx, call_id) }) }; - self.inner.baml_fs_file_text = { - let t = instance.clone(); - Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_text(heap, permit, args, ctx, call_id) - }) - }; - self.inner.baml_fs_file_bytes = { - let t = instance.clone(); - Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_bytes(heap, permit, args, ctx, call_id) - }) - }; - self.inner.baml_fs_file_read = { - let t = instance.clone(); - Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_read(heap, permit, args, ctx, call_id) - }) - }; - self.inner.baml_fs_file_read_bytes = { + self.inner.baml_fs_file_root_io_read_read = { let t = instance.clone(); Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_read_bytes(heap, permit, args, ctx, call_id) + t.__glue_baml_fs_file_root_io_read_read(heap, permit, args, ctx, call_id) }) }; self.inner.baml_fs_file_close = { @@ -2148,16 +2095,16 @@ impl IoSysOpsBuilder { t.__glue_baml_fs_file_seek_from(heap, permit, args, ctx, call_id) }) }; - self.inner.baml_fs_file_write = { + self.inner.baml_fs_file_root_io_write_write = { let t = instance.clone(); Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_write(heap, permit, args, ctx, call_id) + t.__glue_baml_fs_file_root_io_write_write(heap, permit, args, ctx, call_id) }) }; - self.inner.baml_fs_file_write_bytes = { + self.inner.baml_fs_file_root_io_write_flush = { let t = instance.clone(); Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_fs_file_write_bytes(heap, permit, args, ctx, call_id) + t.__glue_baml_fs_file_root_io_write_flush(heap, permit, args, ctx, call_id) }) }; self.inner.baml_fs_read_dir = { diff --git a/baml_language/crates/sys_wasm/src/web_sysops.rs b/baml_language/crates/sys_wasm/src/web_sysops.rs index 343e0120493..3395cfef868 100644 --- a/baml_language/crates/sys_wasm/src/web_sysops.rs +++ b/baml_language/crates/sys_wasm/src/web_sysops.rs @@ -292,24 +292,6 @@ impl WebFs { } impl io::IoClassFsFile for WebFs { - fn text( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput { - unsupported() - } - fn bytes( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _ctx: &SysOpContext, - ) -> SysOpOutput> { - unsupported() - } fn read( &self, _h: &Arc, @@ -317,17 +299,7 @@ impl io::IoClassFsFile for WebFs { _f: io::owned::fs::File, _n: i64, _ctx: &SysOpContext, - ) -> SysOpOutput { - unsupported() - } - fn read_bytes( - &self, - _h: &Arc, - _c: CallId, - _f: io::owned::fs::File, - _n: i64, - _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { unsupported() } fn close( @@ -355,19 +327,18 @@ impl io::IoClassFsFile for WebFs { _h: &Arc, _c: CallId, _f: io::owned::fs::File, - _data: String, + _data: Vec, _ctx: &SysOpContext, ) -> SysOpOutput { unsupported() } - fn write_bytes( + fn flush( &self, _h: &Arc, _c: CallId, _f: io::owned::fs::File, - _data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput<()> { unsupported() } } diff --git a/baml_language/sdk_tests/crates/csharp/phase12_resources/Program.cs b/baml_language/sdk_tests/crates/csharp/phase12_resources/Program.cs index f75f132ea89..a30a3d9b2cd 100644 --- a/baml_language/sdk_tests/crates/csharp/phase12_resources/Program.cs +++ b/baml_language/sdk_tests/crates/csharp/phase12_resources/Program.cs @@ -24,10 +24,14 @@ using Baml.Fs.File reader = Baml.Fs.Functions.Open(tempPath, "r"); // Load-bearing parity assertion: separate managed-to-native calls must // operate on the same native File object and advance one shared cursor. - Require(reader.Read(3) == "012", "first native File.read changed"); - Require(await reader.ReadAsync(3) == "345", "native File cursor did not persist across calls"); + // The cursor is observed through seek_from rather than read: `read` comes + // from `baml.io.Read`, and interface methods are off the bridge surface. + Require(reader.SeekFrom("current", 3) == 3, "first native File.seek_from changed"); + Require( + await reader.SeekFromAsync("current", 3) == 6, + "native File cursor did not persist across calls"); Require(reader.SeekFrom("start", 0) == 0, "native File.seek_from did not rewind"); - Require(reader.Read(2) == "01", "native File.read after seek changed"); + Require(reader.SeekFrom("current", 2) == 2, "native File.seek_from after rewind changed"); Require(reader.Text() == "23456789", "native File.text ignored the current cursor"); _ = reader.Close(); @@ -38,18 +42,16 @@ "baml.fs.write_bytes returned the wrong byte count"); using (Baml.Fs.File binary = await Baml.Fs.Functions.OpenAsync(binaryPath, "r+")) { - Require( - binary.ReadBytes(2).Span.SequenceEqual(new byte[] { 0, 1 }), - "File.read_bytes changed"); - Require(binary.Write("AZ") == 2, "File.write changed"); - Require(binary.SeekFrom("start", 0) == 0, "binary File.seek_from changed"); + Require(binary.SeekFrom("start", 2) == 2, "binary File.seek_from changed"); + Require(binary.Write("AZ") == 2, "File.write over text changed"); + Require(binary.SeekFrom("start", 0) == 0, "binary File.seek_from did not rewind"); Require( (await binary.BytesAsync()).Span.SequenceEqual(new byte[] { 0, 1, (byte)'A', (byte)'Z' }), "File.bytes did not preserve raw data and cursor state"); Require(binary.SeekFrom("end", 0) == 4, "binary File end seek changed"); Require( - await binary.WriteBytesAsync(new byte[] { 5, 6 }) == 2, - "File.write_bytes changed"); + await binary.WriteAsync(new ReadOnlyMemory(new byte[] { 5, 6 })) == 2, + "File.write over raw bytes changed"); _ = await binary.CloseAsync(); } diff --git a/baml_language/sdk_tests/crates/java/type_shapes/customizable/roundtrip_tests/TestHandles.java b/baml_language/sdk_tests/crates/java/type_shapes/customizable/roundtrip_tests/TestHandles.java index cd5b803623b..6b3e92680f3 100644 --- a/baml_language/sdk_tests/crates/java/type_shapes/customizable/roundtrip_tests/TestHandles.java +++ b/baml_language/sdk_tests/crates/java/type_shapes/customizable/roundtrip_tests/TestHandles.java @@ -115,16 +115,18 @@ void test_handles_file_cursor_state_persists_across_calls() throws IOException { try { f = Fns.open(path.toString(), "r"); - // Two successive reads on the *same* handle must advance the - // cursor — the second read continues where the first stopped. + // Two successive relative seeks on the *same* handle must + // accumulate — the second continues where the first stopped. // This is the load-bearing assertion: engine-side file state - // survives across separate host->engine FFI calls. - assertEquals("012", f.read(3L)); - assertEquals("345", f.read(3L)); + // survives across separate host->engine FFI calls. (`read` + // reaches the cursor too, but it comes from `baml.io.Read`, and + // interface methods are not on the bridge surface.) + assertEquals(3L, f.seek_from("current", 3L)); + assertEquals(6L, f.seek_from("current", 3L)); // Seek back to the start and confirm the cursor actually moved. assertEquals(0L, f.seek_from("start", 0L)); - assertEquals("01", f.read(2L)); + assertEquals(2L, f.seek_from("current", 2L)); // text() reads from the current cursor (now at 2) to EOF. assertEquals("23456789", f.text()); diff --git a/baml_language/sdk_tests/crates/python_pydantic2/type_shapes/customizable/roundtrip_tests/test_handles.py b/baml_language/sdk_tests/crates/python_pydantic2/type_shapes/customizable/roundtrip_tests/test_handles.py index 473e42d9af2..984d1f16579 100644 --- a/baml_language/sdk_tests/crates/python_pydantic2/type_shapes/customizable/roundtrip_tests/test_handles.py +++ b/baml_language/sdk_tests/crates/python_pydantic2/type_shapes/customizable/roundtrip_tests/test_handles.py @@ -97,16 +97,17 @@ def test_handles_open_file_returns_file_handle(temp_file): def test_handles_file_cursor_state_persists_across_calls(temp_file): f = baml_open(temp_file, "r") - # Two successive reads on the *same* handle must advance the cursor — - # the second read continues where the first stopped. This is the - # load-bearing assertion: engine-side file state survives across - # separate host→engine FFI calls. - assert f.read(3) == "012" - assert f.read(3) == "345" + # Two successive relative seeks on the *same* handle must accumulate — + # the second continues where the first stopped. This is the load-bearing + # assertion: engine-side file state survives across separate host→engine + # FFI calls. (`read` reaches the cursor too, but it comes from + # `baml.io.Read`, and interface methods are not on the bridge surface.) + assert f.seek_from("current", 3) == 3 + assert f.seek_from("current", 3) == 6 # Seek back to the start and confirm the cursor actually moved. assert f.seek_from("start", 0) == 0 - assert f.read(2) == "01" + assert f.seek_from("current", 2) == 2 # text() reads from the current cursor (now at 2) to EOF. assert f.text() == "23456789" diff --git a/baml_language/sdk_tests/crates/rust/type_shapes/customizable/roundtrip_tests/test_handles.rs b/baml_language/sdk_tests/crates/rust/type_shapes/customizable/roundtrip_tests/test_handles.rs index ce32406a9c8..d450a9aa274 100644 --- a/baml_language/sdk_tests/crates/rust/type_shapes/customizable/roundtrip_tests/test_handles.rs +++ b/baml_language/sdk_tests/crates/rust/type_shapes/customizable/roundtrip_tests/test_handles.rs @@ -103,16 +103,17 @@ fn test_handles_file_cursor_state_persists_across_calls() { let temp_file = temp_file(); let f = baml_open(temp_file.to_str().unwrap().to_string(), "r".to_string()).unwrap(); - // Two successive reads on the *same* handle must advance the cursor — - // the second read continues where the first stopped. This is the - // load-bearing assertion: engine-side file state survives across - // separate host→engine FFI calls. - assert_eq!(f.read(3).unwrap(), "012"); - assert_eq!(f.read(3).unwrap(), "345"); + // Two successive relative seeks on the *same* handle must accumulate — + // the second continues where the first stopped. This is the load-bearing + // assertion: engine-side file state survives across separate host→engine + // FFI calls. (`read` reaches the cursor too, but it comes from + // `baml.io.Read`, and interface methods are not on the bridge surface.) + assert_eq!(f.seek_from("current".to_string(), 3).unwrap(), 3); + assert_eq!(f.seek_from("current".to_string(), 3).unwrap(), 6); // Seek back to the start and confirm the cursor actually moved. assert_eq!(f.seek_from("start".to_string(), 0).unwrap(), 0); - assert_eq!(f.read(2).unwrap(), "01"); + assert_eq!(f.seek_from("current".to_string(), 2).unwrap(), 2); // text() reads from the current cursor (now at 2) to EOF. assert_eq!(f.text().unwrap(), "23456789"); diff --git a/baml_language/sdk_tests/crates/typescript/type_shapes/customizable/roundtrip_handles.test.ts b/baml_language/sdk_tests/crates/typescript/type_shapes/customizable/roundtrip_handles.test.ts index cc3d8b8aa97..2d573cd7f99 100644 --- a/baml_language/sdk_tests/crates/typescript/type_shapes/customizable/roundtrip_handles.test.ts +++ b/baml_language/sdk_tests/crates/typescript/type_shapes/customizable/roundtrip_handles.test.ts @@ -95,10 +95,15 @@ describe.runIf(isTestRuntime("node"))( it("handles_file_cursor_state_persists_across_calls", () => { const f = baml.fs.open(filePath, "r"); - expect(f.read(3)).toBe("012"); - expect(f.read(3)).toBe("345"); + // Two successive relative seeks on the *same* handle must accumulate — + // the second continues where the first stopped. This is the load-bearing + // assertion: engine-side file state survives across separate host→engine + // FFI calls. (`read` reaches the cursor too, but it comes from + // `baml.io.Read`, and interface methods are not on the bridge surface.) + expect(f.seek_from("current", 3)).toBe(3); + expect(f.seek_from("current", 3)).toBe(6); expect(f.seek_from("start", 0)).toBe(0); - expect(f.read(2)).toBe("01"); + expect(f.seek_from("current", 2)).toBe(2); expect(f.text()).toBe("23456789"); expect(f.close()).toBeNull(); }); diff --git a/baml_language/sdk_tests/harness_setup/src/csharp.rs b/baml_language/sdk_tests/harness_setup/src/csharp.rs index bc9f31341a3..af8464f2f3b 100644 --- a/baml_language/sdk_tests/harness_setup/src/csharp.rs +++ b/baml_language/sdk_tests/harness_setup/src/csharp.rs @@ -260,7 +260,6 @@ fn verify_phase12_surface(fixture: &std::path::Path) { for expected in [ "public sealed partial class File : global::System.IDisposable", - "public string Read(", "public long SeekFrom(\n string whence,", "public string Text(", "public File Clone() => new(\n resource.Clone());", @@ -285,6 +284,23 @@ fn verify_phase12_surface(fixture: &std::path::Path) { assert!(!file.contains("public global::Baml.BamlHandle Handle")); assert!(!file.contains("private readonly global::Baml.BamlHandle")); + // `File` reaches `read` / `flush` only through `baml.io.Read` / `baml.io.Write`, + // and interface-block methods are excluded from the bridge surface, so neither + // is projected at all. The one `Write` that survives is the class's own + // `write(string | uint8array)`; a second one would mean the interface method + // was projected under the same name. + for absent in [" Read(", " ReadAsync(", " Flush(", " FlushAsync("] { + assert!( + !file.contains(absent), + "generated File resource surface exposed interface-block member `{absent}`" + ); + } + assert_eq!( + file.matches(" Write(").count(), + 1, + "expected exactly one File.Write (the class method, not baml.io.Write's)" + ); + let resource_surfaces = [ ( "Fs/File.g.cs", @@ -293,18 +309,12 @@ fn verify_phase12_surface(fixture: &std::path::Path) { " TextAsync(", " Bytes(", " BytesAsync(", - " Read(", - " ReadAsync(", - " ReadBytes(", - " ReadBytesAsync(", " Close(", " CloseAsync(", " SeekFrom(", " SeekFromAsync(", " Write(", " WriteAsync(", - " WriteBytes(", - " WriteBytesAsync(", ], ), ( @@ -358,17 +368,10 @@ fn verify_phase12_surface(fixture: &std::path::Path) { vec![" AllowTls12 { get; }", " New(", " NewAsync("], ), ( + // `read` / `write` / `flush` live in `implements` blocks, so they are + // excluded from the bridge surface — only `connect` and `close` remain. "Net/TcpStream.g.cs", - vec![ - " Connect(", - " ConnectAsync(", - " Read(", - " ReadAsync(", - " Write(", - " WriteAsync(", - " Close(", - " CloseAsync(", - ], + vec![" Connect(", " ConnectAsync(", " Close(", " CloseAsync("], ), ( "Net/TcpListener.g.cs", From 23d306ba873f100393f5c130dd042bf35fca5414 Mon Sep 17 00:00:00 2001 From: 2kai2kai2 Date: Thu, 13 Aug 2026 14:16:55 -0700 Subject: [PATCH 3/5] `Read` and `Write` for `TcpStream` --- .../baml_std/baml/ns_io/write.baml | 8 + .../baml_std/baml/ns_net/net.baml | 59 +- ...tests__render_builtin_package_listing.snap | 6 +- .../test_files/syntax/hover/builtin_net.baml | 4 +- .../syntax/hover/builtin_net_close.baml | 4 +- .../syntax/hover/builtin_net_socket.baml | 4 +- .../baml_tests/baml_src/ns_net/net.baml | 20 +- .../diagnostic_errors/builtin_io/net_ops.baml | 27 +- .../baml_tests/snapshots/baml_src/net.snap | 20 +- ...ests__compiles____baml_std____03_ppir.snap | 14 +- ...sts__compiles____baml_std____04_5_mir.snap | 109 +- ...tests__compiles____baml_std____04_tir.snap | 19 +- ...s__compiles____baml_std____06_codegen.snap | 71 +- ...iagnostic_errors__builtin_io__03_ppir.snap | 21 +- ...diagnostic_errors__builtin_io__04_tir.snap | 233 + ...rs__builtin_io__10_formatter__net_ops.snap | 27 +- ...__phase5__snapshot_baml_package_items.snap | 2 +- ...ode_format__bytecode_display_expanded.snap | 12777 +++++++++++++++ ...bytecode_display_expanded_unoptimized.snap | 13149 ++++++++++++++++ baml_language/crates/baml_tests/tests/net.rs | 122 +- .../crates/sys_native/src/io_impls.rs | 98 +- baml_language/crates/sys_ops/src/lib.rs | 19 +- 22 files changed, 26515 insertions(+), 298 deletions(-) create mode 100644 baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__04_tir.snap create mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap create mode 100644 baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml index 75e21cb0692..34f16e6b451 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml @@ -6,4 +6,12 @@ interface Write { /// Flush any buffered data to the destination. function flush(self) -> void throws root.errors.Io + + /// Keep writing data until all bytes have been written. + function write_all(self, data: uint8array) -> void throws root.errors.Io { + while (data.length() > 0) { + let written = self.write(data); + data = data.slice(written, data.length()); + } + } } diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_net/net.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_net/net.baml index 3f6426619d9..a8cf2d182f5 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_net/net.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_net/net.baml @@ -35,45 +35,26 @@ class TcpStream { $rust_io_function } - /// Reads the next available bytes from the stream. Blocks until data arrives. - /// Returns an empty `uint8array` once the peer has closed the connection (EOF). - /// - /// `timeout` bounds the wait for data; `null` (the default) blocks - /// indefinitely. On expiry this throws `root.errors.Timeout` and the stream - /// remains usable for a subsequent read. - function read( - self, - timeout: root.time.Duration? = null, - ) -> uint8array throws root.errors.Io | root.errors.Timeout { - self._read(_timeout_nanos(timeout)) - } - - function _read( - self, - timeout_nanos: bigint, - ) -> uint8array throws root.errors.Io | root.errors.Timeout { - $rust_io_function - } - - /// Writes `data` to the stream. Blocks until every byte has been flushed. - /// - /// `timeout` bounds the flush; `null` (the default) blocks indefinitely. On - /// expiry this throws `root.errors.Timeout`; an unknown amount of `data` may - /// already have been written. - function write( - self, - data: uint8array, - timeout: root.time.Duration? = null, - ) -> null throws root.errors.Io | root.errors.Timeout { - self._write(data, _timeout_nanos(timeout)) - } - - function _write( - self, - data: uint8array, - timeout_nanos: bigint, - ) -> null throws root.errors.Io | root.errors.Timeout { - $rust_io_function + implements root.io.Read { + /// Reads the next available bytes from the stream. Blocks until data arrives. + /// Returns `null` once the stream has been closed and no more data is available (EOF). + function read(self, n: int) -> uint8array? throws root.errors.Io { + $rust_io_function + } + } + + implements root.io.Write { + /// Writes `data` to the stream. + /// + /// If cancelled (e.g. by a timeout), an unknown amount of `data` may + /// already have been written. + function write(self, data: uint8array) -> int throws root.errors.Io { + $rust_io_function + } + + /// No-op, TCP streams don't need to be flushed. + function flush(self) -> void throws never { + } } /// Closes the connection. diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index 9fb4fd7c406..a440ea71001 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -205,9 +205,9 @@ class baml.media.Video /baml/ns_media/media. class baml.media.Image /baml/ns_media/media.baml:134 function baml.net._timeout_nanos /baml/ns_net/net.baml:5 class baml.net.TcpStream /baml/ns_net/net.baml:14 -class baml.net.TcpListener /baml/ns_net/net.baml:88 -class baml.net.UdpSocket /baml/ns_net/net.baml:110 -class baml.net.Datagram /baml/ns_net/net.baml:168 +class baml.net.TcpListener /baml/ns_net/net.baml:69 +class baml.net.UdpSocket /baml/ns_net/net.baml:91 +class baml.net.Datagram /baml/ns_net/net.baml:149 interface baml.ops.BitAnd /baml/ns_ops/bitwise.baml:28 interface baml.ops.BitOr /baml/ns_ops/bitwise.baml:34 interface baml.ops.BitXor /baml/ns_ops/bitwise.baml:40 diff --git a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net.baml b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net.baml index fdb59b20078..f95d0711774 100644 --- a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net.baml +++ b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net.baml @@ -1,8 +1,8 @@ // Test hover on network builtins -function TestNetConnect() -> uint8array { +function TestNetConnect() -> uint8array? { let s = baml.net<[CURSOR].TcpStream.connect("127.0.0.1:8080"); - s.read() + s.read(4096) } //---- diff --git a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_close.baml b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_close.baml index 893dcaca7ff..f9493114f1c 100644 --- a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_close.baml +++ b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_close.baml @@ -1,8 +1,8 @@ // Test hover on TcpStream.close method -function TestSocketClose() -> uint8array { +function TestSocketClose() -> uint8array? { let s = baml.net.TcpStream.connect("127.0.0.1:8080"); - let data = s.read(); + let data = s.read(4096); s.close<[CURSOR](); data } diff --git a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_socket.baml b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_socket.baml index e13ff28940a..60b6e6eddf8 100644 --- a/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_socket.baml +++ b/baml_language/crates/baml_lsp2_actions_tests/test_files/syntax/hover/builtin_net_socket.baml @@ -1,8 +1,8 @@ // Test hover on TcpStream type and methods -function TestSocketRead() -> uint8array { +function TestSocketRead() -> uint8array? { let s<[CURSOR] = baml.net.TcpStream.connect("127.0.0.1:8080"); - s.read() + s.read(4096) } //---- diff --git a/baml_language/crates/baml_tests/baml_src/ns_net/net.baml b/baml_language/crates/baml_tests/baml_src/ns_net/net.baml index f420038815e..16360ae5f27 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_net/net.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_net/net.baml @@ -11,22 +11,26 @@ // be bootstrapped. // // Error classes (crates/sys_native/src/io_impls.rs): -// read / recv_from deadline expiry -> baml.errors.Timeout +// recv_from deadline expiry -> baml.errors.Timeout // op on a closed stream / listener / socket -> baml.errors.Io // -// The TCP read-timeout test lives in Rust (tests/net.rs), not here: its silent -// peer needs a controlled listener that stays alive across the throwing read, -// which a GC-managed BAML `baml.http.Server` cannot guarantee under load. +// `TcpStream` reads have no deadline parameter: they are bounded by the native +// cancellation system (`spawn ... with baml.spawn.options(cancel = tok)`), which +// surfaces as `baml.panics.Cancelled`. Those tests live in Rust (tests/net.rs), +// where the silent peer is a controlled listener that stays alive across the +// cancelled read — a GC-managed BAML `baml.http.Server` cannot guarantee that +// under load. // ─── close() invalidates the shared handle ──────────────────────────────────── // Connect succeeds, then close() invalidates the shared handle so a subsequent // read() on the same socket fails deterministically ("TcpStream is closed"). -function net_tcp_read_after_close_errors_fn() -> uint8array { +// A closed handle is distinct from end-of-stream, which reads as `null`. +function net_tcp_read_after_close_errors_fn() -> uint8array? { let server = baml.http.Server.bind("127.0.0.1:0"); let sock = baml.net.TcpStream.connect(server.addr); sock.close(); - sock.read() + sock.read(4096) } test "net_tcp_read_after_close_errors" { @@ -38,11 +42,11 @@ test "net_tcp_read_after_close_errors" { } } -function net_tcp_listener_accept_after_close_errors_fn() -> uint8array { +function net_tcp_listener_accept_after_close_errors_fn() -> uint8array? { let listener = baml.net.TcpListener.bind("127.0.0.1:0"); listener.close(); let sock = listener.accept(); - sock.read() + sock.read(4096) } test "net_tcp_listener_accept_after_close_errors" { diff --git a/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/net_ops.baml b/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/net_ops.baml index 85983071ca0..4b589992b8d 100644 --- a/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/net_ops.baml +++ b/baml_language/crates/baml_tests/projects/diagnostic_errors/builtin_io/net_ops.baml @@ -1,33 +1,40 @@ // Test network operations typecheck correctly -function ConnectAndRead() -> uint8array { +function ConnectAndRead() -> uint8array? { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); - sock.read() + sock.read(4096) } -function ConnectAndReadInline() -> uint8array { - baml.net.TcpStream.connect("localhost:3000").read() +function ConnectAndReadInline() -> uint8array? { + baml.net.TcpStream.connect("localhost:3000").read(4096) } function MultipleConnections() -> uint8array { let s1 = baml.net.TcpStream.connect("server1:80"); let s2 = baml.net.TcpStream.connect("server2:80"); - let data1 = s1.read(); - let data2 = s2.read(); + let data1 = s1.read(4096) ?? b""; + let data2 = s2.read(4096) ?? b""; data1.concat(data2) } -function ConnectReadAndClose() -> uint8array { +function ConnectReadAndClose() -> uint8array? { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); - let data = sock.read(); + let data = sock.read(4096); sock.close(); data } -function ListenAndAccept() -> uint8array { +function ConnectAndWrite() -> int { + let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); + let n = sock.write("ping".to_utf8()); + sock.flush(); + n +} + +function ListenAndAccept() -> uint8array? { let listener = baml.net.TcpListener.bind("127.0.0.1:0"); let sock = listener.accept(); - sock.read() + sock.read(4096) } function UdpRoundtrip() -> uint8array { diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/net.snap b/baml_language/crates/baml_tests/snapshots/baml_src/net.snap index 904072b45de..bdd3108932b 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/net.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/net.snap @@ -34,7 +34,7 @@ function net.$init_test_ns_net_net(registry: testing.TestCollector) -> null { return } -function net.net_tcp_listener_accept_after_close_errors_fn() -> uint8array { +function net.net_tcp_listener_accept_after_close_errors_fn() -> uint8array | null { load_const "127.0.0.1:0" sys_op baml.net.TcpListener.bind store_var listener @@ -43,12 +43,16 @@ function net.net_tcp_listener_accept_after_close_errors_fn() -> uint8array { pop 1 load_var listener sys_op baml.net.TcpListener.accept - load_const - call baml.net.TcpStream.read + load_const 4096 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _0 + load_var _0 return } -function net.net_tcp_read_after_close_errors_fn() -> uint8array { +function net.net_tcp_read_after_close_errors_fn() -> uint8array | null { load_const "127.0.0.1:0" sys_op baml.http.Server.bind load_field .addr @@ -59,8 +63,12 @@ function net.net_tcp_read_after_close_errors_fn() -> uint8array { sys_op baml.net.TcpStream.close pop 1 load_var sock - load_const - call baml.net.TcpStream.read + load_const 4096 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _0 + load_var _0 return } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap index 105a605ba21..41c77222996 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap @@ -1018,6 +1018,9 @@ function baml.io.read_to_string(self: ?) -> string [expr] { --- /baml/ns_io/write.baml --- function baml.io.flush(self: ?) -> void [missing] function baml.io.write(self: ?, data: uint8array) -> int [missing] +function baml.io.write_all(self: ?, data: uint8array) -> void [expr] { + { while data.length() Gt 0 { let written = self.write(data); data = data.slice(written, data.length()) } } +} --- /baml/ns_iter/iter.baml --- class baml.iter.ArrayIterator { @@ -1406,13 +1409,11 @@ class baml.net.UdpSocket$stream { _handle: $rust_type } function baml.net._connect(addr: string, timeout_nanos: bigint) -> baml.net.TcpStream [builtin] -function baml.net._read(self: ?, timeout_nanos: bigint) -> uint8array [builtin] function baml.net._recv_from(self: ?, timeout_nanos: bigint) -> baml.net.Datagram [builtin] function baml.net._send_to(self: ?, data: uint8array, addr: string, timeout_nanos: bigint) -> int [builtin] function baml.net._timeout_nanos(timeout: root.time.Duration?) -> bigint [expr] { { } match (timeout) { null => 0n, t: root.time.Duration => t.to_nanoseconds() } } -function baml.net._write(self: ?, data: uint8array, timeout_nanos: bigint) -> null [builtin] function baml.net.accept(self: ?) -> baml.net.TcpStream [builtin] function baml.net.bind(addr: string) -> baml.net.TcpListener [builtin] function baml.net.bind(addr: string) -> baml.net.UdpSocket [builtin] @@ -1422,18 +1423,17 @@ function baml.net.close(self: ?) -> null [builtin] function baml.net.connect(addr: string, timeout: root.time.Duration? = null) -> baml.net.TcpStream [expr] { { } TcpStream._connect(addr, _timeout_nanos(timeout)) } -function baml.net.read(self: ?, timeout: root.time.Duration? = null) -> uint8array [expr] { - { } self._read(_timeout_nanos(timeout)) +function baml.net.flush(self: ?) -> void [expr] { + { } } +function baml.net.read(self: ?, n: int) -> uint8array? [builtin] function baml.net.recv_from(self: ?, timeout: root.time.Duration? = null) -> baml.net.Datagram [expr] { { } self._recv_from(_timeout_nanos(timeout)) } function baml.net.send_to(self: ?, data: uint8array, addr: string, timeout: root.time.Duration? = null) -> int [expr] { { } self._send_to(data, addr, _timeout_nanos(timeout)) } -function baml.net.write(self: ?, data: uint8array, timeout: root.time.Duration? = null) -> null [expr] { - { } self._write(data, _timeout_nanos(timeout)) -} +function baml.net.write(self: ?, data: uint8array) -> int [builtin] --- /baml/ns_ops/bitwise.baml --- function baml.ops.bit_and(self: ?, rhs: Rhs) -> Self.Output [missing] diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index 4c7f49c7d64..781b5130202 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -4317,6 +4317,55 @@ fn baml.io.Write.flush(_1: void) -> void { } } +fn baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void { + // Locals: + let _0: void // _0 // return + let _1: baml.io.Write // self // param + let _2: uint8array // data // param + let _3: bool + let _4: int + let _5: int // written + let _6: int + let _7: int + + bb0: { + goto -> bb1; + } + + bb1: { + _4 = len(_2); + goto -> bb2; + } + + bb2: { + _3 = copy _4 > const 0_i64; + branch copy _3 -> [bb5, bb3]; + } + + bb3: { + _0 = const null; + goto -> bb4; + } + + bb4: { + return; + } + + bb5: { + _5 = virtual_call write as baml.io.Write(copy _1, copy _2) -> [bb6]; + } + + bb6: { + _6 = copy _5; + _7 = len(_2); + goto -> bb7; + } + + bb7: { + _2 = call const fn baml.Uint8Array.slice(copy _2, copy _6, copy _7) -> [bb1]; + } +} + fn baml.iter.Iterable.iter(_1: void) -> void { // Locals: let _0: void // return @@ -6717,73 +6766,25 @@ fn baml.net.TcpStream.connect(addr: string, timeout: null | baml.time.Duration) fn baml.net.TcpStream._connect = builtin(io) -fn baml.net.TcpStream.read(self: baml.net.TcpStream, timeout: null | baml.time.Duration) -> uint8array { - // Locals: - let _0: uint8array // _0 // return - let _1: baml.net.TcpStream // self // param - let _2: null | baml.time.Duration // timeout // param - let _3: bool - let _4: bigint - - bb0: { - _3 = copy _2 == const ; - branch copy _3 -> [bb1, bb2]; - } - - bb1: { - _2 = const null; - goto -> bb2; - } +fn baml.net.TcpStream.root.io.Read.read = builtin(io) - bb2: { - _4 = call const fn baml.net._timeout_nanos(copy _2) -> [bb3]; - } - - bb3: { - _0 = sys_op const fn baml.net.TcpStream._read(copy _1, copy _4) -> bb4; - } - - bb4: { - return; - } -} +fn baml.net.TcpStream.root.io.Write.write = builtin(io) -fn baml.net.TcpStream._read = builtin(io) - -fn baml.net.TcpStream.write(self: baml.net.TcpStream, data: uint8array, timeout: null | baml.time.Duration) -> null { +fn baml.net.TcpStream.root.io.Write.flush(self: baml.net.TcpStream) -> void { // Locals: - let _0: null // _0 // return + let _0: void // _0 // return let _1: baml.net.TcpStream // self // param - let _2: uint8array // data // param - let _3: null | baml.time.Duration // timeout // param - let _4: bool - let _5: bigint bb0: { - _4 = copy _3 == const ; - branch copy _4 -> [bb1, bb2]; + _0 = const null; + goto -> bb1; } bb1: { - _3 = const null; - goto -> bb2; - } - - bb2: { - _5 = call const fn baml.net._timeout_nanos(copy _3) -> [bb3]; - } - - bb3: { - _0 = sys_op const fn baml.net.TcpStream._write(copy _1, copy _2, copy _5) -> bb4; - } - - bb4: { return; } } -fn baml.net.TcpStream._write = builtin(io) - fn baml.net.TcpStream.close = builtin(io) fn baml.net.TcpListener.bind = builtin(io) diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap index fc6f631b0d3..5dd3c4543ca 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap @@ -1172,6 +1172,15 @@ function baml.io.Read.read_to_string(self: baml.io.Read) -> string throws baml.e } --- /baml/ns_io/write.baml --- +function baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void throws baml.errors.Io { + { : void + while data.length() > 0 + { : void + let written = self.write(data) : int + data = data.slice(written, data.length()) : uint8array + } + } +} --- /baml/ns_iter/iter.baml --- class baml.iter.Done { @@ -1995,14 +2004,8 @@ function baml.net.TcpStream.connect(addr: string, timeout: baml.time.Duration | TcpStream._connect(addr, _timeout_nanos(timeout)) : baml.net.TcpStream } } -function baml.net.TcpStream.read(self: baml.net.TcpStream, timeout: baml.time.Duration | null = null) -> uint8array throws baml.errors.Io | baml.errors.Timeout { - { : uint8array - self._read(_timeout_nanos(timeout)) : uint8array - } -} -function baml.net.TcpStream.write(self: baml.net.TcpStream, data: uint8array, timeout: baml.time.Duration | null = null) -> null throws baml.errors.Io | baml.errors.Timeout { - { : null - self._write(data, _timeout_nanos(timeout)) : null +function baml.net.TcpStream.flush(self: baml.net.TcpStream) -> void throws never { + { : void } } class baml.net.TcpListener { diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index 83e7028ef99..f6e0372f7d7 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -2906,6 +2906,37 @@ function baml.io.Read.read_to_string(self: baml.io.Read) -> string { return } +function baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void { + L0: + load_var data + container_len + store_var _4 + load_var _4 + load_const 0 + cmp_int_op > + pop_jump_if_false L1 + jump L2 + + L1: + load_const null + return + + L2: + load_var2 1 2 + load_type baml.io.Write + load_const "write" + virtual_call nargs=2 ntypeargs=0 + store_var written + load_var data + container_len + store_var _7 + load_var2 2 4 + load_var _7 + call baml.Uint8Array.slice + store_var data + jump L0 +} + function baml.io.eprint(s: string) -> null { } @@ -4600,12 +4631,6 @@ function baml.net.TcpListener.close(self: baml.net.TcpListener) -> null { function baml.net.TcpStream._connect(addr: string, timeout_nanos: bigint) -> baml.net.TcpStream { } -function baml.net.TcpStream._read(self: baml.net.TcpStream, timeout_nanos: bigint) -> uint8array { -} - -function baml.net.TcpStream._write(self: baml.net.TcpStream, data: uint8array, timeout_nanos: bigint) -> null { -} - function baml.net.TcpStream.close(self: baml.net.TcpStream) -> null { } @@ -4626,41 +4651,17 @@ function baml.net.TcpStream.connect(addr: string, timeout: baml.time.Duration | return } -function baml.net.TcpStream.read(self: baml.net.TcpStream, timeout: baml.time.Duration | null) -> uint8array { - load_var timeout - load_const - cmp_op == - pop_jump_if_false L0 - load_const null - store_var timeout - - L0: - load_var timeout - call baml.net._timeout_nanos - store_var _4 - load_var2 1 3 - sys_op baml.net.TcpStream._read - return +function baml.net.TcpStream.root.io.Read.read(self: baml.net.TcpStream, n: int) -> uint8array | null { } -function baml.net.TcpStream.write(self: baml.net.TcpStream, data: uint8array, timeout: baml.time.Duration | null) -> null { - load_var timeout - load_const - cmp_op == - pop_jump_if_false L0 +function baml.net.TcpStream.root.io.Write.flush(self: baml.net.TcpStream) -> void { load_const null - store_var timeout - - L0: - load_var timeout - call baml.net._timeout_nanos - store_var _5 - load_var2 1 2 - load_var _5 - sys_op baml.net.TcpStream._write return } +function baml.net.TcpStream.root.io.Write.write(self: baml.net.TcpStream, data: uint8array) -> int { +} + function baml.net.UdpSocket._recv_from(self: baml.net.UdpSocket, timeout_nanos: bigint) -> baml.net.Datagram { } diff --git a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap index bf7e2a10d97..e1dd80cdafb 100644 --- a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__03_ppir.snap @@ -68,20 +68,23 @@ function user.AskName() -> string [expr] { function user.AskNoPrompt() -> string [expr] { { } baml.io.input(null) } -function user.ConnectAndRead() -> uint8array [expr] { - { let sock = baml.net.TcpStream.connect("127.0.0.1:8080") } sock.read() +function user.ConnectAndRead() -> uint8array? [expr] { + { let sock = baml.net.TcpStream.connect("127.0.0.1:8080") } sock.read(4096) } -function user.ConnectAndReadInline() -> uint8array [expr] { - { } baml.net.TcpStream.connect("localhost:3000").read() +function user.ConnectAndReadInline() -> uint8array? [expr] { + { } baml.net.TcpStream.connect("localhost:3000").read(4096) } -function user.ConnectReadAndClose() -> uint8array [expr] { - { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); let data = sock.read(); sock.close() } data +function user.ConnectAndWrite() -> int [expr] { + { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); let n = sock.write("ping".to_utf8()); sock.flush() } n } -function user.ListenAndAccept() -> uint8array [expr] { - { let listener = baml.net.TcpListener.bind("127.0.0.1:0"); let sock = listener.accept() } sock.read() +function user.ConnectReadAndClose() -> uint8array? [expr] { + { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); let data = sock.read(4096); sock.close() } data +} +function user.ListenAndAccept() -> uint8array? [expr] { + { let listener = baml.net.TcpListener.bind("127.0.0.1:0"); let sock = listener.accept() } sock.read(4096) } function user.MultipleConnections() -> uint8array [expr] { - { let s1 = baml.net.TcpStream.connect("server1:80"); let s2 = baml.net.TcpStream.connect("server2:80"); let data1 = s1.read(); let data2 = s2.read() } data1.concat(data2) + { let s1 = baml.net.TcpStream.connect("server1:80"); let s2 = baml.net.TcpStream.connect("server2:80"); let data1 = s1.read(4096) NullCoalesce b"<0 bytes>"; let data2 = s2.read(4096) NullCoalesce b"<0 bytes>" } data1.concat(data2) } function user.UdpRoundtrip() -> uint8array [expr] { { let sock = baml.net.UdpSocket.bind("0.0.0.0:0"); sock.send_to("ping".to_utf8(), "127.0.0.1:9"); let dgram = sock.recv_from() } dgram.data diff --git a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__04_tir.snap b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__04_tir.snap new file mode 100644 index 00000000000..620468a064a --- /dev/null +++ b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__04_tir.snap @@ -0,0 +1,233 @@ +--- +source: crates/baml_tests/src/generated_tests.rs +--- +=== TIR2 === +function user.ReadFile() -> string throws never { + { : string + let f = baml.fs.open("example.txt", "r") : baml.fs.File + f.text() : string + } +} +function user.ReadFileInline() -> string throws never { + { : string + baml.fs.open("data.json", "r").text() : string + } +} +function user.ReadMultipleFiles() -> string throws never { + { : string + let f1 = baml.fs.open("file1.txt", "r") : baml.fs.File + let f2 = baml.fs.open("file2.txt", "r") : baml.fs.File + let content1 = f1.text() : string + let content2 = f2.text() : string + content1 + content2 : string + } +} +function user.ReadAndClose() -> string throws never { + { : string + let f = baml.fs.open("example.txt", "r") : baml.fs.File + let content = f.text() : string + f.close() : null + content : string + } +} +function user.ReadFileBytes() -> uint8array throws never { + { : uint8array + let f = baml.fs.open("binary.dat", "r") : baml.fs.File + f.bytes() : uint8array + } +} +function user.ReadFileBytesInline() -> uint8array throws never { + { : uint8array + baml.fs.open("image.png", "r").bytes() : uint8array + } +} +function user.ReadFileBytesAndClose() -> uint8array throws never { + { : uint8array + let f = baml.fs.open("binary.dat", "r") : baml.fs.File + let data = f.bytes() : uint8array + f.close() : null + data : uint8array + } +} +function user.ReadChunk() -> uint8array | null throws never { + { : uint8array | null + let f = baml.fs.open("log.txt", "r") : baml.fs.File + f.read(512) : uint8array | null + } +} +function user.ReadChunkOrEmpty() -> uint8array throws never { + { : uint8array + let f = baml.fs.open("data.bin", "r") : baml.fs.File + f.read(4096) ?? b"<0 bytes>" : uint8array + } +} +function user.WriteFile() -> int throws never { + { : int + baml.fs.write("output.txt", "hello") : int + } +} +function user.WriteFileBytes() -> int throws never { + { : int + let data = baml.fs.open("source.bin", "r").bytes() : uint8array + baml.fs.write_bytes("output.bin", data) : int + } +} +function user.SeekAndRead() -> string throws never { + { : string + let f = baml.fs.open("data.txt", "r+") : baml.fs.File + f.seek_from("start", 10) : int + f.text() : string + } +} +function user.FileWrite() -> int throws never { + { : int + let f = baml.fs.open("data.txt", "r+") : baml.fs.File + f.write("hello".to_utf8()) : int + } +} +function user.FileWriteBytes() -> int throws never { + { : int + let f = baml.fs.open("data.bin", "r+") : baml.fs.File + let data = f.bytes() : uint8array + f.seek_from("start", 0) : int + f.write(data) : int + } +} +function user.Append() -> int throws never { + { : int + let f = baml.fs.open("log.txt", "a") : baml.fs.File + f.write("line\n".to_utf8()) : int + } +} +function user.AppendAndRead() -> string throws never { + { : string + let f = baml.fs.open("log.txt", "a+") : baml.fs.File + f.write("line\n".to_utf8()) : int + f.seek_from("start", 0) : int + f.text() : string + } +} +function user.Exists() -> bool throws never { + { : bool + baml.fs.exists("maybe.txt") : bool + } +} +function user.Remove() -> null throws never { + { : null + baml.fs.remove("stale.txt") : null + } +} +function user.Size() -> int throws never { + { : int + baml.fs.size("data.bin") : int + } +} +function user.ReadDir() -> baml.fs.DirEntry[] throws never { + { : baml.fs.DirEntry[] + baml.fs.read_dir("some/path") : baml.fs.DirEntry[] + } +} +function user.AskName() -> string throws never { + { : string + baml.io.input("What is your name? ") : string + } +} +function user.AskNoPrompt() -> string throws never { + { : string + baml.io.input(null) : string + } +} +function user.ConnectAndRead() -> uint8array | null throws never { + { : uint8array | null + let sock = baml.net.TcpStream.connect("127.0.0.1:8080") : baml.net.TcpStream + sock.read(4096) : uint8array | null + } +} +function user.ConnectAndReadInline() -> uint8array | null throws never { + { : uint8array | null + baml.net.TcpStream.connect("localhost:3000").read(4096) : uint8array | null + } +} +function user.MultipleConnections() -> uint8array throws never { + { : uint8array + let s1 = baml.net.TcpStream.connect("server1:80") : baml.net.TcpStream + let s2 = baml.net.TcpStream.connect("server2:80") : baml.net.TcpStream + let data1 = s1.read(4096) ?? b"<0 bytes>" : uint8array + let data2 = s2.read(4096) ?? b"<0 bytes>" : uint8array + data1.concat(data2) : uint8array + } +} +function user.ConnectReadAndClose() -> uint8array | null throws never { + { : uint8array | null + let sock = baml.net.TcpStream.connect("127.0.0.1:8080") : baml.net.TcpStream + let data = sock.read(4096) : uint8array | null + sock.close() : null + data : uint8array | null + } +} +function user.ConnectAndWrite() -> int throws never { + { : int + let sock = baml.net.TcpStream.connect("127.0.0.1:8080") : baml.net.TcpStream + let n = sock.write("ping".to_utf8()) : int + sock.flush() : void + n : int + } +} +function user.ListenAndAccept() -> uint8array | null throws never { + { : uint8array | null + let listener = baml.net.TcpListener.bind("127.0.0.1:0") : baml.net.TcpListener + let sock = listener.accept() : baml.net.TcpStream + sock.read(4096) : uint8array | null + } +} +function user.UdpRoundtrip() -> uint8array throws never { + { : uint8array + let sock = baml.net.UdpSocket.bind("0.0.0.0:0") : baml.net.UdpSocket + sock.send_to("ping".to_utf8(), "127.0.0.1:9") : int + let dgram = sock.recv_from() : baml.net.Datagram + dgram.data : uint8array + } +} +function user.RunCommand() -> string throws never { + { : uint8array + baml.sys.shell("echo hello", null).stdout : uint8array + } + !! 84..125: type mismatch: expected string, got uint8array +} +function user.RunCommandWithVar() -> string throws never { + { : uint8array + let cmd = "ls -la" : "ls -la" -> string + baml.sys.shell(cmd, null).stdout : uint8array + } + !! 198..230: type mismatch: expected string, got uint8array +} +function user.ChainCommands() -> string throws never { + { : unknown + let result1 = baml.sys.shell("pwd", null) : baml.sys.ShellOutput + let result2 = baml.sys.shell("whoami", null) : baml.sys.ShellOutput + result1.stdout + " - " + result2.stdout : unknown + } + !! 372..394: operator `+` cannot be applied to `uint8array` and `" - "` +} +function user.CheckExitCode() -> int throws never { + { : int + baml.sys.shell("exit 42", null).exit_code : int + } +} +function user.CheckOk() -> bool throws never { + { : bool + baml.sys.shell("echo test", null).ok() : bool + } +} +function user.ExecCommand() -> string throws never { + { : uint8array + baml.sys.exec("echo", ["hello"], null).stdout : uint8array + } + !! 612..657: type mismatch: expected string, got uint8array +} +function user.ExecWithOptions() -> string throws never { + { : uint8array + baml.sys.exec("pwd", null, baml.sys.ProcessOptions { cwd: "/tmp" }).stdout : uint8array + } + !! 704..778: type mismatch: expected string, got uint8array +} diff --git a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__net_ops.snap b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__net_ops.snap index a4f06424863..650f04e7c9d 100644 --- a/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__net_ops.snap +++ b/baml_language/crates/baml_tests/snapshots/diagnostic_errors/builtin_io/baml_tests__diagnostic_errors__builtin_io__10_formatter__net_ops.snap @@ -3,34 +3,41 @@ source: crates/baml_tests/src/generated_tests.rs --- // Test network operations typecheck correctly -function ConnectAndRead() -> uint8array { +function ConnectAndRead() -> uint8array? { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); - sock.read() + sock.read(4096) } -function ConnectAndReadInline() -> uint8array { - baml.net.TcpStream.connect("localhost:3000").read() +function ConnectAndReadInline() -> uint8array? { + baml.net.TcpStream.connect("localhost:3000").read(4096) } function MultipleConnections() -> uint8array { let s1 = baml.net.TcpStream.connect("server1:80"); let s2 = baml.net.TcpStream.connect("server2:80"); - let data1 = s1.read(); - let data2 = s2.read(); + let data1 = s1.read(4096) ?? b""; + let data2 = s2.read(4096) ?? b""; data1.concat(data2) } -function ConnectReadAndClose() -> uint8array { +function ConnectReadAndClose() -> uint8array? { let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); - let data = sock.read(); + let data = sock.read(4096); sock.close(); data } -function ListenAndAccept() -> uint8array { +function ConnectAndWrite() -> int { + let sock = baml.net.TcpStream.connect("127.0.0.1:8080"); + let n = sock.write("ping".to_utf8()); + sock.flush(); + n +} + +function ListenAndAccept() -> uint8array? { let listener = baml.net.TcpListener.bind("127.0.0.1:0"); let sock = listener.accept(); - sock.read() + sock.read(4096) } function UdpRoundtrip() -> uint8array { diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index 6e03a4a9e43..53980302ec9 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -222,7 +222,7 @@ namespace baml.media: namespace baml.net: class Datagram { methods: [] } class TcpListener { methods: [bind, accept, close] } - class TcpStream { methods: [connect, _connect, read, _read, write, _write, close] } + class TcpStream { methods: [connect, _connect, close, read, write, flush] } class UdpSocket { methods: [bind, send_to, _send_to, recv_from, _recv_from, close] } function _timeout_nanos namespace baml.ops: diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap new file mode 100644 index 00000000000..19522a6b941 --- /dev/null +++ b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap @@ -0,0 +1,12777 @@ +--- +source: crates/baml_tests/tests/bytecode_format/main.rs +--- +function ai.Agent.Runner.run(self: ai.Agent<#0>, spec: ai.FunctionSpec<#0>) -> ai.RunResult<#0> { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + 6 load_var 5 + 7 make_cell + 8 store_var 5 + 9 load_var 20 + 10 make_cell + 11 store_var 20 + + 198 12 load_deref 1 + 13 load_field 1 (client) + 14 store_var 4 (_4) + 15 load_var 4 (_4) + 16 store_var 3 (selected) + 17 load_var 4 (_4) + 18 load_const 0 (null) + 19 cmp_op == + 20 pop_jump_if_false +4 (to 24) + 21 load_deref 2 + 22 load_field 4 (default_client) + 23 store_var 3 (selected) + + 199 24 load_type 1 + 25 load_deref 2 + 26 call 784 ntypeargs=1 (ai.Journal.new) + 27 store_deref 5 + + 200 28 load_type 1 + 29 load_deref 1 + 30 load_deref 5 + 31 load_const 2 (0) + 32 call 823 ntypeargs=1 (ai.Agent._emit_from) + 33 store_var 6 (seen) + + 201 34 load_const 2 (0) + 35 store_var 7 (steps) + + 202 36 load_const 2 (0) + 37 load_const 2 (0) + 38 load_const 0 (null) + 39 load_const 0 (null) + 40 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 41 store_var 8 (total) + + 209 42 load_type 3 + 43 load_type 4 + 44 alloc_map 0 + 45 store_var 9 (fail_counts) + + 210 46 load_var 7 (steps) + 47 load_deref 1 + 48 load_field 0 (max_steps) + 49 cmp_int_op < + 50 pop_jump_if_false +2 (to 52) + 51 jump +4 (to 55) + + 269 52 load_var 7 (steps) + 53 init_instance 1 (ai.errors.StepBudgetExceeded .steps) + 54 throw + + 212 55 load_type 1 + 56 load_deref 1 + 57 load_var 3 (selected) + 58 load_deref 2 + 59 load_deref 5 + 60 load_var 8 (total) + 61 load_const 5 (2) + 62 call 822 ntypeargs=1 (ai.Agent._attempt_turn) + 63 store_var 10 (turn) + + 213 64 load_var 7 (steps) + 65 load_const 6 (1) + 66 add_int + 67 store_var 7 (steps) + + 214 68 load_type 1 + 69 load_deref 1 + 70 load_deref 5 + 71 load_var 6 (seen) + 72 call 823 ntypeargs=1 (ai.Agent._emit_from) + 73 store_var 6 (seen) + + 215 74 load_var 10 (turn) + 75 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 76 store_var 11 (calls) + + 216 77 load_var 11 (calls) + 78 container_len + 79 store_var 12 (_28) + 80 load_var 12 (_28) + 81 load_const 2 (0) + 82 cmp_int_op > + 83 pop_jump_if_false +2 (to 85) + 84 jump +63 (to 147) + + 251 85 load_var 10 (turn) + 86 call 802 ntypeargs=0 (ai.ModelTurn.terminal_text) + 87 store_var 34 (_96) + 88 load_var 34 (_96) + 89 store_var 33 (candidate) + 90 load_var 34 (_96) + 91 load_const 0 (null) + 92 cmp_op == + 93 pop_jump_if_false +3 (to 96) + 94 load_const 7 ("") + 95 store_var 33 (candidate) + + 252 96 load_type 1 + 97 load_var 33 (candidate) + 98 call 428 ntypeargs=1 (baml.sap.parse) + 99 store_var 35 (value) + 100 jump +11 (to 111) + 101 load_var 36 (e) + 102 throw_if_panic + + 254 103 load_var 3 (selected) + 104 load_type 8 + 105 load_const 9 ("id") + 106 virtual_call nargs=1 ntypeargs=0 + 107 store_var 37 (_103) + 108 load_var2 37 33 + 109 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) + 110 throw + + 257 111 load_type 1 + 112 load_var 35 (value) + 113 call 333 ntypeargs=1 (baml.json.to_json) + 114 jump +12 (to 126) + 115 load_var 38 (e) + 116 throw_if_panic + + 259 117 load_type 10 + 118 load_var 38 (e) + 119 call 138 ntypeargs=1 (baml.String.from) + 120 store_var 39 (_112) + 121 load_var2 38 39 + 122 load_type 3 + 123 alloc_array 1 + 124 init_instance 3 (baml.errors.UnknownError .data, .message) + 125 throw + + 263 126 call 330 ntypeargs=0 (baml.json.stringify) + 127 store_var 40 (_117) + + 262 128 load_deref 5 + + 263 129 load_var 40 (_117) + 130 init_instance 4 (ai.events.FinalProduced .value_json) + 131 load_type 11 + 132 alloc_array 1 + 133 call 785 ntypeargs=0 (ai.Journal.append_all) + 134 pop 1 + + 265 135 load_type 1 + 136 load_deref 1 + 137 load_deref 5 + 138 load_var 6 (seen) + 139 call 823 ntypeargs=1 (ai.Agent._emit_from) + 140 store_var 6 (seen) + + 266 141 load_var 35 (value) + 142 load_deref 5 + 143 load_var 8 (total) + 144 load_type 1 + 145 init_instance 5 (ai.RunResult .value, .journal, .usage) + 146 return + + 217 147 load_deref 5 + 148 call 783 ntypeargs=0 (ai.Journal.entries) + 149 container_len + 150 store_var 13 (before) + + 219 151 load_type 12 + 152 load_type 13 + 153 load_type 14 + 154 load_var 11 (calls) + 155 load_type 1 + 156 load_var2 1 2 + 157 load_var 5 (j) + 158 make_closure 1713 captures=3 ntypeargs=1 + 159 call 16 ntypeargs=3 (baml.Array.map) + 160 store_var 14 (futures) + + 222 161 load_type 15 + 162 load_type 16 + 163 load_var 14 (futures) + 164 call 485 ntypeargs=2 (baml.future.all) + 165 await + 166 pop 1 + + 223 167 load_type 1 + 168 load_deref 1 + 169 load_deref 5 + 170 load_var 6 (seen) + 171 call 823 ntypeargs=1 (ai.Agent._emit_from) + 172 store_var 6 (seen) + + 227 173 load_deref 5 + 174 call 783 ntypeargs=0 (ai.Journal.entries) + 175 store_var 15 (entries) + + 228 176 load_var 13 (before) + 177 store_var 16 (i) + + 229 178 load_var 16 (i) + 179 store_var 17 (_47) + 180 load_var 15 (entries) + 181 container_len + 182 store_var 18 (_48) + 183 load_var2 17 18 + 184 cmp_int_op < + 185 pop_jump_if_false -139 (to 46) + + 230 186 load_type 11 + 187 load_var2 15 16 + 188 call 3 ntypeargs=1 (baml.Array.at) + 189 store_var 19 (_52) + 190 load_var 19 (_52) + 191 narrow_bind 17 19 + 192 pop_jump_if_false +60 (to 252) + 193 load_var 19 (_52) + 194 store_deref 20 + + 231 195 load_type 12 + 196 load_type 14 + 197 load_var 11 (calls) + 198 load_type 1 + 199 load_var 20 (f) + 200 make_closure 1714 captures=1 ntypeargs=1 + 201 call 19 ntypeargs=2 (baml.Array.find) + + 234 202 store_var 21 (_58) + 203 load_var 21 (_58) + 204 narrow_bind 18 21 + 205 pop_jump_if_false +47 (to 252) + 206 load_var 21 (_58) + 207 store_var 22 (known) + + 235 208 load_type 3 + 209 load_var 22 (known) + 210 load_field 1 (name) + 211 call 138 ntypeargs=1 (baml.String.from) + 212 store_var 24 (_62) + 213 load_type 3 + 214 load_deref 20 + 215 load_field 1 (message) + 216 call 138 ntypeargs=1 (baml.String.from) + 217 store_var 25 (_65) + 218 load_var 24 (_62) + 219 load_const 19 ("|") + 220 bin_op + + 221 load_var 25 (_65) + 222 bin_op + + 223 store_var 23 (key) + + 236 224 load_type 3 + 225 load_type 4 + 226 load_var2 9 23 + 227 call 38 ntypeargs=2 (baml.Map.get) + 228 store_var 28 (_70) + 229 load_var 28 (_70) + 230 store_var 27 (_69) + 231 load_var 28 (_70) + 232 load_const 0 (null) + 233 cmp_op == + 234 pop_jump_if_false +3 (to 237) + 235 load_const 2 (0) + 236 store_var 27 (_69) + 237 load_var 27 (_69) + 238 load_const 6 (1) + 239 add_int + 240 store_var 26 (n) + + 237 241 load_type 3 + 242 load_type 4 + 243 load_var2 9 23 + 244 load_var 26 (n) + 245 call 37 ntypeargs=2 (baml.Map.set) + 246 pop 1 + + 238 247 load_var 26 (n) + 248 load_const 20 (3) + 249 cmp_int_op >= + 250 pop_jump_if_false +2 (to 252) + 251 jump +6 (to 257) + + 248 252 load_var 16 (i) + 253 load_const 6 (1) + 254 add_int + 255 store_var 16 (i) + + 229 256 jump -78 (to 178) + + 240 257 load_var 22 (known) + 258 load_field 0 (id) + 259 store_var 29 (_83) + + 241 260 load_var 22 (known) + 261 load_field 1 (name) + 262 store_var 30 (_84) + + 242 263 load_type 4 + 264 load_var 26 (n) + 265 call 138 ntypeargs=1 (baml.String.from) + 266 store_var 31 (_88) + 267 load_type 3 + 268 load_deref 20 + 269 load_field 1 (message) + 270 call 138 ntypeargs=1 (baml.String.from) + 271 store_var 32 (_91) + + 239 272 load_var2 29 30 + + 242 273 load_const 21 ("the same tool call failed ") + 274 load_var 31 (_88) + 275 bin_op + + 276 load_const 22 (" times; stopping the run: ") + 277 bin_op + + 278 load_var 32 (_91) + 279 bin_op + + 280 load_const 0 (null) + 281 init_instance 6 (ai.errors.ToolFailedError .id, .name, .message, .cause) + 282 throw +} + +function ai.Agent._attempt_turn(self: ai.Agent<#0>, c: ai.Client, spec: ai.FunctionSpec<#0>, j: ai.Journal, total: ai.events.Usage, attempts_left: int) -> ai.ModelTurn { + 124 0 load_var 3 (spec) + 1 load_field 2 (prompt_template) + 2 store_var 8 (_9) + + 126 3 load_type 0 + 4 load_var 3 (spec) + 5 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 6 store_var 9 (_10) + + 127 7 load_type 0 + 8 load_var 3 (spec) + 9 call 792 ntypeargs=1 (ai.FunctionSpec.output_type) + 10 store_var 10 (_12) + + 122 11 load_var2 2 8 + + 123 12 load_var2 4 9 + 13 load_var 10 (_12) + 14 init_instance 0 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) + 15 load_type 1 + 16 load_const 2 ("invoke") + 17 virtual_call nargs=2 ntypeargs=0 + 18 store_var 7 (turn) + + 130 19 load_var 7 (turn) + 20 load_field 2 (usage) + 21 store_var 11 (_15) + 22 load_var 11 (_15) + 23 narrow_bind 3 11 + 24 pop_jump_if_false +63 (to 87) + 25 load_var 11 (_15) + 26 store_var 12 (u) + + 131 27 load_var 5 (total) + 28 copy 0 + 29 load_field 0 (input_tokens) + 30 load_var 12 (u) + 31 load_field 0 (input_tokens) + 32 bin_op + + 33 store_field 0 (input_tokens) + + 132 34 load_var 5 (total) + 35 copy 0 + 36 load_field 1 (output_tokens) + 37 load_var 12 (u) + 38 load_field 1 (output_tokens) + 39 bin_op + + 40 store_field 1 (output_tokens) + + 133 41 load_var 12 (u) + 42 load_field 2 (cached_input_tokens) + 43 store_var 13 (_20) + 44 load_var 13 (_20) + 45 narrow_bind 4 13 + 46 pop_jump_if_false +18 (to 64) + 47 load_var 13 (_20) + 48 store_var 14 (ci) + + 134 49 load_var 5 (total) + 50 load_field 2 (cached_input_tokens) + 51 store_var 16 (_23) + 52 load_var 16 (_23) + 53 store_var 15 (_22) + 54 load_var 16 (_23) + 55 load_const 5 (null) + 56 cmp_op == + 57 pop_jump_if_false +3 (to 60) + 58 load_const 4 (0) + 59 store_var 15 (_22) + 60 load_var2 5 15 + 61 load_var 14 (ci) + 62 bin_op + + 63 store_field 2 (cached_input_tokens) + + 136 64 load_var 12 (u) + 65 load_field 3 (reasoning_tokens) + 66 store_var 17 (_27) + 67 load_var 17 (_27) + 68 narrow_bind 4 17 + 69 pop_jump_if_false +18 (to 87) + 70 load_var 17 (_27) + 71 store_var 18 (rt) + + 137 72 load_var 5 (total) + 73 load_field 3 (reasoning_tokens) + 74 store_var 20 (_30) + 75 load_var 20 (_30) + 76 store_var 19 (_29) + 77 load_var 20 (_30) + 78 load_const 5 (null) + 79 cmp_op == + 80 pop_jump_if_false +3 (to 83) + 81 load_const 4 (0) + 82 store_var 19 (_29) + 83 load_var2 5 19 + 84 load_var 18 (rt) + 85 bin_op + + 86 store_field 3 (reasoning_tokens) + + 141 87 load_var 7 (turn) + 88 load_field 0 (content) + 89 store_var 22 (_35) + 90 load_var 2 (c) + 91 load_type 1 + 92 load_const 6 ("id") + 93 virtual_call nargs=1 ntypeargs=0 + 94 store_var 23 (_36) + 95 load_var2 22 23 + 96 init_instance 1 (ai.events.AssistantMessage .content, .client_id) + 97 load_type 7 + 98 alloc_array 1 + 99 store_var 21 (batch) + + 142 100 load_var 7 (turn) + 101 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 102 load_type 8 + 103 load_const 9 ("iter") + 104 virtual_call nargs=1 ntypeargs=0 + 105 store_var 24 (_38) + 106 load_var 24 (_38) + 107 load_type 10 + 108 load_const 11 ("next") + 109 virtual_call nargs=1 ntypeargs=0 + 110 store_var 25 (_39) + 111 load_var 25 (_39) + 112 is_type 12 + 113 pop_jump_if_false +2 (to 115) + 114 jump +13 (to 127) + 115 load_var 25 (_39) + 116 store_var 26 (u) + + 143 117 load_var2 21 26 + 118 load_field 0 (id) + 119 load_var 26 (u) + 120 load_field 1 (name) + 121 load_var 26 (u) + 122 load_field 2 (args) + 123 init_instance 2 (ai.events.ToolRequested .id, .name, .args) + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + 126 jump -20 (to 106) + + 145 127 load_var 7 (turn) + 128 load_field 2 (usage) + 129 store_var 27 (_49) + 130 load_var 27 (_49) + 131 narrow_bind 3 27 + 132 pop_jump_if_false +4 (to 136) + + 146 133 load_var2 21 27 + + 145 134 call 4 ntypeargs=0 (baml.Array.push) + 135 pop 1 + + 148 136 load_var 7 (turn) + 137 call 802 ntypeargs=0 (ai.ModelTurn.terminal_text) + 138 store_var 29 (_54) + 139 load_var 29 (_54) + 140 store_var 28 (candidate) + 141 load_var 29 (_54) + 142 load_const 5 (null) + 143 cmp_op == + 144 pop_jump_if_false +3 (to 147) + 145 load_const 13 ("") + 146 store_var 28 (candidate) + + 149 147 load_var 7 (turn) + 148 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 149 container_len + 150 store_var 30 (_60) + 151 load_var 30 (_60) + 152 load_const 4 (0) + 153 cmp_int_op > + 154 jump_if_false +2 (to 156) + 155 jump +7 (to 162) + 156 pop 1 + + 150 157 load_var 7 (turn) + 158 load_field 1 (stop_reason) + 159 load_const 14 (ai.content.StopReason.MaxTokens) + 160 alloc_variant 436 (ai.content.StopReason) + 161 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 149 162 jump_if_false +2 (to 164) + 163 jump +7 (to 170) + 164 pop 1 + + 151 165 load_var 7 (turn) + 166 load_field 1 (stop_reason) + 167 load_const 15 (ai.content.StopReason.Refused) + 168 alloc_variant 436 (ai.content.StopReason) + 169 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 149 170 jump_if_false +2 (to 172) + 171 jump +5 (to 176) + 172 pop 1 + + 152 173 load_type 0 + 174 load_var2 1 28 + 175 call 821 ntypeargs=1 (ai.Agent._parses) + + 153 176 pop_jump_if_false +2 (to 178) + 177 jump +33 (to 210) + + 166 178 load_var 6 (attempts_left) + 179 load_const 16 (1) + 180 cmp_int_op > + 181 pop_jump_if_false +2 (to 183) + 182 jump +12 (to 194) + + 175 183 load_var2 4 21 + 184 call 785 ntypeargs=0 (ai.Journal.append_all) + 185 pop 1 + + 176 186 load_var 2 (c) + 187 load_type 1 + 188 load_const 17 ("id") + 189 virtual_call nargs=1 ntypeargs=0 + 190 store_var 33 (_86) + 191 load_var2 33 28 + 192 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) + 193 throw + + 167 194 load_var 21 (batch) + + 168 195 load_const 18 ("The reply did not match the required schema. Answer again with only the corrected value.") + 196 init_instance 4 (ai.events.UserMessage .content) + 197 call 4 ntypeargs=0 (baml.Array.push) + 198 pop 1 + + 172 199 load_var2 4 21 + 200 call 785 ntypeargs=0 (ai.Journal.append_all) + 201 pop 1 + + 173 202 load_type 0 + 203 load_var2 1 2 + 204 load_var2 3 4 + 205 load_var2 5 6 + 206 load_const 16 (1) + 207 sub_int + 208 call 822 ntypeargs=1 (ai.Agent._attempt_turn) + 209 jump +19 (to 228) + + 154 210 load_var2 4 21 + 211 call 785 ntypeargs=0 (ai.Journal.append_all) + 212 pop 1 + + 156 213 load_var 7 (turn) + 214 load_field 1 (stop_reason) + 215 discriminant + 216 load_const 14 (StopReason.MaxTokens) + 217 cmp_int_op == + 218 pop_jump_if_false +2 (to 220) + 219 jump +20 (to 239) + 220 load_var 7 (turn) + 221 load_field 1 (stop_reason) + 222 discriminant + 223 load_const 15 (StopReason.Refused) + 224 cmp_int_op == + 225 pop_jump_if_false +2 (to 227) + 226 jump +3 (to 229) + + 165 227 load_var 7 (turn) + 228 return + + 161 229 load_var 2 (c) + 230 load_type 1 + 231 load_const 19 ("id") + 232 virtual_call nargs=1 ntypeargs=0 + 233 store_var 32 (_75) + 234 load_var 32 (_75) + 235 load_const 20 ("the model declined to answer") + 236 load_const 5 (null) + 237 init_instance 5 (ai.errors.Refused .provider, .reason, .raw_body) + 238 throw + + 158 239 load_var 2 (c) + 240 load_type 1 + 241 load_const 21 ("id") + 242 virtual_call nargs=1 ntypeargs=0 + 243 store_var 31 (_72) + 244 load_var2 31 28 + 245 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) + 246 throw +} + +function ai.Agent._emit_from(self: ai.Agent<#0>, j: ai.Journal, seen: int) -> int { + 182 0 load_var 2 (j) + 1 call 783 ntypeargs=0 (ai.Journal.entries) + 2 store_var 4 (entries) + + 183 3 load_var 3 (seen) + 4 store_var 5 (i) + + 184 5 load_var 5 (i) + 6 store_var 6 (_7) + 7 load_var 4 (entries) + 8 container_len + 9 store_var 7 (_8) + 10 load_var2 6 7 + 11 cmp_int_op < + 12 pop_jump_if_false +2 (to 14) + 13 jump +4 (to 17) + + 190 14 load_var 4 (entries) + 15 container_len + 16 return + + 185 17 load_type 0 + 18 load_var2 4 5 + 19 call 3 ntypeargs=1 (baml.Array.at) + 20 store_var 8 (_12) + 21 load_var 8 (_12) + 22 narrow_bind 1 8 + 23 pop_jump_if_false +2 (to 25) + 24 jump +28 (to 52) + 25 load_var 8 (_12) + 26 narrow_bind 2 8 + 27 pop_jump_if_false +2 (to 29) + 28 jump +24 (to 52) + 29 load_var 8 (_12) + 30 narrow_bind 3 8 + 31 pop_jump_if_false +2 (to 33) + 32 jump +20 (to 52) + 33 load_var 8 (_12) + 34 narrow_bind 4 8 + 35 pop_jump_if_false +2 (to 37) + 36 jump +16 (to 52) + 37 load_var 8 (_12) + 38 narrow_bind 5 8 + 39 pop_jump_if_false +2 (to 41) + 40 jump +12 (to 52) + 41 load_var 8 (_12) + 42 narrow_bind 6 8 + 43 pop_jump_if_false +2 (to 45) + 44 jump +8 (to 52) + 45 load_var 8 (_12) + 46 narrow_bind 7 8 + 47 pop_jump_if_false +2 (to 49) + 48 jump +4 (to 52) + 49 load_var 8 (_12) + 50 narrow_bind 8 8 + 51 pop_jump_if_false +5 (to 56) + 52 load_var2 8 1 + + 186 53 load_field 3 (on_event) + 54 call_indirect + 55 pop 1 + + 188 56 load_var 5 (i) + 57 load_const 9 (1) + 58 add_int + 59 store_var 5 (i) + + 184 60 jump -55 (to 5) +} + +function ai.Agent._parses(self: ai.Agent<#0>, candidate: string) -> bool { + 100 0 load_type 0 + 1 load_var 2 (candidate) + 2 call 428 ntypeargs=1 (baml.sap.parse) + 3 pop 1 + 4 jump +5 (to 9) + 5 load_var 3 (e) + 6 throw_if_panic + + 102 7 load_const 1 (false) + 8 jump +2 (to 10) + + 105 9 load_const 2 (true) + 10 return +} + +function ai.Agent._run_one_tool(self: ai.Agent<#0>, tb: ai.tools.Toolbox, call: ai.content.ToolUse, j: ai.Journal) -> null { + 56 0 load_var2 2 3 + 1 load_field 1 (name) + 2 call 800 ntypeargs=0 (ai.tools.Toolbox.get) + 3 store_var 5 (_7) + 4 load_var 5 (_7) + 5 narrow_bind 0 5 + 6 pop_jump_if_false +2 (to 8) + 7 jump +20 (to 27) + + 89 8 load_var 3 (call) + 9 load_field 0 (id) + 10 store_var 19 (_41) + + 90 11 load_type 1 + 12 load_var 3 (call) + 13 load_field 1 (name) + 14 call 138 ntypeargs=1 (baml.String.from) + 15 store_var 20 (_43) + + 86 16 load_var2 4 19 + + 90 17 load_const 2 ("tool is not in the active toolbox: ") + 18 load_var 20 (_43) + 19 bin_op + + 20 init_instance 0 (ai.events.ToolFailed .id, .message) + 21 load_type 3 + 22 alloc_array 1 + 23 call 785 ntypeargs=0 (ai.Journal.append_all) + 24 pop 1 + + 94 25 load_const 4 (null) + + 56 26 jump +84 (to 110) + 27 load_var 5 (_7) + 28 store_var 6 (t) + + 58 29 load_var2 6 3 + 30 load_field 2 (args) + 31 call 795 ntypeargs=0 (ai.tools.Tool.call) + 32 store_var 7 (outcome) + 33 jump +63 (to 96) + 34 load_var 8 (e) + 35 throw_if_panic + + 61 36 load_var 3 (call) + 37 load_field 0 (id) + 38 store_var 9 (_15) + 39 load_type 5 + 40 load_var 8 (e) + 41 call 138 ntypeargs=1 (baml.String.from) + 42 store_var 10 (_16) + + 60 43 load_var2 4 9 + + 61 44 load_var 10 (_16) + 45 init_instance 1 (ai.events.ToolFailed .id, .message) + 46 load_type 3 + 47 alloc_array 1 + 48 call 785 ntypeargs=0 (ai.Journal.append_all) + 49 pop 1 + + 64 50 load_var 6 (t) + 51 load_field 5 (on_error) + 52 store_var 12 (_20) + 53 load_var 12 (_20) + 54 store_var 11 (_19) + 55 load_var 12 (_20) + 56 load_const 4 (null) + 57 cmp_op == + 58 pop_jump_if_false +4 (to 62) + 59 load_var 1 (self) + 60 load_field 2 (tool_errors) + 61 store_var 11 (_19) + 62 load_var 11 (_19) + 63 load_const 6 (ai.tools.ErrorMode.Raise) + 64 alloc_variant 437 (ai.tools.ErrorMode) + 65 call 635 ntypeargs=0 (baml.ops.equals_equals) + 66 pop_jump_if_false +2 (to 68) + 67 jump +4 (to 71) + + 76 68 load_const 4 (null) + 69 store_var 7 (outcome) + + 64 70 jump +26 (to 96) + + 65 71 load_var 8 (e) + 72 store_var 14 (_23) + 73 load_var 14 (_23) + 74 narrow_bind 7 14 + 75 pop_jump_if_false +2 (to 77) + 76 jump +4 (to 80) + + 67 77 load_const 4 (null) + 78 store_var 13 (classified) + + 65 79 jump +3 (to 82) + 80 load_var 14 (_23) + 81 store_var 13 (classified) + + 70 82 load_var 3 (call) + 83 load_field 0 (id) + 84 store_var 15 (_26) + + 71 85 load_var 3 (call) + 86 load_field 1 (name) + 87 store_var 16 (_27) + + 72 88 load_type 5 + 89 load_var 8 (e) + 90 call 138 ntypeargs=1 (baml.String.from) + 91 store_var 17 (_28) + + 69 92 load_var2 15 16 + 93 load_var2 17 13 + + 73 94 init_instance 2 (ai.errors.ToolFailedError .id, .name, .message, .cause) + 95 throw + + 80 96 load_var 7 (outcome) + 97 store_var 18 (_31) + 98 load_var 18 (_31) + 99 narrow_bind 6 18 + 100 pop_jump_if_false +9 (to 109) + + 81 101 load_var2 4 3 + 102 load_field 0 (id) + + 80 103 load_var 18 (_31) + 104 init_instance 3 (ai.events.ToolCompleted .id, .output) + 105 load_type 3 + 106 alloc_array 1 + 107 call 785 ntypeargs=0 (ai.Journal.append_all) + 108 pop 1 + + 83 109 load_const 4 (null) + 110 return +} + +function ai.Agent.new(max_steps: int, client: ai.Client | null, tool_errors: ai.tools.ErrorMode, on_event: ((ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced) -> null throws never) | null) -> ai.Agent<#0> { + 0 load_var 1 (max_steps) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 30 4 load_const 1 (12) + 5 store_var 1 (max_steps) + 6 load_var 2 (client) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 31 10 load_const 2 (null) + 11 store_var 2 (client) + 12 load_var 3 (tool_errors) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +4 (to 19) + + 32 16 load_const 3 (ai.tools.ErrorMode.Report) + 17 alloc_variant 437 (ai.tools.ErrorMode) + 18 store_var 3 (tool_errors) + 19 load_var 4 (on_event) + 20 load_const 0 () + 21 cmp_op == + 22 pop_jump_if_false +3 (to 25) + + 33 23 load_const 2 (null) + 24 store_var 4 (on_event) + + 39 25 load_var 4 (on_event) + 26 store_var 5 (_9) + 27 load_var 4 (on_event) + 28 load_const 2 (null) + 29 cmp_op == + 30 pop_jump_if_false +4 (to 34) + + 41 31 load_type 4 + 32 make_closure 1695 captures=0 ntypeargs=1 + 33 store_var 5 (_9) + + 35 34 load_var2 1 2 + 35 load_var2 3 5 + 36 load_type 4 + 37 init_instance 0 (ai.Agent .max_steps, .client, .tool_errors, .on_event) + 38 return +} + +function ai.FunctionSpec.arguments(self: ai.FunctionSpec<#0>) -> map { + 73 0 load_var 1 (self) + 1 load_field 1 (args) + 2 return +} + +function ai.FunctionSpec.name(self: ai.FunctionSpec<#0>) -> string { + 69 0 load_var 1 (self) + 1 load_field 0 (spec_name) + 2 return +} + +function ai.FunctionSpec.output_type(self: ai.FunctionSpec<#0>) -> type { + 77 0 load_type 0 + 1 return +} + +function ai.FunctionSpec.prompt(self: ai.FunctionSpec<#0>, output_format: string) -> ai.Prompt { + 0 load_var 2 (output_format) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 80 4 load_const 1 ("") + 5 store_var 2 (output_format) + + 81 6 load_var2 2 1 + 7 load_field 2 (prompt_template) + 8 call_indirect + 9 return +} + +function ai.FunctionSpec.tools(self: ai.FunctionSpec<#0>) -> ai.tools.Toolbox { + 85 0 load_var 1 (self) + 1 load_field 3 (toolbox) + 2 return +} + +function ai.Journal.append_all(self: ai.Journal, events: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[]) -> void { + 27 0 load_var 2 (events) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +8 (to 21) + + 28 14 load_type 5 + 15 load_var 1 (self) + 16 load_field 0 (log) + + 27 17 load_var 4 (_4) + 18 call 4 ntypeargs=1 (baml.Array.push) + 19 pop 1 + 20 jump -15 (to 5) + + 26 21 load_const 6 (null) + 22 return +} + +function ai.Journal.entries(self: ai.Journal) -> (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[] { + 15 0 load_var 1 (self) + 1 load_field 0 (log) + 2 return +} + +function ai.Journal.new(spec: ai.FunctionSpec<#0>) -> ai.Journal { + 21 0 load_type 0 + 1 load_var 1 (spec) + 2 call 790 ntypeargs=1 (ai.FunctionSpec.name) + 3 store_var 2 (_4) + 4 load_type 0 + 5 load_var 1 (spec) + 6 call 791 ntypeargs=1 (ai.FunctionSpec.arguments) + 7 store_var 3 (_6) + 8 load_var2 2 3 + 9 init_instance 0 (ai.events.RunStarted .spec_name, .arguments) + 10 load_type 1 + 11 alloc_array 1 + 12 init_instance 1 (ai.Journal .log) + 13 return +} + +function ai.ModelTurn.terminal_text(self: ai.ModelTurn) -> string | null { + 22 0 load_const 0 (null) + 1 store_var 2 (out) + + 23 2 load_var 1 (self) + 3 load_field 0 (content) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_4) + 8 load_var 3 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_5) + 13 load_var 4 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +10 (to 26) + 17 load_var 4 (_5) + 18 store_var 5 (_9) + + 24 19 load_var 5 (_9) + 20 narrow_bind 6 5 + 21 pop_jump_if_false -13 (to 8) + 22 load_var 5 (_9) + 23 load_field 0 (text) + 24 store_var 2 (out) + 25 jump -17 (to 8) + + 28 26 load_var 2 (out) + 27 return +} + +function ai.ModelTurn.tool_uses(self: ai.ModelTurn) -> ai.content.ToolUse[] { + 33 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 34 3 load_var 1 (self) + 4 load_field 0 (content) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +10 (to 27) + 18 load_var 4 (_5) + 19 store_var 5 (_9) + + 35 20 load_var 5 (_9) + 21 narrow_bind 6 5 + 22 pop_jump_if_false -13 (to 9) + + 36 23 load_var2 2 5 + + 35 24 call 4 ntypeargs=0 (baml.Array.push) + 25 pop 1 + 26 jump -17 (to 9) + + 39 27 load_var 2 (out) + 28 return +} + +function ai.Prompt.baml.ToString.to_string(self: ai.Prompt) -> string { + 35 0 load_var 1 (self) + 1 call 786 ntypeargs=0 (ai.Prompt.text) + 2 return +} + +function ai.Prompt.messages(self: ai.Prompt) -> ai.PromptMessage[] { +} + +function ai.Prompt.text(self: ai.Prompt) -> string { +} + +function ai.clients.Backoff.delay_ms(self: ai.clients.Backoff, attempt: int, f: ai.errors.Failure) -> int { + 27 0 load_var 3 (f) + 1 store_var 4 (_5) + 2 load_var 4 (_5) + 3 narrow_bind 0 4 + 4 pop_jump_if_false +2 (to 6) + 5 jump +3 (to 8) + + 29 6 load_const 1 (null) + + 27 7 jump +3 (to 10) + 8 load_var 4 (_5) + 9 load_field 1 (retry_after_ms) + + 31 10 store_var 5 (_7) + 11 load_var 5 (_7) + 12 narrow_bind 2 5 + 13 pop_jump_if_false +2 (to 15) + 14 jump +29 (to 43) + + 34 15 load_var 1 (self) + 16 load_field 0 (initial_ms) + 17 store_var 6 (d) + + 35 18 load_const 3 (1) + 19 store_var 7 (i) + + 36 20 load_var2 7 2 + 21 cmp_int_op < + 22 pop_jump_if_false +2 (to 24) + 23 jump +11 (to 34) + + 40 24 load_var2 6 1 + 25 load_field 2 (max_ms) + 26 cmp_int_op > + 27 pop_jump_if_false +2 (to 29) + 28 jump +3 (to 31) + + 43 29 load_var 6 (d) + + 40 30 jump +14 (to 44) + + 41 31 load_var 1 (self) + 32 load_field 2 (max_ms) + + 40 33 jump +11 (to 44) + + 37 34 load_var2 6 1 + 35 load_field 1 (multiplier) + 36 mul_int + 37 store_var 6 (d) + + 38 38 load_var 7 (i) + 39 load_const 3 (1) + 40 add_int + 41 store_var 7 (i) + + 36 42 jump -22 (to 20) + + 31 43 load_var 5 (_7) + 44 return +} + +function ai.clients.Backoff.new(initial_ms: int, multiplier: int, max_ms: int) -> ai.clients.Backoff { + 0 load_var 1 (initial_ms) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 20 4 load_const 1 (250) + 5 store_var 1 (initial_ms) + 6 load_var 2 (multiplier) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + 10 load_const 2 (2) + 11 store_var 2 (multiplier) + 12 load_var 3 (max_ms) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + 16 load_const 3 (10000) + 17 store_var 3 (max_ms) + + 21 18 load_var2 1 2 + 19 load_var 3 (max_ms) + 20 init_instance 0 (ai.clients.Backoff .initial_ms, .multiplier, .max_ms) + 21 return +} + +function ai.clients.Fallback._try(self: ai.clients.Fallback, input: ai.ModelTurnInput, index: int) -> ai.ModelTurn { + 151 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_var 3 (index) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 4 (_7) + 6 load_var 4 (_7) + 7 narrow_bind 0 4 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 168 10 load_const 1 ("Fallback needs at least one member") + 11 init_instance 0 (baml.errors.InvalidArgument .message) + 12 throw + + 151 13 load_var2 4 2 + 14 load_type 0 + 15 load_const 2 ("invoke") + 16 virtual_call nargs=2 ntypeargs=0 + 17 jump +43 (to 60) + + 153 18 load_var 5 (e) + 19 store_var 6 (_10) + 20 load_var 6 (_10) + 21 narrow_bind 3 6 + 22 pop_jump_if_false +2 (to 24) + 23 jump +5 (to 28) + 24 load_var 5 (e) + 25 throw_if_panic + + 164 26 load_var 5 (e) + 27 rethrow + + 153 28 load_var 6 (_10) + 29 store_var 7 (f) + + 156 30 load_var 3 (index) + 31 load_const 4 (1) + 32 add_int + 33 store_var 8 (_14) + 34 load_var 1 (self) + 35 load_field 0 (members) + 36 container_len + 37 store_var 9 (_15) + 38 load_var2 8 9 + 39 cmp_int_op < + 40 jump_if_false +11 (to 51) + 41 pop 1 + + 157 42 load_var 7 (f) + 43 load_type 3 + 44 load_const 5 ("retry_safety") + 45 virtual_call nargs=1 ntypeargs=0 + 46 store_var 10 (_17) + 47 load_var 10 (_17) + 48 load_const 6 (ai.errors.RetrySafety.Safe) + 49 alloc_variant 438 (ai.errors.RetrySafety) + 50 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 155 51 pop_jump_if_false +2 (to 53) + 52 jump +3 (to 55) + + 161 53 load_var 5 (e) + 54 rethrow + + 159 55 load_var2 1 2 + 56 load_var 3 (index) + 57 load_const 4 (1) + 58 add_int + 59 call 816 ntypeargs=0 (ai.clients.Fallback._try) + 60 return +} + +function ai.clients.Fallback.root.Client.id(self: ai.clients.Fallback) -> string { + 177 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_const 1 (0) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 3 (_5) + 6 load_var 3 (_5) + 7 narrow_bind 0 3 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 180 10 load_const 2 ("fallback") + 11 store_var 2 (_0) + + 177 12 jump +6 (to 18) + 13 load_var 3 (_5) + 14 load_type 0 + 15 load_const 3 ("id") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 2 (_0) + 18 load_var 2 (_0) + 19 return +} + +function ai.clients.Fallback.root.Client.invoke(self: ai.clients.Fallback, input: ai.ModelTurnInput) -> ai.ModelTurn { + 185 0 load_var2 1 2 + 1 load_const 0 (0) + 2 call 816 ntypeargs=0 (ai.clients.Fallback._try) + 3 jump +6 (to 9) + 4 load_var 3 (e) + 5 throw_if_panic + + 186 6 load_var 3 (e) + 7 call 834 ntypeargs=0 (ai.errors.normalize) + 8 throw + 9 return +} + +function ai.clients.Retry._attempt(self: ai.clients.Retry, input: ai.ModelTurnInput, remaining: int) -> ai.ModelTurn { + 70 0 load_var 1 (self) + 1 load_field 0 (inner) + 2 load_var 2 (input) + 3 load_type 0 + 4 load_const 1 ("invoke") + 5 virtual_call nargs=2 ntypeargs=0 + 6 jump +57 (to 63) + 7 load_var 4 (e) + 8 store_var 5 (_6) + 9 load_var 5 (_6) + 10 narrow_bind 2 5 + 11 pop_jump_if_false +2 (to 13) + 12 jump +5 (to 17) + 13 load_var 4 (e) + 14 throw_if_panic + + 89 15 load_var 4 (e) + 16 rethrow + + 70 17 load_var 5 (_6) + 18 store_var 6 (f) + + 74 19 load_var 3 (remaining) + 20 load_const 3 (1) + 21 cmp_int_op > + 22 jump_if_false +11 (to 33) + 23 pop 1 + + 75 24 load_var 6 (f) + 25 load_type 2 + 26 load_const 4 ("retry_safety") + 27 virtual_call nargs=1 ntypeargs=0 + 28 store_var 7 (_11) + 29 load_var 7 (_11) + 30 load_const 5 (ai.errors.RetrySafety.Safe) + 31 alloc_variant 438 (ai.errors.RetrySafety) + 32 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 74 33 jump_if_false +5 (to 38) + 34 pop 1 + + 76 35 load_var2 6 1 + 36 load_field 2 (retry_if) + 37 call_indirect + + 73 38 pop_jump_if_false +2 (to 40) + 39 jump +3 (to 42) + + 86 40 load_var 4 (e) + 41 rethrow + + 80 42 load_var 1 (self) + 43 load_field 3 (backoff) + + 78 44 load_var 1 (self) + 45 load_field 1 (max_attempts) + 46 load_var 3 (remaining) + 47 sub_int + 48 load_const 3 (1) + 49 add_int + + 80 50 load_var 6 (f) + 51 call 808 ntypeargs=0 (ai.clients.Backoff.delay_ms) + 52 call 504 ntypeargs=0 (baml.time.Duration.from_milliseconds) + + 79 53 sys_op 258 (baml.sys.sleep) + 54 pop 1 + 55 jump +3 (to 58) + 56 load_var 8 (se) + 57 throw_if_panic + + 84 58 load_var2 1 2 + 59 load_var 3 (remaining) + 60 load_const 3 (1) + 61 sub_int + 62 call 810 ntypeargs=0 (ai.clients.Retry._attempt) + 63 return +} + +function ai.clients.Retry.new(inner: ai.Client, max_attempts: int, retry_if: ((ai.errors.Failure) -> bool throws never) | null, backoff: ai.clients.Backoff | null) -> ai.clients.Retry { + 0 load_var 2 (max_attempts) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 57 4 load_const 1 (3) + 5 store_var 2 (max_attempts) + 6 load_var 3 (retry_if) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 58 10 load_const 2 (null) + 11 store_var 3 (retry_if) + 12 load_var 4 (backoff) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 59 16 load_const 2 (null) + 17 store_var 4 (backoff) + + 64 18 load_var 3 (retry_if) + 19 store_var 5 (_8) + 20 load_var 3 (retry_if) + 21 load_const 2 (null) + 22 cmp_op == + 23 pop_jump_if_false +3 (to 26) + 24 load_const 3 (ai.clients.default_retry_judgment) + 25 store_var 5 (_8) + + 65 26 load_var 4 (backoff) + 27 store_var 6 (_10) + 28 load_var 4 (backoff) + 29 load_const 2 (null) + 30 cmp_op == + 31 pop_jump_if_false +6 (to 37) + 32 load_const 0 () + 33 load_const 0 () + 34 load_const 0 () + 35 call 807 ntypeargs=0 (ai.clients.Backoff.new) + 36 store_var 6 (_10) + + 61 37 load_var2 1 2 + 38 load_var2 5 6 + 39 init_instance 0 (ai.clients.Retry .inner, .max_attempts, .retry_if, .backoff) + 40 return +} + +function ai.clients.Retry.root.Client.id(self: ai.clients.Retry) -> string { + 95 0 load_var 1 (self) + 1 load_field 0 (inner) + 2 load_type 0 + 3 load_const 1 ("id") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 2 (_0) + 6 load_var 2 (_0) + 7 return +} + +function ai.clients.Retry.root.Client.invoke(self: ai.clients.Retry, input: ai.ModelTurnInput) -> ai.ModelTurn { + 99 0 load_var2 1 2 + 1 load_var 1 (self) + 2 load_field 1 (max_attempts) + 3 call 810 ntypeargs=0 (ai.clients.Retry._attempt) + 4 jump +6 (to 10) + 5 load_var 3 (e) + 6 throw_if_panic + + 100 7 load_var 3 (e) + 8 call 834 ntypeargs=0 (ai.errors.normalize) + 9 throw + 10 return +} + +function ai.clients.RoundRobin.new(members: ai.Client[]) -> ai.clients.RoundRobin { + 115 0 load_var 1 (members) + 1 container_len + 2 store_var 2 (_3) + 3 load_var 2 (_3) + 4 load_const 0 (0) + 5 cmp_int_op == + 6 pop_jump_if_false +2 (to 8) + 7 jump +5 (to 12) + + 118 8 load_var 1 (members) + 9 load_const 0 (0) + 10 init_instance 0 (ai.clients.RoundRobin .members, .counter) + 11 return + + 116 12 load_const 1 ("RoundRobin needs at least one member") + 13 init_instance 1 (baml.errors.InvalidArgument .message) + 14 throw +} + +function ai.clients.RoundRobin.root.Client.id(self: ai.clients.RoundRobin) -> string { + 123 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_const 1 (0) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 3 (_5) + 6 load_var 3 (_5) + 7 narrow_bind 0 3 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 126 10 load_const 2 ("round-robin") + 11 store_var 2 (_0) + + 123 12 jump +6 (to 18) + 13 load_var 3 (_5) + 14 load_type 0 + 15 load_const 3 ("id") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 2 (_0) + 18 load_var 2 (_0) + 19 return +} + +function ai.clients.RoundRobin.root.Client.invoke(self: ai.clients.RoundRobin, input: ai.ModelTurnInput) -> ai.ModelTurn { + 132 0 load_var 1 (self) + 1 load_field 1 (counter) + 2 store_var 5 (_5) + 3 load_var 1 (self) + 4 load_field 0 (members) + 5 container_len + 6 store_var 6 (_6) + + 133 7 load_var2 1 1 + 8 load_field 1 (counter) + 9 load_const 0 (1) + 10 bin_op + + 11 store_field 1 (counter) + + 134 12 load_type 1 + 13 load_var 1 (self) + 14 load_field 0 (members) + + 132 15 load_var2 5 6 + 16 mod_int + 17 call 3 ntypeargs=1 (baml.Array.at) + + 134 18 store_var 7 (_13) + 19 load_var 7 (_13) + 20 narrow_bind 1 7 + 21 pop_jump_if_false +2 (to 23) + 22 jump +4 (to 26) + + 137 23 load_const 2 ("RoundRobin needs at least one member") + 24 init_instance 0 (baml.errors.InvalidArgument .message) + 25 throw + + 134 26 load_var2 7 2 + 27 load_type 1 + 28 load_const 3 ("invoke") + 29 virtual_call nargs=2 ntypeargs=0 + 30 store_var 3 (_0) + 31 jump +6 (to 37) + + 131 32 load_var 4 (e) + 33 throw_if_panic + + 141 34 load_var 4 (e) + 35 call 834 ntypeargs=0 (ai.errors.normalize) + 36 throw + 37 load_var 3 (_0) + 38 return +} + +function ai.clients.default_retry_judgment(f: ai.errors.Failure) -> bool { + 7 0 load_var 1 (f) + 1 store_var 2 (_2) + 2 load_var 2 (_2) + 3 narrow_bind 0 2 + 4 pop_jump_if_false +2 (to 6) + 5 jump +19 (to 24) + 6 load_var 1 (f) + 7 store_var 3 (_3) + 8 load_var 3 (_3) + 9 narrow_bind 1 3 + 10 pop_jump_if_false +2 (to 12) + 11 jump +11 (to 22) + 12 load_var 1 (f) + 13 store_var 4 (_4) + 14 load_var 4 (_4) + 15 narrow_bind 2 4 + 16 pop_jump_if_false +2 (to 18) + 17 jump +3 (to 20) + + 11 18 load_const 3 (true) + + 7 19 jump +6 (to 25) + + 10 20 load_const 4 (false) + + 7 21 jump +4 (to 25) + + 9 22 load_const 4 (false) + + 7 23 jump +2 (to 25) + + 8 24 load_const 4 (false) + 25 return +} + +function ai.errors.InvalidRequest.Failure.retry_safety(self: ai.errors.InvalidRequest) -> ai.errors.RetrySafety { + 54 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.NetworkFailure.Failure.retry_safety(self: ai.errors.NetworkFailure) -> ai.errors.RetrySafety { + 42 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.ParseFailed.Failure.retry_safety(self: ai.errors.ParseFailed) -> ai.errors.RetrySafety { + 75 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.RateLimited.Failure.retry_safety(self: ai.errors.RateLimited) -> ai.errors.RetrySafety { + 31 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.Refused.Failure.retry_safety(self: ai.errors.Refused) -> ai.errors.RetrySafety { + 65 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.StepBudgetExceeded.Failure.retry_safety(self: ai.errors.StepBudgetExceeded) -> ai.errors.RetrySafety { + 88 0 load_const 0 (ai.errors.RetrySafety.Unsafe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.StreamingUnsupported.Failure.retry_safety(self: ai.errors.StreamingUnsupported) -> ai.errors.RetrySafety { + 117 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.ToolFailedError.Failure.retry_safety(self: ai.errors.ToolFailedError) -> ai.errors.RetrySafety { + 104 0 load_const 0 (ai.errors.RetrySafety.Unsafe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 return +} + +function ai.errors.classify_http(provider: string, status_code: int, body: string) -> ai.errors.Failure { + 125 0 load_var 2 (status_code) + 1 load_const 0 (429) + 2 cmp_int_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +34 (to 38) + + 127 5 load_var 2 (status_code) + 6 load_const 1 (408) + 7 cmp_int_op == + 8 jump_if_false +2 (to 10) + 9 jump +5 (to 14) + 10 pop 1 + 11 load_var 2 (status_code) + 12 load_const 2 (500) + 13 cmp_int_op >= + 14 pop_jump_if_false +2 (to 16) + 15 jump +12 (to 27) + + 133 16 load_type 3 + 17 load_var 2 (status_code) + 18 call 138 ntypeargs=1 (baml.String.from) + 19 store_var 5 (_11) + + 130 20 load_var2 1 2 + + 133 21 load_const 4 ("http ") + 22 load_var 5 (_11) + 23 bin_op + + 24 load_var 3 (body) + 25 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + + 127 26 jump +16 (to 42) + + 128 27 load_type 3 + 28 load_var 2 (status_code) + 29 call 138 ntypeargs=1 (baml.String.from) + 30 store_var 4 (_8) + 31 load_var 1 (provider) + 32 load_const 5 ("http ") + 33 load_var 4 (_8) + 34 bin_op + + 35 load_var 3 (body) + 36 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + + 127 37 jump +5 (to 42) + + 126 38 load_var 1 (provider) + 39 load_const 6 (null) + 40 load_var 3 (body) + 41 init_instance 2 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) + 42 return +} + +function ai.errors.normalize(error: unknown) -> ai.errors.Failure | baml.errors.UnknownError { + 18 0 load_var 1 (error) + 1 store_var 2 (_2) + 2 load_var 2 (_2) + 3 narrow_bind 0 2 + 4 pop_jump_if_false +2 (to 6) + 5 jump +18 (to 23) + 6 load_var 1 (error) + 7 store_var 3 (_4) + 8 load_var 3 (_4) + 9 narrow_bind 1 3 + 10 pop_jump_if_false +2 (to 12) + 11 jump +10 (to 21) + + 21 12 load_type 2 + 13 load_var 1 (error) + 14 call 138 ntypeargs=1 (baml.String.from) + 15 store_var 4 (_7) + 16 load_var2 1 4 + 17 load_type 3 + 18 alloc_array 1 + 19 init_instance 0 (baml.errors.UnknownError .data, .message) + + 18 20 jump +4 (to 24) + 21 load_var 3 (_4) + 22 jump +2 (to 24) + 23 load_var 2 (_2) + 24 return +} + +function ai.internal._schema_for_signature(handler: baml.AnyFunction) -> map { + 6 0 load_var 1 (handler) + 1 call 718 ntypeargs=0 (reflect.signature) + 2 store_var 2 (sig) + + 7 3 load_type 0 + 4 load_type 1 + 5 alloc_map 0 + 6 store_var 3 (props) + + 8 7 load_type 0 + 8 alloc_array 0 + 9 store_var 4 (required) + + 9 10 load_var 2 (sig) + 11 load_field 1 (args) + 12 load_type 2 + 13 load_const 3 ("iter") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 5 (_6) + 16 load_var 5 (_6) + 17 load_type 4 + 18 load_const 5 ("next") + 19 virtual_call nargs=1 ntypeargs=0 + 20 store_var 6 (_7) + 21 load_var 6 (_7) + 22 is_type 6 + 23 pop_jump_if_false +2 (to 25) + 24 jump +21 (to 45) + 25 load_var 6 (_7) + 26 store_var 7 (a) + + 10 27 load_var 7 (a) + 28 load_field 0 (name) + 29 store_var 8 (_12) + 30 load_var 7 (a) + 31 load_field 1 (type) + 32 sys_op 343 (baml.json.schema) + 33 store_var 9 (_13) + 34 load_type 0 + 35 load_type 1 + 36 load_var2 3 8 + 37 load_var 9 (_13) + 38 call 37 ntypeargs=2 (baml.Map.set) + 39 pop 1 + + 11 40 load_var2 4 7 + 41 load_field 0 (name) + 42 call 4 ntypeargs=0 (baml.Array.push) + 43 pop 1 + 44 jump -28 (to 16) + + 13 45 load_const 7 ("object") + 46 load_var2 3 4 + 47 load_const 8 (false) + 48 load_const 9 ("type") + 49 load_const 10 ("properties") + 50 load_const 11 ("required") + 51 load_const 12 ("additionalProperties") + 52 load_type 0 + 53 load_type 1 + 54 alloc_map 4 + 55 return +} + +function ai.internal.assemble_prompt(parts: string[], values: unknown[]) -> ai.Prompt { +} + +function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, params: map) -> baml.json.json { + 100 0 load_var 1 (self) + 1 load_field 2 (next_id) + 2 store_var 4 (id) + + 101 3 load_var 1 (self) + 4 copy 0 + 5 load_field 2 (next_id) + 6 load_const 0 (1) + 7 bin_op + + 8 store_field 2 (next_id) + + 102 9 load_var2 4 2 + 10 load_var 3 (params) + 11 call 904 ntypeargs=0 (ai.mcp.rpc_line) + 12 store_var 5 (_6) + 13 load_var2 1 5 + 14 call 906 ntypeargs=0 (ai.mcp.McpConnection._send) + 15 pop 1 + + 103 16 load_const 1 (true) + 17 pop_jump_if_false +2 (to 19) + 18 jump +19 (to 37) + + 146 19 load_type 2 + 20 load_var 1 (self) + 21 load_field 0 (server_name) + 22 call 138 ntypeargs=1 (baml.String.from) + 23 store_var 22 (_66) + + 147 24 load_type 2 + 25 load_var 2 (method) + 26 call 138 ntypeargs=1 (baml.String.from) + 27 store_var 23 (_70) + + 146 28 load_const 3 ("mcp/") + 29 load_var 22 (_66) + 30 bin_op + + + 147 31 load_const 4 ("no response for ") + 32 load_var 23 (_70) + 33 bin_op + + 34 load_const 5 (null) + 35 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 36 throw + + 104 37 load_var 1 (self) + 38 load_field 1 (p) + 39 load_field 0 (stdout) + 40 load_type 6 + 41 load_const 7 ("next") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 6 (next) + 44 jump +25 (to 69) + 45 load_var 7 (e) + 46 throw_if_panic + + 107 47 load_type 2 + 48 load_var 1 (self) + 49 load_field 0 (server_name) + 50 call 138 ntypeargs=1 (baml.String.from) + 51 store_var 8 (_13) + + 108 52 load_type 8 + 53 load_var 7 (e) + 54 call 138 ntypeargs=1 (baml.String.from) + 55 store_var 10 (_18) + 56 load_type 2 + 57 load_var 10 (_18) + 58 call 138 ntypeargs=1 (baml.String.from) + 59 store_var 9 (_17) + + 107 60 load_const 9 ("mcp/") + 61 load_var 8 (_13) + 62 bin_op + + + 108 63 load_const 10 ("reading from the MCP server failed: ") + 64 load_var 9 (_17) + 65 bin_op + + 66 load_const 5 (null) + 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 68 throw + + 113 69 load_var 6 (next) + 70 store_var 11 (_21) + 71 load_var 11 (_21) + 72 narrow_bind 0 11 + 73 pop_jump_if_false +2 (to 75) + 74 jump +19 (to 93) + + 137 75 load_type 2 + 76 load_var 1 (self) + 77 load_field 0 (server_name) + 78 call 138 ntypeargs=1 (baml.String.from) + 79 store_var 20 (_58) + + 138 80 load_type 2 + 81 load_var 2 (method) + 82 call 138 ntypeargs=1 (baml.String.from) + 83 store_var 21 (_62) + + 137 84 load_const 11 ("mcp/") + 85 load_var 20 (_58) + 86 bin_op + + + 138 87 load_const 12 ("the MCP server stream ended before answering ") + 88 load_var 21 (_62) + 89 bin_op + + 90 load_const 5 (null) + 91 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 92 throw + + 113 93 load_var 11 (_21) + 94 call 144 ntypeargs=0 (baml.String.trim) + 95 store_var 12 (trimmed) + + 116 96 load_var 12 (trimmed) + 97 call 139 ntypeargs=0 (baml.String.length) + 98 load_const 13 (0) + 99 cmp_int_op > + 100 pop_jump_if_false -84 (to 16) + + 118 101 load_var 12 (trimmed) + 102 call 329 ntypeargs=0 (baml.json.parse) + 103 store_var 13 (msg) + 104 jump +5 (to 109) + 105 load_var 14 (e) + 106 throw_if_panic + + 119 107 load_const 5 (null) + 108 store_var 13 (msg) + + 121 109 load_type 14 + 110 load_var 13 (msg) + 111 load_const 15 (".id") + 112 load_const 0 (1) + 113 unary_op - + 114 call 342 ntypeargs=1 (baml.json.path_or) + 115 load_var 4 (id) + 116 cmp_int_op == + 117 pop_jump_if_false -101 (to 16) + + 122 118 load_type 16 + 119 load_var 13 (msg) + 120 load_const 17 (".error") + 121 load_const 5 (null) + 122 call 342 ntypeargs=1 (baml.json.path_or) + 123 store_var 15 (err) + + 123 124 load_var 15 (err) + 125 load_const 5 (null) + 126 call 635 ntypeargs=0 (baml.ops.equals_equals) + 127 unary_op ! + 128 pop_jump_if_false +2 (to 130) + 129 jump +7 (to 136) + + 131 130 load_type 16 + 131 load_var 13 (msg) + 132 load_const 18 (".result") + 133 load_const 5 (null) + 134 call 342 ntypeargs=1 (baml.json.path_or) + 135 return + + 125 136 load_type 2 + 137 load_var 1 (self) + 138 load_field 0 (server_name) + 139 call 138 ntypeargs=1 (baml.String.from) + 140 store_var 16 (_43) + + 126 141 load_type 19 + 142 load_var 15 (err) + 143 load_const 20 (".code") + 144 load_const 5 (null) + 145 call 342 ntypeargs=1 (baml.json.path_or) + 146 store_var 17 (_46) + + 127 147 load_type 2 + 148 load_var 15 (err) + 149 load_const 21 (".message") + 150 load_const 22 ("MCP error") + 151 call 342 ntypeargs=1 (baml.json.path_or) + 152 store_var 18 (_49) + + 128 153 load_var 15 (err) + 154 call 330 ntypeargs=0 (baml.json.stringify) + 155 store_var 19 (_52) + + 125 156 load_const 23 ("mcp/") + 157 load_var 16 (_43) + 158 bin_op + + 159 load_var2 17 18 + 160 load_var 19 (_52) + 161 init_instance 3 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + 162 throw +} + +function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> null { + 84 0 load_type 0 + 1 load_var 2 (line) + 2 load_const 1 ("\n") + 3 load_type 0 + 4 alloc_array 2 + 5 load_const 2 ("") + 6 call 15 ntypeargs=1 (baml.Array.join) + 7 store_var 3 (framed) + + 85 8 load_var 1 (self) + 9 load_field 1 (p) + 10 load_var 3 (framed) + 11 sys_op 250 (baml.sys.Process.write_stdin) + 12 pop 1 + 13 jump +25 (to 38) + 14 load_var 4 (e) + 15 throw_if_panic + + 88 16 load_type 0 + 17 load_var 1 (self) + 18 load_field 0 (server_name) + 19 call 138 ntypeargs=1 (baml.String.from) + 20 store_var 5 (_12) + + 89 21 load_type 3 + 22 load_var 4 (e) + 23 call 138 ntypeargs=1 (baml.String.from) + 24 store_var 7 (_17) + 25 load_type 0 + 26 load_var 7 (_17) + 27 call 138 ntypeargs=1 (baml.String.from) + 28 store_var 6 (_16) + + 88 29 load_const 4 ("mcp/") + 30 load_var 5 (_12) + 31 bin_op + + + 89 32 load_const 5 ("writing to the MCP server failed: ") + 33 load_var 6 (_16) + 34 bin_op + + 35 load_const 6 (null) + 36 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 37 throw + + 94 38 load_const 6 (null) + 39 return +} + +function ai.mcp.McpConnection.call_tool(self: ai.mcp.McpConnection, name: string, args: map) -> string { + 184 0 load_var 1 (self) + 1 load_const 0 ("tools/call") + + 183 2 load_var2 2 3 + 3 load_const 1 ("name") + 4 load_const 2 ("arguments") + 5 load_type 3 + 6 load_type 4 + 7 alloc_map 2 + 8 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 9 store_var 4 (result) + + 185 10 load_type 3 + 11 alloc_array 0 + 12 store_var 5 (texts) + + 186 13 load_type 5 + 14 load_var 4 (result) + 15 load_const 6 (".content") + 16 load_type 7 + 17 alloc_array 0 + 18 call 342 ntypeargs=1 (baml.json.path_or) + 19 load_type 8 + 20 load_const 9 ("iter") + 21 virtual_call nargs=1 ntypeargs=0 + 22 store_var 6 (_12) + 23 load_var 6 (_12) + 24 load_type 10 + 25 load_const 11 ("next") + 26 virtual_call nargs=1 ntypeargs=0 + 27 store_var 7 (_13) + 28 load_var 7 (_13) + 29 is_type 12 + 30 pop_jump_if_false +2 (to 32) + 31 jump +21 (to 52) + 32 load_var 7 (_13) + 33 store_var 8 (item) + + 187 34 load_type 3 + 35 load_var 8 (item) + 36 load_const 13 (".type") + 37 load_const 14 ("") + 38 call 342 ntypeargs=1 (baml.json.path_or) + 39 load_const 15 ("text") + 40 cmp_op == + 41 pop_jump_if_false -18 (to 23) + + 188 42 load_type 3 + 43 load_var 8 (item) + 44 load_const 16 (".text") + 45 load_const 17 ("") + 46 call 342 ntypeargs=1 (baml.json.path_or) + 47 store_var 9 (_22) + 48 load_var2 5 9 + 49 call 4 ntypeargs=0 (baml.Array.push) + 50 pop 1 + 51 jump -28 (to 23) + + 191 52 load_type 3 + 53 load_var 5 (texts) + 54 load_const 18 ("\n") + 55 call 15 ntypeargs=1 (baml.Array.join) + 56 store_var 10 (joined) + + 192 57 load_type 19 + 58 load_var 4 (result) + 59 load_const 20 (".isError") + 60 load_const 21 (false) + 61 call 342 ntypeargs=1 (baml.json.path_or) + 62 pop_jump_if_false +2 (to 64) + 63 jump +3 (to 66) + + 195 64 load_var 10 (joined) + 65 return + + 193 66 load_type 3 + 67 load_var 2 (name) + 68 call 138 ntypeargs=1 (baml.String.from) + 69 store_var 11 (_34) + 70 load_type 3 + 71 load_var 10 (joined) + 72 call 138 ntypeargs=1 (baml.String.from) + 73 store_var 12 (_36) + 74 load_const 22 ("mcp tool ") + 75 load_var 11 (_34) + 76 bin_op + + 77 load_const 23 (" failed: ") + 78 bin_op + + 79 load_var 12 (_36) + 80 bin_op + + 81 init_instance 0 (baml.errors.InvalidArgument .message) + 82 throw +} + +function ai.mcp.McpConnection.close(self: ai.mcp.McpConnection) -> null { + 199 0 load_var 1 (self) + 1 load_field 1 (p) + 2 sys_op 254 (baml.sys.Process.close) + 3 return +} + +function ai.mcp.McpConnection.connect(name: string, command: string, args: string[], timeout_ms: int) -> ai.mcp.McpConnection { + 0 load_var 4 (timeout_ms) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 48 4 load_const 1 (30000) + 5 store_var 4 (timeout_ms) + + 50 6 load_var2 2 3 + + 53 7 load_const 2 (null) + 8 load_const 2 (null) + 9 load_var 4 (timeout_ms) + 10 load_const 2 (null) + 11 load_const 3 (true) + 12 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) + 13 sys_op 256 (baml.sys.start_process) + 14 store_var 5 (p) + 15 jump +24 (to 39) + + 50 16 load_var 6 (e) + 17 throw_if_panic + + 63 18 load_type 4 + 19 load_var 1 (name) + 20 call 138 ntypeargs=1 (baml.String.from) + 21 store_var 7 (_11) + + 64 22 load_type 5 + 23 load_var 6 (e) + 24 call 138 ntypeargs=1 (baml.String.from) + 25 store_var 9 (_15) + 26 load_type 4 + 27 load_var 9 (_15) + 28 call 138 ntypeargs=1 (baml.String.from) + 29 store_var 8 (_14) + + 63 30 load_const 6 ("mcp/") + 31 load_var 7 (_11) + 32 bin_op + + + 64 33 load_const 7 ("the MCP server could not start: ") + 34 load_var 8 (_14) + 35 bin_op + + 36 load_const 2 (null) + 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 38 throw + + 69 39 load_var2 1 5 + 40 load_const 8 (1) + 41 init_instance 2 (ai.mcp.McpConnection .server_name, .p, .next_id) + 42 store_var 10 (conn) + + 75 43 load_var 10 (conn) + 44 load_const 9 ("initialize") + + 70 45 load_const 10 ("2025-06-18") + + 72 46 load_type 11 + 47 load_type 11 + 48 alloc_map 0 + + 73 49 load_const 12 ("baml-mcp") + 50 load_const 13 ("0.1") + 51 load_const 14 ("name") + 52 load_const 15 ("version") + 53 load_type 4 + 54 load_type 4 + 55 alloc_map 2 + 56 load_const 16 ("protocolVersion") + 57 load_const 17 ("capabilities") + 58 load_const 18 ("clientInfo") + 59 load_type 4 + 60 load_type 19 + 61 alloc_map 3 + 62 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 63 pop 1 + + 76 64 load_const 2 (null) + 65 load_const 20 ("notifications/initialized") + 66 load_const 2 (null) + 67 call 904 ntypeargs=0 (ai.mcp.rpc_line) + 68 store_var 11 (_26) + 69 load_var2 10 11 + 70 call 906 ntypeargs=0 (ai.mcp.McpConnection._send) + 71 pop 1 + + 77 72 load_var 10 (conn) + 73 return +} + +function ai.mcp.McpConnection.tools(self: ai.mcp.McpConnection) -> ai.tools.Tool[] { + 156 0 load_var 1 (self) + 1 load_const 0 ("tools/list") + 2 load_type 1 + 3 load_type 2 + 4 alloc_map 0 + 5 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 6 store_var 2 (result) + + 157 7 load_type 3 + 8 alloc_array 0 + 9 store_var 3 (out) + + 158 10 load_type 4 + 11 load_var 2 (result) + 12 load_const 5 (".tools") + 13 load_type 6 + 14 alloc_array 0 + 15 call 342 ntypeargs=1 (baml.json.path_or) + 16 load_type 7 + 17 load_const 8 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 4 (_9) + 20 load_var 4 (_9) + 21 load_type 9 + 22 load_const 10 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 5 (_10) + 25 load_var 5 (_10) + 26 is_type 11 + 27 pop_jump_if_false +2 (to 29) + 28 jump +48 (to 76) + 29 load_var 5 (_10) + 30 store_var 6 (t) + + 159 31 load_type 1 + 32 load_var 6 (t) + 33 load_const 12 (".name") + 34 load_const 13 ("") + 35 call 342 ntypeargs=1 (baml.json.path_or) + 36 store_var 7 (tool_name) + + 161 37 load_type 6 + 38 load_var 6 (t) + 39 load_const 14 (".inputSchema") + 40 load_type 1 + 41 load_type 6 + 42 alloc_map 0 + 43 call 342 ntypeargs=1 (baml.json.path_or) + 44 store_var 10 (_19) + + 160 45 load_type 15 + 46 load_var 10 (_19) + 47 call 336 ntypeargs=1 (baml.json.from_json) + 48 store_var 8 (schema) + 49 jump +7 (to 56) + 50 load_var 9 (e) + 51 throw_if_panic + + 164 52 load_type 1 + 53 load_type 2 + 54 alloc_map 0 + 55 store_var 8 (schema) + + 171 56 load_type 1 + 57 load_var 6 (t) + 58 load_const 16 (".description") + 59 load_const 17 ("") + 60 call 342 ntypeargs=1 (baml.json.path_or) + 61 store_var 12 (_28) + + 172 62 load_var 8 (schema) + 63 store_var 13 (_31) + + 173 64 load_var2 1 7 + 65 call 903 ntypeargs=0 (ai.mcp._proxy) + 66 store_var 14 (_32) + + 170 67 load_var2 7 12 + 68 load_var2 13 14 + 69 load_const 18 () + 70 call 797 ntypeargs=0 (ai.tools.raw_tool) + 71 store_var 11 (_26) + + 168 72 load_var2 3 11 + 73 call 4 ntypeargs=0 (baml.Array.push) + 74 pop 1 + 75 jump -55 (to 20) + + 177 76 load_var 3 (out) + 77 return +} + +function ai.mcp._proxy(conn: ai.mcp.McpConnection, name: string) -> (map) -> string throws unknown { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 20 6 load_var2 1 2 + 7 make_closure 2279 2 + 8 return +} + +function ai.mcp.rpc_line(id: int | null, method: string, params: map | null) -> string { + 27 0 load_const 0 ("2.0") + 1 load_var 2 (method) + 2 load_const 1 ("jsonrpc") + 3 load_const 2 ("method") + 4 load_type 3 + 5 load_type 4 + 6 alloc_map 2 + 7 store_var 4 (m) + + 28 8 load_var 1 (id) + 9 store_var 5 (_5) + 10 load_var 5 (_5) + 11 narrow_bind 5 5 + 12 pop_jump_if_false +8 (to 20) + + 29 13 load_type 3 + 14 load_type 4 + 15 load_var 4 (m) + 16 load_const 6 ("id") + + 28 17 load_var 5 (_5) + 18 call 37 ntypeargs=2 (baml.Map.set) + 19 pop 1 + + 31 20 load_var 3 (params) + 21 store_var 6 (_11) + 22 load_var 6 (_11) + 23 narrow_bind 7 6 + 24 pop_jump_if_false +8 (to 32) + + 32 25 load_type 3 + 26 load_type 4 + 27 load_var 4 (m) + 28 load_const 8 ("params") + + 31 29 load_var 6 (_11) + 30 call 37 ntypeargs=2 (baml.Map.set) + 31 pop 1 + + 34 32 load_type 7 + 33 load_var 4 (m) + 34 call 333 ntypeargs=1 (baml.json.to_json) + 35 call 330 ntypeargs=0 (baml.json.stringify) + 36 return +} + +function ai.prompt(body: ((string) -> baml.prompt.Role throws never, baml.prompt.Context) -> baml.TaggedString throws never) -> (baml.prompt.Context) -> ai.Prompt throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 49 3 load_var 1 (body) + 4 make_closure 1629 1 + 5 return +} + +function ai.stream.Stream.final(self: ai.stream.Stream<#0, #1>) -> #1 { + 278 0 load_var 1 (self) + 1 load_field 3 (_finished) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +9 (to 13) + + 288 5 load_var 1 (self) + 6 load_field 2 (_text) + 7 load_var 1 (self) + 8 load_field 1 (_cache) + 9 load_type 0 + 10 load_type 1 + 11 sys_op 426 (baml.sap.__parse_final) + 12 return + + 279 13 load_var 1 (self) + 14 load_field 0 (_next_text) + 15 call_indirect + 16 store_var 2 (_4) + 17 load_var 2 (_4) + 18 load_const 2 (null) + 19 cmp_op == + 20 pop_jump_if_false +2 (to 22) + 21 jump +7 (to 28) + + 284 22 load_var2 1 1 + 23 load_field 2 (_text) + + 279 24 load_var 2 (_4) + 25 bin_op + + 26 store_field 2 (_text) + 27 jump -27 (to 0) + + 281 28 load_var 1 (self) + 29 load_const 3 (true) + 30 store_field 3 (_finished) + + 279 31 jump -31 (to 0) +} + +function ai.stream.Stream.next(self: ai.stream.Stream<#0, #1>) -> #0 | ai.stream.Done { + 252 0 load_const 0 (true) + 1 pop_jump_if_false +2 (to 3) + 2 jump +4 (to 6) + + 273 3 load_const 1 ("unreachable") + 4 call 260 ntypeargs=0 (baml.sys.panic) + 5 jump +39 (to 44) + + 253 6 load_var 1 (self) + 7 load_field 3 (_finished) + 8 pop_jump_if_false +2 (to 10) + 9 jump +34 (to 43) + + 256 10 load_var 1 (self) + 11 load_field 0 (_next_text) + 12 call_indirect + 13 store_var 2 (_3) + 14 load_var 2 (_3) + 15 load_const 2 (null) + 16 cmp_op == + 17 pop_jump_if_false +2 (to 19) + 18 jump +20 (to 38) + + 262 19 load_var2 1 1 + 20 load_field 2 (_text) + + 256 21 load_var 2 (_3) + 22 bin_op + + 23 store_field 2 (_text) + + 263 24 load_var 1 (self) + 25 load_field 2 (_text) + 26 load_var 1 (self) + 27 load_field 1 (_cache) + 28 load_type 3 + 29 load_type 4 + 30 sys_op 427 (baml.sap.__parse_partial) + 31 store_var 3 (parsed) + + 264 32 load_var 3 (parsed) + 33 is_type 5 + 34 pop_jump_if_false +2 (to 36) + 35 jump -35 (to 0) + 36 load_var 3 (parsed) + + 267 37 jump +7 (to 44) + + 258 38 load_var 1 (self) + 39 load_const 0 (true) + 40 store_field 3 (_finished) + + 259 41 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 42 jump +2 (to 44) + + 254 43 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 44 return +} + +function ai.stream.TurnStream._finish(self: ai.stream.TurnStream) -> null { + 128 0 load_var 1 (self) + 1 load_const 0 (true) + 2 store_field 10 (_done) + + 129 3 load_var 1 (self) + 4 load_field 0 (_sse) + 5 store_var 2 (_3) + 6 load_var 2 (_3) + 7 narrow_bind 1 2 + 8 pop_jump_if_false +2 (to 10) + 9 jump +3 (to 12) + + 132 10 load_const 2 (null) + + 129 11 jump +3 (to 14) + 12 load_var 2 (_3) + 13 sys_op 229 (baml.http.SseStream.close) + 14 return +} + +function ai.stream.TurnStream.final_turn(self: ai.stream.TurnStream) -> ai.ModelTurn { + 215 0 load_const 0 (true) + 1 pop_jump_if_false +7 (to 8) + + 216 2 load_var 1 (self) + 3 call 829 ntypeargs=0 (ai.stream.TurnStream.next) + 4 store_var 2 (_3) + 5 load_var 2 (_3) + 6 narrow_bind 1 2 + 7 pop_jump_if_false -7 (to 0) + + 223 8 load_var 1 (self) + 9 load_field 8 (_input_tokens) + 10 load_const 2 (null) + 11 call 635 ntypeargs=0 (baml.ops.equals_equals) + 12 unary_op ! + 13 jump_if_false +2 (to 15) + 14 jump +7 (to 21) + 15 pop 1 + 16 load_var 1 (self) + 17 load_field 9 (_output_tokens) + 18 load_const 2 (null) + 19 call 635 ntypeargs=0 (baml.ops.equals_equals) + 20 unary_op ! + 21 pop_jump_if_false +2 (to 23) + 22 jump +4 (to 26) + + 231 23 load_const 2 (null) + 24 store_var 3 (usage) + + 223 25 jump +28 (to 53) + + 225 26 load_var 1 (self) + 27 load_field 8 (_input_tokens) + 28 store_var 5 (_12) + 29 load_var 5 (_12) + 30 store_var 4 (_11) + 31 load_var 5 (_12) + 32 load_const 2 (null) + 33 cmp_op == + 34 pop_jump_if_false +3 (to 37) + 35 load_const 3 (0) + 36 store_var 4 (_11) + + 226 37 load_var 1 (self) + 38 load_field 9 (_output_tokens) + 39 store_var 7 (_15) + 40 load_var 7 (_15) + 41 store_var 6 (_14) + 42 load_var 7 (_15) + 43 load_const 2 (null) + 44 cmp_op == + 45 pop_jump_if_false +3 (to 48) + 46 load_const 3 (0) + 47 store_var 6 (_14) + + 224 48 load_var2 4 6 + 49 load_const 2 (null) + 50 load_const 2 (null) + 51 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 52 store_var 3 (usage) + + 235 53 load_var 1 (self) + 54 load_field 7 (_stop_reason) + 55 store_var 9 (_21) + 56 load_var 9 (_21) + 57 store_var 8 (_20) + 58 load_var 9 (_21) + 59 load_const 2 (null) + 60 cmp_op == + 61 pop_jump_if_false +4 (to 65) + 62 load_const 3 (ai.content.StopReason.Complete) + 63 alloc_variant 436 (ai.content.StopReason) + 64 store_var 8 (_20) + + 234 65 load_var 1 (self) + 66 load_field 6 (_text) + 67 init_instance 1 (ai.content.Text .text) + 68 load_type 4 + 69 alloc_array 1 + 70 load_var2 8 3 + + 236 71 init_instance 2 (ai.ModelTurn .content, .stop_reason, .usage) + 72 return +} + +function ai.stream.TurnStream.from_chunks(chunks: string[]) -> ai.stream.TurnStream { + 112 0 load_const 0 (null) + 1 load_const 0 (null) + 2 load_var 1 (chunks) + 3 load_const 1 (0) + + 117 4 load_type 2 + 5 alloc_array 0 + 6 load_const 1 (0) + 7 load_const 3 ("") + 8 load_const 0 (null) + 9 load_const 0 (null) + 10 load_const 0 (null) + 11 load_const 4 (false) + 12 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done) + 13 return +} + +function ai.stream.TurnStream.from_sse(sse: baml.http.SseStream, decode: (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown) -> ai.stream.TurnStream { + 93 0 load_var2 1 2 + + 96 1 load_type 0 + 2 alloc_array 0 + 3 load_const 1 (0) + + 98 4 load_type 2 + 5 alloc_array 0 + 6 load_const 1 (0) + 7 load_const 3 ("") + 8 load_const 4 (null) + 9 load_const 4 (null) + 10 load_const 4 (null) + 11 load_const 5 (false) + 12 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done) + 13 return +} + +function ai.stream.TurnStream.next(self: ai.stream.TurnStream) -> string | ai.stream.Done { + 139 0 load_const 0 (true) + 1 pop_jump_if_false +2 (to 3) + 2 jump +4 (to 6) + + 209 3 load_const 1 ("unreachable") + 4 call 260 ntypeargs=0 (baml.sys.panic) + 5 jump +184 (to 189) + + 140 6 load_var 1 (self) + 7 load_field 10 (_done) + 8 pop_jump_if_false +2 (to 10) + 9 jump +179 (to 188) + + 144 10 load_var 1 (self) + 11 load_field 5 (_pcursor) + 12 store_var 2 (_4) + 13 load_var 1 (self) + 14 load_field 4 (_pending) + 15 container_len + 16 store_var 3 (_5) + 17 load_var2 2 3 + 18 cmp_int_op < + 19 pop_jump_if_false +2 (to 21) + 20 jump +88 (to 108) + + 172 21 load_var 1 (self) + 22 load_field 0 (_sse) + 23 store_var 15 (_33) + 24 load_var 15 (_33) + 25 narrow_bind 2 15 + 26 pop_jump_if_false +2 (to 28) + 27 jump +40 (to 67) + + 195 28 load_type 3 + 29 load_var 1 (self) + 30 load_field 2 (_chunks) + 31 load_var 1 (self) + 32 load_field 3 (_cursor) + 33 call 3 ntypeargs=1 (baml.Array.at) + 34 store_var 20 (_58) + 35 load_var 20 (_58) + 36 narrow_bind 4 20 + 37 pop_jump_if_false +2 (to 39) + 38 jump +6 (to 44) + + 202 39 load_var 1 (self) + 40 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 41 pop 1 + + 203 42 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 43 jump +146 (to 189) + + 195 44 load_var 20 (_58) + 45 store_var 21 (c) + + 197 46 load_var 1 (self) + 47 copy 0 + 48 load_field 3 (_cursor) + 49 load_const 4 (1) + 50 bin_op + + 51 store_field 3 (_cursor) + + 198 52 load_type 3 + 53 load_var 1 (self) + 54 load_field 6 (_text) + 55 call 138 ntypeargs=1 (baml.String.from) + 56 store_var 22 (_60) + 57 load_type 3 + 58 load_var 21 (c) + 59 call 138 ntypeargs=1 (baml.String.from) + 60 store_var 23 (_63) + 61 load_var2 1 22 + 62 load_var 23 (_63) + 63 bin_op + + 64 store_field 6 (_text) + + 199 65 load_var 21 (c) + 66 jump +123 (to 189) + + 172 67 load_var 15 (_33) + 68 sys_op 228 (baml.http.SseStream.next) + 69 store_var 16 (_35) + + 174 70 load_var 16 (_35) + 71 load_const 5 (null) + 72 cmp_op == + 73 pop_jump_if_false +2 (to 75) + 74 jump +29 (to 103) + + 180 75 load_var 1 (self) + 76 load_field 1 (_decode) + 77 store_var 17 (_40) + 78 load_var 17 (_40) + 79 narrow_bind 6 17 + 80 pop_jump_if_false -80 (to 0) + + 174 81 load_var2 16 17 + + 180 82 call_indirect + + 181 83 load_type 7 + 84 load_const 8 ("iter") + 85 virtual_call nargs=1 ntypeargs=0 + 86 store_var 18 (_45) + 87 load_var 18 (_45) + 88 load_type 9 + 89 load_const 10 ("next") + 90 virtual_call nargs=1 ntypeargs=0 + 91 store_var 19 (_46) + 92 load_var 19 (_46) + 93 is_type 11 + 94 pop_jump_if_false +2 (to 96) + 95 jump -95 (to 0) + + 182 96 load_type 12 + 97 load_var 1 (self) + 98 load_field 4 (_pending) + + 181 99 load_var 19 (_46) + 100 call 4 ntypeargs=1 (baml.Array.push) + 101 pop 1 + 102 jump -15 (to 87) + + 176 103 load_var 1 (self) + 104 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 105 pop 1 + + 177 106 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 107 jump +82 (to 189) + + 145 108 load_type 12 + 109 load_var 1 (self) + 110 load_field 4 (_pending) + 111 load_var 1 (self) + 112 load_field 5 (_pcursor) + 113 call 3 ntypeargs=1 (baml.Array.at) + 114 store_var 4 (e) + + 146 115 load_var 1 (self) + 116 copy 0 + 117 load_field 5 (_pcursor) + 118 load_const 4 (1) + 119 bin_op + + 120 store_field 5 (_pcursor) + + 147 121 load_var 4 (e) + 122 store_var 5 (_11) + 123 load_var 5 (_11) + 124 narrow_bind 13 5 + 125 pop_jump_if_false +2 (to 127) + 126 jump +43 (to 169) + 127 load_var 4 (e) + 128 store_var 9 (_19) + 129 load_var 9 (_19) + 130 narrow_bind 14 9 + 131 pop_jump_if_false +2 (to 133) + 132 jump +11 (to 143) + 133 load_var 4 (e) + 134 store_var 14 (_30) + 135 load_var 14 (_30) + 136 narrow_bind 15 14 + 137 pop_jump_if_false -137 (to 0) + + 165 138 load_var 1 (self) + 139 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 140 pop 1 + + 166 141 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 142 jump +47 (to 189) + + 147 143 load_var 9 (_19) + 144 store_var_load_var 10 (m) + + 153 145 load_field 0 (stop_reason) + 146 store_var 11 (_22) + 147 load_var 11 (_22) + 148 narrow_bind 16 11 + 149 pop_jump_if_false +3 (to 152) + + 154 150 load_var2 1 11 + + 153 151 store_field 7 (_stop_reason) + + 156 152 load_var 10 (m) + 153 load_field 1 (input_tokens) + 154 store_var 12 (_25) + 155 load_var 12 (_25) + 156 narrow_bind 17 12 + 157 pop_jump_if_false +3 (to 160) + + 157 158 load_var2 1 12 + + 156 159 store_field 8 (_input_tokens) + + 159 160 load_var 10 (m) + 161 load_field 2 (output_tokens) + 162 store_var 13 (_28) + 163 load_var 13 (_28) + 164 narrow_bind 17 13 + 165 pop_jump_if_false -165 (to 0) + + 160 166 load_var2 1 13 + + 159 167 store_field 9 (_output_tokens) + 168 jump -168 (to 0) + + 147 169 load_var 5 (_11) + 170 store_var 6 (d) + + 149 171 load_type 3 + 172 load_var 1 (self) + 173 load_field 6 (_text) + 174 call 138 ntypeargs=1 (baml.String.from) + 175 store_var 7 (_13) + 176 load_type 3 + 177 load_var 6 (d) + 178 load_field 0 (text) + 179 call 138 ntypeargs=1 (baml.String.from) + 180 store_var 8 (_16) + 181 load_var2 1 7 + 182 load_var 8 (_16) + 183 bin_op + + 184 store_field 6 (_text) + + 150 185 load_var 6 (d) + 186 load_field 0 (text) + 187 jump +2 (to 189) + + 141 188 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 189 return +} + +function ai.stream.decode_sse_batch(batch: string) -> ai.stream.SseEvent[] { + 27 0 load_type 0 + 1 load_var 1 (batch) + 2 call 335 ntypeargs=1 (baml.json.from_string) + 3 return +} + +function ai.stream.from_spec(spec: ai.FunctionSpec<#1>, client: ai.stream.StreamingClient | null) -> ai.stream.Stream<#0, #1> { + 0 load_var 10 + 1 make_cell + 2 store_var 10 + 3 load_var 2 (client) + 4 load_const 0 () + 5 cmp_op == + 6 pop_jump_if_false +3 (to 9) + + 304 7 load_const 1 (null) + 8 store_var 2 (client) + + 306 9 load_type 2 + 10 load_var 1 (spec) + 11 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 12 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 13 unary_op ! + 14 pop_jump_if_false +2 (to 16) + 15 jump +71 (to 86) + + 311 16 load_var 2 (client) + 17 store_var 6 (_16) + 18 load_var 6 (_16) + 19 narrow_bind 3 6 + 20 pop_jump_if_false +2 (to 22) + 21 jump +20 (to 41) + + 314 22 load_var 1 (spec) + 23 load_field 4 (default_client) + 24 store_var 7 (_19) + 25 load_var 7 (_19) + 26 narrow_bind 3 7 + 27 pop_jump_if_false +2 (to 29) + 28 jump +10 (to 38) + + 318 29 load_var 1 (spec) + 30 load_field 4 (default_client) + 31 load_type 4 + 32 load_const 5 ("id") + 33 virtual_call nargs=1 ntypeargs=0 + 34 store_var 8 (_22) + + 317 35 load_var 8 (_22) + 36 init_instance 0 (ai.errors.StreamingUnsupported .client_id) + 37 throw + + 314 38 load_var 7 (_19) + 39 store_var 5 (selected) + 40 jump +3 (to 43) + + 311 41 load_var 6 (_16) + 42 store_var 5 (selected) + + 325 43 load_var 5 (selected) + 44 load_type 4 + 45 load_const 6 ("id") + 46 virtual_call nargs=1 ntypeargs=0 + 47 store_var 9 (provider) + + 330 48 load_var 1 (spec) + 49 load_field 2 (prompt_template) + 50 store_var 11 (_28) + + 331 51 load_type 2 + 52 load_var 1 (spec) + 53 call 784 ntypeargs=1 (ai.Journal.new) + 54 store_var 12 (_29) + + 332 55 load_type 2 + 56 load_var 1 (spec) + 57 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 58 store_var 13 (_31) + + 333 59 load_type 2 + 60 load_var 1 (spec) + 61 call 792 ntypeargs=1 (ai.FunctionSpec.output_type) + 62 store_var 14 (_33) + + 328 63 load_var2 5 11 + + 329 64 load_var2 12 13 + 65 load_var 14 (_33) + 66 init_instance 1 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) + 67 load_type 3 + 68 load_const 7 ("invoke_stream") + 69 virtual_call nargs=2 ntypeargs=0 + 70 store_deref 10 + + 346 71 load_type 8 + 72 load_type 2 + 73 call 425 ntypeargs=2 (baml.sap.__new_parse_cache) + 74 store_var 15 (_36) + + 340 75 load_type 8 + 76 load_type 2 + 77 load_var 10 (turns) + 78 make_closure 1735 captures=1 ntypeargs=2 + 79 load_var 15 (_36) + 80 load_const 9 ("") + 81 load_const 10 (false) + 82 load_type 8 + 83 load_type 2 + 84 init_instance 2 (ai.stream.Stream ._next_text, ._cache, ._text, ._finished) + 85 return + + 308 86 load_type 2 + 87 load_var 1 (spec) + 88 call 790 ntypeargs=1 (ai.FunctionSpec.name) + 89 store_var 4 (_12) + 90 load_type 11 + 91 load_var 4 (_12) + 92 call 138 ntypeargs=1 (baml.String.from) + 93 store_var 3 (_11) + 94 load_const 12 ("streaming does not run the tool loop yet: ") + 95 load_var 3 (_11) + 96 bin_op + + 97 load_const 13 (" has a non-empty toolbox") + 98 bin_op + + 99 init_instance 3 (baml.errors.InvalidArgument .message) + 100 throw +} + +function ai.tools.Tool.call(self: ai.tools.Tool, args: map) -> string { + 26 0 load_var 1 (self) + 1 load_field 4 (raw_handler) + 2 store_var 3 (_4) + 3 load_var 3 (_4) + 4 narrow_bind 0 3 + 5 pop_jump_if_false +2 (to 7) + 6 jump +63 (to 69) + + 29 7 load_var 1 (self) + 8 load_field 3 (handler) + 9 store_var 4 (_8) + 10 load_var 4 (_8) + 11 narrow_bind 1 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +13 (to 26) + + 37 14 load_type 2 + 15 load_var 1 (self) + 16 load_field 0 (name) + 17 call 138 ntypeargs=1 (baml.String.from) + 18 store_var 12 (_34) + 19 load_const 3 ("tool ") + 20 load_var 12 (_34) + 21 bin_op + + 22 load_const 4 (" has no handler") + 23 bin_op + + 24 init_instance 0 (baml.errors.InvalidArgument .message) + 25 throw + + 30 26 load_type 5 + 27 load_type 5 + + 29 28 load_var2 4 2 + 29 call 719 ntypeargs=2 (reflect.call_any) + 30 store_var 5 (value) + 31 jump +33 (to 64) + + 30 32 load_var 6 (e) + 33 store_var 7 (_15) + 34 load_var 7 (_15) + 35 narrow_bind 6 7 + 36 pop_jump_if_false +2 (to 38) + 37 jump +3 (to 40) + 38 load_var 6 (e) + 39 rethrow + 40 load_var 7 (_15) + 41 store_var 8 (bad) + + 32 42 load_type 2 + 43 load_var 1 (self) + 44 load_field 0 (name) + 45 call 138 ntypeargs=1 (baml.String.from) + 46 store_var 9 (_21) + 47 load_type 7 + 48 load_var 8 (bad) + 49 call 138 ntypeargs=1 (baml.String.from) + 50 store_var 11 (_25) + 51 load_type 2 + 52 load_var 11 (_25) + 53 call 138 ntypeargs=1 (baml.String.from) + 54 store_var 10 (_24) + 55 load_const 8 ("invalid arguments for ") + 56 load_var 9 (_21) + 57 bin_op + + 58 load_const 9 (": ") + 59 bin_op + + 60 load_var 10 (_24) + 61 bin_op + + 62 init_instance 1 (baml.errors.InvalidArgument .message) + 63 throw + + 35 64 load_type 5 + 65 load_var 5 (value) + 66 call 333 ntypeargs=1 (baml.json.to_json) + 67 call 330 ntypeargs=0 (baml.json.stringify) + 68 jump +3 (to 71) + + 27 69 load_var2 2 3 + + 26 70 call_indirect + 71 return +} + +function ai.tools.Toolbox.get(self: ai.tools.Toolbox, name: string) -> ai.tools.Tool | null { + 0 load_var 2 + 1 make_cell + 2 store_var 2 + + 112 3 load_type 0 + 4 load_type 1 + 5 load_var 1 (self) + 6 load_field 0 (entries) + 7 load_var 2 (name) + 8 make_closure 1655 1 + 9 call 19 ntypeargs=2 (baml.Array.find) + 10 return +} + +function ai.tools.Toolbox.is_empty(self: ai.tools.Toolbox) -> bool { + 118 0 load_var 1 (self) + 1 load_field 0 (entries) + 2 container_len + 3 store_var 2 (_2) + 4 load_var 2 (_2) + 5 load_const 0 (0) + 6 cmp_int_op == + 7 return +} + +function ai.tools.Toolbox.list(self: ai.tools.Toolbox) -> ai.tools.Tool[] { + 108 0 load_var 1 (self) + 1 load_field 0 (entries) + 2 return +} + +function ai.tools.Toolbox.new(tools: ai.tools.Tool[]) -> ai.tools.Toolbox { + 97 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (names) + + 98 3 load_var 1 (tools) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_3) + 8 load_var 3 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_4) + 13 load_var 4 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +24 (to 40) + 17 load_var 4 (_4) + 18 store_var 5 (t) + + 99 19 load_type 0 + 20 load_var2 2 5 + 21 load_field 0 (name) + 22 call 23 ntypeargs=1 (baml.Array.includes) + 23 pop_jump_if_false +2 (to 25) + 24 jump +6 (to 30) + + 102 25 load_var2 2 5 + 26 load_field 0 (name) + 27 call 4 ntypeargs=0 (baml.Array.push) + 28 pop 1 + 29 jump -21 (to 8) + + 100 30 load_type 0 + 31 load_var 5 (t) + 32 load_field 0 (name) + 33 call 138 ntypeargs=1 (baml.String.from) + 34 store_var 6 (_13) + 35 load_const 6 ("duplicate tool name: ") + 36 load_var 6 (_13) + 37 bin_op + + 38 init_instance 0 (baml.errors.InvalidArgument .message) + 39 throw + + 104 40 load_var 1 (tools) + 41 init_instance 1 (ai.tools.Toolbox .entries) + 42 return +} + +function ai.tools.raw_tool(name: string, description: string, input_schema: map, handler: (map) -> string throws unknown, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { + 0 load_var 5 (on_error) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 77 4 load_const 1 (null) + 5 store_var 5 (on_error) + + 79 6 load_var 1 (name) + 7 load_const 2 ("__baml_return_output") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +7 (to 17) + + 82 11 load_var2 1 2 + 12 load_var 3 (input_schema) + 13 load_const 1 (null) + 14 load_var2 4 5 + 15 init_instance 0 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) + 16 return + + 80 17 load_const 3 ("the tool name __baml_return_output is reserved") + 18 init_instance 1 (baml.errors.InvalidArgument .message) + 19 throw +} + +function ai.tools.tool(handler: baml.AnyFunction, name: string | null, description: string | null, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { + 0 load_var 2 (name) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 45 4 load_const 1 (null) + 5 store_var 2 (name) + 6 load_var 3 (description) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 46 10 load_const 1 (null) + 11 store_var 3 (description) + 12 load_var 4 (on_error) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 47 16 load_const 1 (null) + 17 store_var 4 (on_error) + + 49 18 load_var 1 (handler) + 19 call 718 ntypeargs=0 (reflect.signature) + 20 store_var 5 (sig) + + 50 21 load_var 2 (name) + 22 store_var 6 (resolved_name) + 23 load_var 2 (name) + 24 load_const 1 (null) + 25 cmp_op == + 26 pop_jump_if_false +4 (to 30) + 27 load_var 5 (sig) + 28 load_field 0 (name) + 29 store_var 6 (resolved_name) + + 51 30 load_var 6 (resolved_name) + 31 store_var 7 (_11) + 32 load_var 7 (_11) + 33 narrow_bind 2 7 + 34 pop_jump_if_false +2 (to 36) + 35 jump +4 (to 39) + + 64 36 load_const 3 ("anonymous tool needs a name") + 37 init_instance 0 (baml.errors.InvalidArgument .message) + 38 throw + + 51 39 load_var 7 (_11) + 40 store_var_load_var 8 (n) + + 52 41 load_const 4 ("__baml_return_output") + 42 cmp_op == + 43 pop_jump_if_false +2 (to 45) + 44 jump +27 (to 71) + + 57 45 load_var 3 (description) + 46 store_var 10 (_18) + 47 load_var 3 (description) + 48 load_const 1 (null) + 49 cmp_op == + 50 pop_jump_if_false +4 (to 54) + 51 load_var 5 (sig) + 52 load_field 5 (docstring) + 53 store_var 10 (_18) + 54 load_var 10 (_18) + 55 store_var 9 (_17) + 56 load_var 10 (_18) + 57 load_const 1 (null) + 58 cmp_op == + 59 pop_jump_if_false +3 (to 62) + 60 load_const 5 ("") + 61 store_var 9 (_17) + + 58 62 load_var 1 (handler) + 63 call 844 ntypeargs=0 (ai.internal._schema_for_signature) + 64 store_var 11 (_21) + + 56 65 load_var2 8 9 + 66 load_var2 11 1 + 67 load_const 1 (null) + 68 load_var 4 (on_error) + 69 init_instance 1 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) + 70 return + + 53 71 load_const 6 ("the tool name __baml_return_output is reserved") + 72 init_instance 2 (baml.errors.InvalidArgument .message) + 73 throw +} + +function ai.wire.render_output_format(t: type) -> string { + 37 0 load_var 1 (t) + 1 sys_op 420 (baml.prompt.render_output_format) + 2 return +} + +function ai.wire.send_as(req: baml.http.Request, provider: string) -> #0 { + 8 0 load_var 1 (req) + 1 load_const 0 () + 2 call 233 ntypeargs=0 (baml.http.send) + 3 store_var 3 (resp) + 4 jump +18 (to 22) + 5 load_var 4 (e) + 6 throw_if_panic + + 12 7 load_type 1 + 8 load_var 4 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 6 (_8) + 11 load_type 2 + 12 load_var 6 (_8) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 5 (_7) + + 10 15 load_var 2 (provider) + + 12 16 load_const 3 ("transport failed before a response arrived: ") + 17 load_var 5 (_7) + 18 bin_op + + 19 load_const 4 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 17 22 load_var 3 (resp) + 23 sys_op 221 (baml.http.Response.text) + 24 store_var 7 (text) + 25 jump +8 (to 33) + 26 load_var 8 (e) + 27 throw_if_panic + + 19 28 load_var 2 (provider) + 29 load_const 5 ("the response body could not be read completely") + 30 load_const 4 (null) + 31 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 32 throw + + 26 33 load_var 3 (resp) + 34 call 223 ntypeargs=0 (baml.http.Response.ok) + 35 unary_op ! + 36 pop_jump_if_false +2 (to 38) + 37 jump +11 (to 48) + + 29 38 load_type 6 + 39 load_var 7 (text) + 40 call 335 ntypeargs=1 (baml.json.from_string) + 41 jump +6 (to 47) + 42 load_var 9 (e) + 43 throw_if_panic + + 30 44 load_var2 2 7 + 45 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) + 46 throw + 47 return + + 27 48 load_var2 2 3 + 49 load_field 0 (status_code) + 50 load_var 7 (text) + 51 call 843 ntypeargs=0 (ai.errors.classify_http) + 52 throw +} + +function anthropic.AnthropicClient.ai.Client.id(self: anthropic.AnthropicClient) -> string { + 28 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 2 (_2) + 5 load_const 1 ("anthropic/") + 6 load_var 2 (_2) + 7 bin_op + + 8 return +} + +function anthropic.AnthropicClient.ai.Client.invoke(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 32 0 load_var2 1 2 + 1 call 871 ntypeargs=0 (anthropic.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 33 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function anthropic.AnthropicClient.ai.stream.StreamingClient.invoke_stream(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 40 0 load_var2 1 2 + 1 call 873 ntypeargs=0 (anthropic.internal.invoke_stream) + 2 return +} + +function anthropic.AnthropicClient.new(model: string, api_key: string | null, base_url: string | null, max_tokens: int) -> anthropic.AnthropicClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 13 4 load_const 1 ("claude-haiku-4-5") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 14 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 15 16 load_const 2 (null) + 17 store_var 3 (base_url) + 18 load_var 4 (max_tokens) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 16 22 load_const 3 (4096) + 23 store_var 4 (max_tokens) + + 18 24 load_var2 1 2 + 25 load_var2 3 4 + 26 init_instance 0 (anthropic.AnthropicClient .model, .api_key, .base_url, .max_tokens) + 27 return +} + +function anthropic.internal._anthropic_assistant_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse)[]) -> map[] { + 74 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 75 3 load_var 1 (content) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_3) + 8 load_var 3 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_4) + 13 load_var 4 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +81 (to 97) + 17 load_var 4 (_4) + 18 store_var 5 (b) + + 76 19 load_var 5 (b) + 20 store_var 6 (_8) + 21 load_var 6 (_8) + 22 narrow_bind 6 6 + 23 pop_jump_if_false +2 (to 25) + 24 jump +48 (to 72) + 25 load_var 5 (b) + 26 store_var 9 (_20) + 27 load_var 9 (_20) + 28 narrow_bind 7 9 + 29 pop_jump_if_false +2 (to 31) + 30 jump -22 (to 8) + 31 load_var 5 (b) + 32 store_var 10 (u) + + 88 33 load_type 8 + 34 load_type 9 + 35 alloc_map 0 + 36 store_var 11 (bb) + + 89 37 load_type 8 + 38 load_type 9 + 39 load_var 11 (bb) + 40 load_const 10 ("type") + 41 load_const 11 ("tool_use") + 42 call 37 ntypeargs=2 (baml.Map.set) + 43 pop 1 + + 90 44 load_type 8 + 45 load_type 9 + 46 load_var 11 (bb) + 47 load_const 12 ("id") + 48 load_var 10 (u) + 49 load_field 0 (id) + 50 call 37 ntypeargs=2 (baml.Map.set) + 51 pop 1 + + 91 52 load_type 8 + 53 load_type 9 + 54 load_var 11 (bb) + 55 load_const 13 ("name") + 56 load_var 10 (u) + 57 load_field 1 (name) + 58 call 37 ntypeargs=2 (baml.Map.set) + 59 pop 1 + + 92 60 load_type 8 + 61 load_type 9 + 62 load_var 11 (bb) + 63 load_const 14 ("input") + 64 load_var 10 (u) + 65 load_field 2 (args) + 66 call 37 ntypeargs=2 (baml.Map.set) + 67 pop 1 + + 93 68 load_var2 2 11 + 69 call 4 ntypeargs=0 (baml.Array.push) + 70 pop 1 + 71 jump -63 (to 8) + + 76 72 load_var 6 (_8) + 73 store_var 7 (t) + + 78 74 load_type 8 + 75 load_type 9 + 76 alloc_map 0 + 77 store_var 8 (bb) + + 79 78 load_type 8 + 79 load_type 9 + 80 load_var 8 (bb) + 81 load_const 15 ("type") + 82 load_const 16 ("text") + 83 call 37 ntypeargs=2 (baml.Map.set) + 84 pop 1 + + 80 85 load_type 8 + 86 load_type 9 + 87 load_var 8 (bb) + 88 load_const 17 ("text") + 89 load_var 7 (t) + 90 load_field 0 (text) + 91 call 37 ntypeargs=2 (baml.Map.set) + 92 pop 1 + + 81 93 load_var2 2 8 + 94 call 4 ntypeargs=0 (baml.Array.push) + 95 pop 1 + 96 jump -88 (to 8) + + 98 97 load_var 2 (out) + 98 return +} + +function anthropic.internal._anthropic_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 348 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 349 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +218 (to 235) + 18 load_var 4 (_5) + 19 store_var_load_var 5 (raw) + + 350 20 load_field 1 (data) + 21 store_var 6 (_10) + 22 load_var 6 (_10) + 23 narrow_bind 6 6 + 24 pop_jump_if_false -15 (to 9) + + 351 25 load_type 7 + + 350 26 load_var 6 (_10) + 27 call 335 ntypeargs=1 (baml.json.from_string) + 28 jump +4 (to 32) + + 351 29 load_var 7 (e) + 30 throw_if_panic + + 352 31 load_const 8 (null) + + 354 32 store_var 8 (_16) + 33 load_var 8 (_16) + 34 narrow_bind 9 8 + 35 pop_jump_if_false -26 (to 9) + 36 load_var 8 (_16) + 37 store_var 9 (event) + + 355 38 load_var 9 (event) + 39 load_field 0 (type) + 40 store_var 12 (_20) + 41 load_var 12 (_20) + 42 store_var 11 (_19) + 43 load_var 12 (_20) + 44 load_const 8 (null) + 45 cmp_op == + 46 pop_jump_if_false +4 (to 50) + 47 load_var 5 (raw) + 48 load_field 0 (event) + 49 store_var 11 (_19) + 50 load_var 11 (_19) + 51 store_var 10 (t) + 52 load_var 11 (_19) + 53 load_const 8 (null) + 54 cmp_op == + 55 pop_jump_if_false +3 (to 58) + 56 load_const 10 ("") + 57 store_var 10 (t) + + 356 58 load_var 10 (t) + 59 load_const 11 ("content_block_delta") + 60 cmp_op == + 61 pop_jump_if_false +2 (to 63) + 62 jump +139 (to 201) + + 372 63 load_var 10 (t) + 64 load_const 12 ("message_start") + 65 cmp_op == + 66 pop_jump_if_false +2 (to 68) + 67 jump +73 (to 140) + + 381 68 load_var 10 (t) + 69 load_const 13 ("message_delta") + 70 cmp_op == + 71 pop_jump_if_false +2 (to 73) + 72 jump +10 (to 82) + + 394 73 load_var 10 (t) + 74 load_const 14 ("message_stop") + 75 cmp_op == + 76 pop_jump_if_false -67 (to 9) + + 395 77 load_var 2 (out) + 78 alloc_instance 358 ntypeargs=0 (ai.stream.TurnDone) + 79 call 4 ntypeargs=0 (baml.Array.push) + 80 pop 1 + 81 jump -72 (to 9) + + 382 82 load_var 9 (event) + 83 load_field 1 (delta) + 84 load_const 8 (null) + 85 cmp_op == + 86 pop_jump_if_false +2 (to 88) + 87 jump +6 (to 93) + 88 load_var 9 (event) + 89 load_field 1 (delta) + 90 load_field 2 (2) + 91 store_var 21 (_65) + 92 jump +3 (to 95) + 93 load_const 8 (null) + 94 store_var 21 (_65) + 95 load_var 21 (_65) + 96 load_const 8 (null) + 97 cmp_op == + 98 pop_jump_if_false +2 (to 100) + 99 jump +5 (to 104) + 100 load_var 21 (_65) + 101 call 870 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) + 102 store_var 20 (stop) + 103 jump +3 (to 106) + + 383 104 load_const 8 (null) + 105 store_var 20 (stop) + + 388 106 load_var 20 (stop) + 107 store_var 22 (_74) + + 389 108 load_var 9 (event) + 109 load_field 3 (usage) + 110 load_const 8 (null) + 111 cmp_op == + 112 pop_jump_if_false +2 (to 114) + 113 jump +6 (to 119) + 114 load_var 9 (event) + 115 load_field 3 (usage) + 116 load_field 0 (0) + 117 store_var 23 (_75) + 118 jump +3 (to 121) + 119 load_const 8 (null) + 120 store_var 23 (_75) + + 390 121 load_var 9 (event) + 122 load_field 3 (usage) + 123 load_const 8 (null) + 124 cmp_op == + 125 pop_jump_if_false +2 (to 127) + 126 jump +6 (to 132) + 127 load_var 9 (event) + 128 load_field 3 (usage) + 129 load_field 1 (1) + 130 store_var 24 (_79) + 131 jump +3 (to 134) + 132 load_const 8 (null) + 133 store_var 24 (_79) + + 386 134 load_var2 2 22 + + 387 135 load_var2 23 24 + 136 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 137 call 4 ntypeargs=0 (baml.Array.push) + 138 pop 1 + 139 jump -130 (to 9) + + 376 140 load_var 9 (event) + 141 load_field 2 (message) + 142 load_const 8 (null) + 143 cmp_op == + 144 pop_jump_if_false +2 (to 146) + 145 jump +20 (to 165) + 146 load_var 9 (event) + 147 load_field 2 (message) + 148 load_field 0 (0) + 149 load_const 8 (null) + 150 cmp_op == + 151 pop_jump_if_false +2 (to 153) + 152 jump +13 (to 165) + 153 load_var 9 (event) + 154 load_field 2 (message) + 155 load_const 8 (null) + 156 cmp_op == + 157 pop_jump_if_false +2 (to 159) + 158 jump +7 (to 165) + 159 load_var 9 (event) + 160 load_field 2 (message) + 161 load_field 0 (0) + 162 load_field 0 (0) + 163 store_var 18 (_42) + 164 jump +3 (to 167) + 165 load_const 8 (null) + 166 store_var 18 (_42) + + 377 167 load_var 9 (event) + 168 load_field 2 (message) + 169 load_const 8 (null) + 170 cmp_op == + 171 pop_jump_if_false +2 (to 173) + 172 jump +20 (to 192) + 173 load_var 9 (event) + 174 load_field 2 (message) + 175 load_field 0 (0) + 176 load_const 8 (null) + 177 cmp_op == + 178 pop_jump_if_false +2 (to 180) + 179 jump +13 (to 192) + 180 load_var 9 (event) + 181 load_field 2 (message) + 182 load_const 8 (null) + 183 cmp_op == + 184 pop_jump_if_false +2 (to 186) + 185 jump +7 (to 192) + 186 load_var 9 (event) + 187 load_field 2 (message) + 188 load_field 0 (0) + 189 load_field 1 (1) + 190 store_var 19 (_52) + 191 jump +3 (to 194) + 192 load_const 8 (null) + 193 store_var 19 (_52) + + 373 194 load_var 2 (out) + + 374 195 load_const 8 (null) + 196 load_var2 18 19 + 197 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 198 call 4 ntypeargs=0 (baml.Array.push) + 199 pop 1 + 200 jump -191 (to 9) + + 357 201 load_var 9 (event) + 202 load_field 1 (delta) + 203 store_var 13 (_26) + 204 load_var 13 (_26) + 205 narrow_bind 15 13 + 206 pop_jump_if_false -197 (to 9) + 207 load_var 13 (_26) + 208 store_var 14 (d) + + 358 209 load_var 14 (d) + 210 load_field 0 (type) + 211 store_var 16 (_30) + 212 load_var 16 (_30) + 213 store_var 15 (_29) + 214 load_var 16 (_30) + 215 load_const 8 (null) + 216 cmp_op == + 217 pop_jump_if_false +3 (to 220) + 218 load_const 16 ("") + 219 store_var 15 (_29) + 220 load_var 15 (_29) + 221 load_const 17 ("text_delta") + 222 cmp_op == + 223 pop_jump_if_false -214 (to 9) + + 359 224 load_var 14 (d) + 225 load_field 1 (text) + 226 store_var 17 (_33) + 227 load_var 17 (_33) + 228 narrow_bind 6 17 + 229 pop_jump_if_false -220 (to 9) + + 360 230 load_var2 2 17 + + 359 231 init_instance 2 (ai.stream.TextDelta .text) + 232 call 4 ntypeargs=0 (baml.Array.push) + 233 pop 1 + 234 jump -225 (to 9) + + 409 235 load_var 2 (out) + 236 return +} + +function anthropic.internal._anthropic_lower_journal(j: ai.Journal) -> anthropic.internal.AnthropicMessage[] { + 131 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (msgs) + + 132 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +89 (to 106) + 18 load_var 4 (_5) + 19 store_var 5 (e) + + 133 20 load_var 5 (e) + 21 store_var 6 (_10) + 22 load_var 6 (_10) + 23 narrow_bind 6 6 + 24 pop_jump_if_false +2 (to 26) + 25 jump +50 (to 75) + 26 load_var 5 (e) + 27 store_var 9 (_24) + 28 load_var 9 (_24) + 29 narrow_bind 7 9 + 30 pop_jump_if_false +2 (to 32) + 31 jump +32 (to 63) + 32 load_var 5 (e) + 33 store_var 11 (_30) + 34 load_var 11 (_30) + 35 narrow_bind 8 11 + 36 pop_jump_if_false +2 (to 38) + 37 jump +16 (to 53) + 38 load_var 5 (e) + 39 store_var 13 (_35) + 40 load_var 13 (_35) + 41 narrow_bind 9 13 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 13 (_35) + 44 store_var 14 (f) + + 154 45 load_var2 2 14 + 46 load_field 0 (id) + 47 load_var 14 (f) + 48 load_field 1 (message) + 49 load_const 10 (true) + 50 call 866 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) + 51 pop 1 + 52 jump -43 (to 9) + + 133 53 load_var 11 (_30) + 54 store_var 12 (c) + + 152 55 load_var2 2 12 + 56 load_field 0 (id) + 57 load_var 12 (c) + 58 load_field 1 (output) + 59 load_const 11 (false) + 60 call 866 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) + 61 pop 1 + 62 jump -53 (to 9) + + 133 63 load_var 9 (_24) + 64 load_field 0 (content) + 65 call 865 ntypeargs=0 (anthropic.internal._anthropic_assistant_blocks) + 66 store_var 10 (_28) + + 142 67 load_var 2 (msgs) + + 143 68 load_const 12 ("assistant") + 69 load_const 11 (false) + 70 load_var 10 (_28) + 71 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 72 call 4 ntypeargs=0 (baml.Array.push) + 73 pop 1 + 74 jump -65 (to 9) + + 133 75 load_var 6 (_10) + 76 store_var 7 (m) + + 135 77 load_type 13 + 78 load_type 14 + 79 alloc_map 0 + 80 store_var 8 (block) + + 136 81 load_type 13 + 82 load_type 14 + 83 load_var 8 (block) + 84 load_const 15 ("type") + 85 load_const 16 ("text") + 86 call 37 ntypeargs=2 (baml.Map.set) + 87 pop 1 + + 137 88 load_type 13 + 89 load_type 14 + 90 load_var 8 (block) + 91 load_const 17 ("text") + 92 load_var 7 (m) + 93 load_field 0 (content) + 94 call 37 ntypeargs=2 (baml.Map.set) + 95 pop 1 + + 138 96 load_var 2 (msgs) + 97 load_const 18 ("user") + 98 load_const 11 (false) + 99 load_var 8 (block) + 100 load_type 19 + 101 alloc_array 1 + 102 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 103 call 4 ntypeargs=0 (baml.Array.push) + 104 pop 1 + 105 jump -96 (to 9) + + 158 106 load_var 2 (msgs) + 107 return +} + +function anthropic.internal._anthropic_lower_prompt(prompt: ai.Prompt) -> anthropic.internal.AnthropicPrompt { + 51 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (system) + + 52 3 load_type 1 + 4 alloc_array 0 + 5 store_var 3 (messages) + + 53 6 load_var 1 (prompt) + 7 call 787 ntypeargs=0 (ai.Prompt.messages) + 8 load_type 2 + 9 load_const 3 ("iter") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 load_type 4 + 14 load_const 5 ("next") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 5 (_6) + 17 load_var 5 (_6) + 18 is_type 6 + 19 pop_jump_if_false +2 (to 21) + 20 jump +52 (to 72) + 21 load_var 5 (_6) + 22 store_var 6 (message) + + 54 23 load_type 7 + 24 load_type 8 + 25 alloc_map 0 + 26 store_var 7 (block) + + 55 27 load_type 7 + 28 load_type 8 + 29 load_var 7 (block) + 30 load_const 9 ("type") + 31 load_const 10 ("text") + 32 call 37 ntypeargs=2 (baml.Map.set) + 33 pop 1 + + 56 34 load_type 7 + 35 load_type 8 + 36 load_var 7 (block) + 37 load_const 11 ("text") + 38 load_var 6 (message) + 39 load_field 1 (content) + 40 call 37 ntypeargs=2 (baml.Map.set) + 41 pop 1 + + 57 42 load_var 6 (message) + 43 load_field 0 (role) + 44 load_const 12 ("system") + 45 cmp_op == + 46 pop_jump_if_false +2 (to 48) + 47 jump +21 (to 68) + + 61 48 load_var 6 (message) + 49 load_field 0 (role) + 50 load_const 13 ("assistant") + 51 cmp_op == + 52 pop_jump_if_false +2 (to 54) + 53 jump +4 (to 57) + + 64 54 load_const 14 ("user") + 55 store_var 8 (role) + + 61 56 jump +3 (to 59) + + 62 57 load_const 15 ("assistant") + 58 store_var 8 (role) + + 66 59 load_var2 3 8 + 60 load_const 16 (false) + 61 load_var 7 (block) + 62 load_type 0 + 63 alloc_array 1 + 64 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 65 call 4 ntypeargs=0 (baml.Array.push) + 66 pop 1 + 67 jump -55 (to 12) + + 58 68 load_var2 2 7 + 69 call 4 ntypeargs=0 (baml.Array.push) + 70 pop 1 + 71 jump -59 (to 12) + + 70 72 load_var2 2 3 + 73 init_instance 1 (anthropic.internal.AnthropicPrompt .system, .messages) + 74 return +} + +function anthropic.internal._anthropic_push_tool_result(msgs: anthropic.internal.AnthropicMessage[], id: string, content: string, is_error: bool) -> null { + 108 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 5 (block) + + 109 4 load_type 0 + 5 load_type 1 + 6 load_var 5 (block) + 7 load_const 2 ("type") + 8 load_const 3 ("tool_result") + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 110 11 load_type 0 + 12 load_type 1 + 13 load_var 5 (block) + 14 load_const 4 ("tool_use_id") + 15 load_var 2 (id) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 111 18 load_type 0 + 19 load_type 1 + 20 load_var 5 (block) + 21 load_const 5 ("content") + 22 load_var 3 (content) + 23 call 37 ntypeargs=2 (baml.Map.set) + 24 pop 1 + + 112 25 load_type 0 + 26 load_type 1 + 27 load_var 5 (block) + 28 load_const 6 ("is_error") + 29 load_var 4 (is_error) + 30 call 37 ntypeargs=2 (baml.Map.set) + 31 pop 1 + + 114 32 load_var 1 (msgs) + 33 container_len + 34 store_var 6 (_20) + 35 load_type 7 + 36 load_var2 1 6 + 37 load_const 8 (1) + 38 sub_int + 39 call 3 ntypeargs=1 (baml.Array.at) + 40 store_var 7 (_22) + 41 load_var 7 (_22) + 42 narrow_bind 9 7 + 43 pop_jump_if_false +2 (to 45) + 44 jump +12 (to 56) + + 123 45 load_var 1 (msgs) + 46 load_const 10 ("user") + 47 load_const 11 (true) + 48 load_var 5 (block) + 49 load_type 12 + 50 alloc_array 1 + 51 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 52 call 4 ntypeargs=0 (baml.Array.push) + 53 pop 1 + + 124 54 load_const 13 (null) + + 114 55 jump +24 (to 79) + 56 load_var 7 (_22) + 57 store_var_load_var 8 (m) + + 115 58 load_field 1 (tool_results) + 59 pop_jump_if_false +2 (to 61) + 60 jump +12 (to 72) + + 119 61 load_var 1 (msgs) + 62 load_const 14 ("user") + 63 load_const 11 (true) + 64 load_var 5 (block) + 65 load_type 12 + 66 alloc_array 1 + 67 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 68 call 4 ntypeargs=0 (baml.Array.push) + 69 pop 1 + + 120 70 load_const 13 (null) + + 115 71 jump +8 (to 79) + + 116 72 load_type 12 + 73 load_var 8 (m) + 74 load_field 2 (blocks) + 75 load_var 5 (block) + 76 call 4 ntypeargs=1 (baml.Array.push) + 77 pop 1 + + 117 78 load_const 13 (null) + 79 return +} + +function anthropic.internal._anthropic_render_messages(msgs: anthropic.internal.AnthropicMessage[]) -> map[] { + 162 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 163 3 load_var 1 (msgs) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_3) + 8 load_var 3 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_4) + 13 load_var 4 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +27 (to 43) + 17 load_var 4 (_4) + 18 store_var 5 (m) + + 164 19 load_type 6 + 20 load_type 7 + 21 alloc_map 0 + 22 store_var 6 (mm) + + 165 23 load_type 6 + 24 load_type 7 + 25 load_var 6 (mm) + 26 load_const 8 ("role") + 27 load_var 5 (m) + 28 load_field 0 (role) + 29 call 37 ntypeargs=2 (baml.Map.set) + 30 pop 1 + + 166 31 load_type 6 + 32 load_type 7 + 33 load_var 6 (mm) + 34 load_const 9 ("content") + 35 load_var 5 (m) + 36 load_field 2 (blocks) + 37 call 37 ntypeargs=2 (baml.Map.set) + 38 pop 1 + + 167 39 load_var2 2 6 + 40 call 4 ntypeargs=0 (baml.Array.push) + 41 pop 1 + 42 jump -34 (to 8) + + 169 43 load_var 2 (out) + 44 return +} + +function anthropic.internal._anthropic_request(c: anthropic.AnthropicClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 182 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 4 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 4 (_5) + 7 call_indirect + + 183 8 call 864 ntypeargs=0 (anthropic.internal._anthropic_lower_prompt) + 9 store_var 5 (prompt_parts) + + 184 10 load_var 5 (prompt_parts) + 11 load_field 0 (system) + 12 store_var 6 (system) + + 185 13 load_var 5 (prompt_parts) + 14 load_field 1 (messages) + 15 store_var 7 (lowered) + + 186 16 load_var 2 (input) + 17 load_field 1 (journal) + 18 call 867 ntypeargs=0 (anthropic.internal._anthropic_lower_journal) + 19 load_type 0 + 20 load_const 1 ("iter") + 21 virtual_call nargs=1 ntypeargs=0 + 22 store_var 8 (_14) + 23 load_var 8 (_14) + 24 load_type 2 + 25 load_const 3 ("next") + 26 virtual_call nargs=1 ntypeargs=0 + 27 store_var 9 (_15) + 28 load_var 9 (_15) + 29 is_type 4 + 30 pop_jump_if_false +2 (to 32) + 31 jump +5 (to 36) + + 187 32 load_var2 7 9 + + 186 33 call 4 ntypeargs=0 (baml.Array.push) + 34 pop 1 + 35 jump -12 (to 23) + + 190 36 load_type 5 + 37 load_type 6 + 38 alloc_map 0 + 39 store_var 10 (body) + + 191 40 load_type 5 + 41 load_type 6 + 42 load_var 10 (body) + 43 load_const 7 ("model") + 44 load_var 1 (c) + 45 load_field 0 (model) + 46 call 37 ntypeargs=2 (baml.Map.set) + 47 pop 1 + + 192 48 load_type 5 + 49 load_type 6 + 50 load_var 10 (body) + 51 load_const 8 ("max_tokens") + 52 load_var 1 (c) + 53 load_field 3 (max_tokens) + 54 call 37 ntypeargs=2 (baml.Map.set) + 55 pop 1 + + 198 56 load_type 9 + 57 load_var 7 (lowered) + 58 load_const 10 (0) + 59 call 3 ntypeargs=1 (baml.Array.at) + 60 load_const 11 (null) + 61 cmp_op == + 62 pop_jump_if_false +2 (to 64) + 63 jump +8 (to 71) + 64 load_type 9 + 65 load_var 7 (lowered) + 66 load_const 10 (0) + 67 call 3 ntypeargs=1 (baml.Array.at) + 68 load_field 0 (0) + 69 store_var 12 (_31) + 70 jump +3 (to 73) + 71 load_const 11 (null) + 72 store_var 12 (_31) + 73 load_var 12 (_31) + 74 store_var 11 (first_role) + 75 load_var 12 (_31) + 76 load_const 11 (null) + 77 cmp_op == + 78 pop_jump_if_false +3 (to 81) + 79 load_const 12 ("") + 80 store_var 11 (first_role) + + 199 81 load_var 11 (first_role) + 82 load_const 13 ("user") + 83 cmp_op != + 84 jump_if_false +8 (to 92) + 85 pop 1 + 86 load_var 6 (system) + 87 container_len + 88 store_var 13 (_41) + 89 load_var 13 (_41) + 90 load_const 10 (0) + 91 cmp_int_op > + 92 pop_jump_if_false +2 (to 94) + 93 jump +26 (to 119) + + 204 94 load_var 6 (system) + 95 container_len + 96 store_var 15 (_54) + 97 load_var 15 (_54) + 98 load_const 10 (0) + 99 cmp_int_op > + 100 pop_jump_if_false +8 (to 108) + + 205 101 load_type 5 + 102 load_type 6 + 103 load_var 10 (body) + 104 load_const 14 ("system") + 105 load_var 6 (system) + 106 call 37 ntypeargs=2 (baml.Map.set) + 107 pop 1 + + 210 108 load_var 7 (lowered) + 109 call 868 ntypeargs=0 (anthropic.internal._anthropic_render_messages) + 110 store_var 16 (_60) + 111 load_type 5 + 112 load_type 6 + 113 load_var 10 (body) + 114 load_const 15 ("messages") + 115 load_var 16 (_60) + 116 call 37 ntypeargs=2 (baml.Map.set) + 117 pop 1 + 118 jump +19 (to 137) + + 201 119 load_type 9 + + 200 120 load_const 16 ("user") + 121 load_const 17 (false) + 122 load_var 6 (system) + 123 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 124 load_type 9 + 125 alloc_array 1 + + 201 126 load_var 7 (lowered) + 127 call 7 ntypeargs=1 (baml.Array.concat) + 128 call 868 ntypeargs=0 (anthropic.internal._anthropic_render_messages) + 129 store_var 14 (_45) + 130 load_type 5 + 131 load_type 6 + 132 load_var 10 (body) + 133 load_const 18 ("messages") + 134 load_var 14 (_45) + 135 call 37 ntypeargs=2 (baml.Map.set) + 136 pop 1 + + 213 137 load_var 2 (input) + 138 load_field 2 (toolbox) + 139 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 140 unary_op ! + 141 pop_jump_if_false +79 (to 220) + + 214 142 load_type 19 + 143 alloc_array 0 + 144 store_var 17 (tools) + + 215 145 load_var 2 (input) + 146 load_field 2 (toolbox) + 147 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 148 load_type 20 + 149 load_const 21 ("iter") + 150 virtual_call nargs=1 ntypeargs=0 + 151 store_var 18 (_70) + 152 load_var 18 (_70) + 153 load_type 22 + 154 load_const 23 ("next") + 155 virtual_call nargs=1 ntypeargs=0 + 156 store_var 19 (_71) + 157 load_var 19 (_71) + 158 is_type 4 + 159 pop_jump_if_false +2 (to 161) + 160 jump +35 (to 195) + 161 load_var 19 (_71) + 162 store_var 20 (t) + + 216 163 load_type 5 + 164 load_type 6 + 165 alloc_map 0 + 166 store_var 21 (tw) + + 217 167 load_type 5 + 168 load_type 6 + 169 load_var 21 (tw) + 170 load_const 24 ("name") + 171 load_var 20 (t) + 172 load_field 0 (name) + 173 call 37 ntypeargs=2 (baml.Map.set) + 174 pop 1 + + 218 175 load_type 5 + 176 load_type 6 + 177 load_var 21 (tw) + 178 load_const 25 ("description") + 179 load_var 20 (t) + 180 load_field 1 (description) + 181 call 37 ntypeargs=2 (baml.Map.set) + 182 pop 1 + + 219 183 load_type 5 + 184 load_type 6 + 185 load_var 21 (tw) + 186 load_const 26 ("input_schema") + 187 load_var 20 (t) + 188 load_field 2 (input_schema) + 189 call 37 ntypeargs=2 (baml.Map.set) + 190 pop 1 + + 220 191 load_var2 17 21 + 192 call 4 ntypeargs=0 (baml.Array.push) + 193 pop 1 + 194 jump -42 (to 152) + + 222 195 load_type 5 + 196 load_type 6 + 197 alloc_map 0 + 198 store_var 22 (tc) + + 223 199 load_type 5 + 200 load_type 6 + 201 load_var 22 (tc) + 202 load_const 27 ("type") + 203 load_const 28 ("auto") + 204 call 37 ntypeargs=2 (baml.Map.set) + 205 pop 1 + + 224 206 load_type 5 + 207 load_type 6 + 208 load_var 10 (body) + 209 load_const 29 ("tools") + 210 load_var 17 (tools) + 211 call 37 ntypeargs=2 (baml.Map.set) + 212 pop 1 + + 225 213 load_type 5 + 214 load_type 6 + 215 load_var 10 (body) + 216 load_const 30 ("tool_choice") + 217 load_var 22 (tc) + 218 call 37 ntypeargs=2 (baml.Map.set) + 219 pop 1 + + 231 220 load_var 3 (stream) + 221 pop_jump_if_false +8 (to 229) + + 232 222 load_type 5 + 223 load_type 6 + 224 load_var 10 (body) + 225 load_const 31 ("stream") + 226 load_const 32 (true) + 227 call 37 ntypeargs=2 (baml.Map.set) + 228 pop 1 + + 238 229 load_var 1 (c) + 230 load_field 2 (base_url) + 231 store_var 24 (_106) + 232 load_var 24 (_106) + 233 store_var 23 (base) + 234 load_var 24 (_106) + 235 load_const 11 (null) + 236 cmp_op == + 237 pop_jump_if_false +3 (to 240) + 238 load_const 33 ("https://api.anthropic.com") + 239 store_var 23 (base) + + 241 240 load_type 5 + 241 load_var 23 (base) + 242 call 138 ntypeargs=1 (baml.String.from) + 243 store_var 25 (_109) + + 243 244 load_var 1 (c) + 245 load_field 1 (api_key) + 246 store_var 27 (_114) + 247 load_var2 27 27 + 248 load_const 11 (null) + 249 cmp_op == + 250 pop_jump_if_false +3 (to 253) + 251 load_const 34 ("ANTHROPIC_API_KEY") + 252 call 211 ntypeargs=0 (baml.env.get_or_panic) + + 242 253 load_const 35 ("2023-06-01") + 254 load_const 36 ("application/json") + 255 load_const 37 ("x-api-key") + 256 load_const 38 ("anthropic-version") + 257 load_const 39 ("content-type") + 258 load_type 5 + 259 load_type 5 + 260 alloc_map 3 + 261 store_var 26 (_112) + + 247 262 load_type 19 + 263 load_var 10 (body) + 264 call 333 ntypeargs=1 (baml.json.to_json) + 265 call 330 ntypeargs=0 (baml.json.stringify) + 266 store_var 28 (_116) + + 239 267 load_const 40 ("POST") + + 241 268 load_var 25 (_109) + 269 load_const 41 ("/v1/messages") + 270 bin_op + + 271 load_var2 26 28 + 272 init_instance 1 (baml.http.Request .method, .url, .headers, .body) + 273 return +} + +function anthropic.internal._anthropic_stop_reason(s: string) -> ai.content.StopReason { + 253 0 load_var 1 (s) + 1 load_const 0 ("tool_use") + 2 cmp_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +20 (to 24) + + 255 5 load_var 1 (s) + 6 load_const 1 ("max_tokens") + 7 cmp_op == + 8 pop_jump_if_false +2 (to 10) + 9 jump +12 (to 21) + + 257 10 load_var 1 (s) + 11 load_const 2 ("refusal") + 12 cmp_op == + 13 pop_jump_if_false +2 (to 15) + 14 jump +4 (to 18) + + 260 15 load_const 3 (ai.content.StopReason.Complete) + 16 alloc_variant 436 (ai.content.StopReason) + + 257 17 jump +9 (to 26) + + 258 18 load_const 4 (ai.content.StopReason.Refused) + 19 alloc_variant 436 (ai.content.StopReason) + + 257 20 jump +6 (to 26) + + 256 21 load_const 5 (ai.content.StopReason.MaxTokens) + 22 alloc_variant 436 (ai.content.StopReason) + + 255 23 jump +3 (to 26) + + 254 24 load_const 6 (ai.content.StopReason.ToolUse) + 25 alloc_variant 436 (ai.content.StopReason) + 26 return +} + +function anthropic.internal.invoke(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 266 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 869 ntypeargs=0 (anthropic.internal._anthropic_request) + 3 store_var 3 (req) + + 267 4 load_type 1 + 5 load_var 3 (req) + 6 load_const 2 ("anthropic") + 7 call 804 ntypeargs=1 (ai.wire.send_as) + 8 store_var 4 (resp) + + 269 9 load_type 3 + 10 alloc_array 0 + 11 store_var 5 (content) + + 270 12 load_var 4 (resp) + 13 load_field 0 (content) + 14 load_type 4 + 15 load_const 5 ("iter") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 6 (_9) + 18 load_var 6 (_9) + 19 load_type 6 + 20 load_const 7 ("next") + 21 virtual_call nargs=1 ntypeargs=0 + 22 store_var 7 (_10) + 23 load_var 7 (_10) + 24 is_type 8 + 25 pop_jump_if_false +2 (to 27) + 26 jump +92 (to 118) + 27 load_var 7 (_10) + 28 store_var_load_var 8 (b) + + 271 29 load_field 0 (type) + 30 load_const 9 ("text") + 31 cmp_op == + 32 pop_jump_if_false +2 (to 34) + 33 jump +69 (to 102) + + 274 34 load_var 8 (b) + 35 load_field 0 (type) + 36 load_const 10 ("thinking") + 37 cmp_op == + 38 pop_jump_if_false +2 (to 40) + 39 jump +47 (to 86) + + 277 40 load_var 8 (b) + 41 load_field 0 (type) + 42 load_const 11 ("tool_use") + 43 cmp_op == + 44 pop_jump_if_false -26 (to 18) + + 281 45 load_var 8 (b) + 46 load_field 3 (id) + 47 store_var 14 (_34) + 48 load_var 14 (_34) + 49 store_var 13 (_33) + 50 load_var 14 (_34) + 51 load_const 12 (null) + 52 cmp_op == + 53 pop_jump_if_false +3 (to 56) + 54 load_const 13 ("") + 55 store_var 13 (_33) + + 282 56 load_var 8 (b) + 57 load_field 4 (name) + 58 store_var 16 (_37) + 59 load_var 16 (_37) + 60 store_var 15 (_36) + 61 load_var 16 (_37) + 62 load_const 12 (null) + 63 cmp_op == + 64 pop_jump_if_false +3 (to 67) + 65 load_const 14 ("") + 66 store_var 15 (_36) + + 283 67 load_var 8 (b) + 68 load_field 5 (input) + 69 store_var 18 (_40) + 70 load_var 18 (_40) + 71 store_var 17 (_39) + 72 load_var 18 (_40) + 73 load_const 12 (null) + 74 cmp_op == + 75 pop_jump_if_false +5 (to 80) + + 278 76 load_type 15 + 77 load_type 16 + 78 alloc_map 0 + 79 store_var 17 (_39) + + 279 80 load_var2 5 13 + + 280 81 load_var2 15 17 + 82 init_instance 0 (ai.content.ToolUse .id, .name, .args) + 83 call 4 ntypeargs=0 (baml.Array.push) + 84 pop 1 + 85 jump -67 (to 18) + + 275 86 load_var 8 (b) + 87 load_field 2 (thinking) + 88 store_var 12 (_26) + 89 load_var 12 (_26) + 90 store_var 11 (_25) + 91 load_var 12 (_26) + 92 load_const 12 (null) + 93 cmp_op == + 94 pop_jump_if_false +3 (to 97) + 95 load_const 17 ("") + 96 store_var 11 (_25) + 97 load_var2 5 11 + 98 init_instance 1 (ai.content.Reasoning .summary) + 99 call 4 ntypeargs=0 (baml.Array.push) + 100 pop 1 + 101 jump -83 (to 18) + + 272 102 load_var 8 (b) + 103 load_field 1 (text) + 104 store_var 10 (_19) + 105 load_var 10 (_19) + 106 store_var 9 (_18) + 107 load_var 10 (_19) + 108 load_const 12 (null) + 109 cmp_op == + 110 pop_jump_if_false +3 (to 113) + 111 load_const 18 ("") + 112 store_var 9 (_18) + 113 load_var2 5 9 + 114 init_instance 2 (ai.content.Text .text) + 115 call 4 ntypeargs=0 (baml.Array.push) + 116 pop 1 + 117 jump -99 (to 18) + + 292 118 load_var 4 (resp) + 119 load_field 1 (stop_reason) + 120 store_var_load_var 20 (_43) + 121 load_const 12 (null) + 122 cmp_op == + 123 pop_jump_if_false +2 (to 125) + 124 jump +5 (to 129) + 125 load_var 20 (_43) + 126 call 870 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) + 127 store_var 19 (stop) + 128 jump +4 (to 132) + + 293 129 load_const 19 (ai.content.StopReason.Complete) + 130 alloc_variant 436 (ai.content.StopReason) + 131 store_var 19 (stop) + + 297 132 load_var 4 (resp) + 133 load_field 2 (usage) + 134 store_var 22 (_49) + 135 load_var 22 (_49) + 136 narrow_bind 20 22 + 137 pop_jump_if_false +2 (to 139) + 138 jump +4 (to 142) + + 306 139 load_const 12 (null) + 140 store_var 21 (usage) + + 297 141 jump +10 (to 151) + 142 load_var 22 (_49) + 143 store_var_load_var 23 (u) + + 300 144 load_field 0 (input_tokens) + + 301 145 load_var 23 (u) + 146 load_field 1 (output_tokens) + 147 load_const 12 (null) + 148 load_const 12 (null) + 149 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 150 store_var 21 (usage) + + 309 151 load_var2 5 19 + 152 load_var 21 (usage) + 153 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 154 return +} + +function anthropic.internal.invoke_stream(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 415 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 869 ntypeargs=0 (anthropic.internal._anthropic_request) + + 416 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 420 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 418 15 load_const 3 ("anthropic") + + 420 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 425 22 load_const 6 (anthropic.internal._anthropic_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function assert.approx_equal(actual: float, expected: float, eps: float) -> null { + 77 0 load_var 3 (eps) + 1 load_const 0 (0.0) + 2 cmp_float_op < + 3 jump_if_false +2 (to 5) + 4 jump +4 (to 8) + 5 pop 1 + 6 load_var 3 (eps) + 7 call 95 ntypeargs=0 (baml.Float.is_nan) + 8 pop_jump_if_false +2 (to 10) + 9 jump +45 (to 54) + + 80 10 load_var2 1 2 + 11 sub_float + 12 call 98 ntypeargs=0 (baml.Float.abs) + 13 store_var 4 (delta) + + 81 14 load_var 4 (delta) + 15 call 95 ntypeargs=0 (baml.Float.is_nan) + 16 jump_if_false +2 (to 18) + 17 jump +4 (to 21) + 18 pop 1 + 19 load_var2 4 3 + 20 cmp_float_op > + 21 pop_jump_if_false +2 (to 23) + 22 jump +3 (to 25) + + 93 23 load_const 1 (null) + + 81 24 jump +32 (to 56) + + 84 25 load_var 4 (delta) + 26 call 779 ntypeargs=0 (assert.format_operand) + 27 store_var 5 (_18) + + 86 28 load_var 3 (eps) + 29 call 779 ntypeargs=0 (assert.format_operand) + 30 store_var 6 (_20) + + 88 31 load_var 1 (actual) + 32 call 779 ntypeargs=0 (assert.format_operand) + 33 store_var 7 (_21) + + 90 34 load_var 2 (expected) + 35 call 779 ntypeargs=0 (assert.format_operand) + 36 store_var 8 (_22) + + 84 37 load_const 2 ("assertion failed: |left - right| = ") + 38 load_var 5 (_18) + 39 bin_op + + 40 load_const 3 (", eps = ") + 41 bin_op + + 42 load_var 6 (_20) + 43 bin_op + + 44 load_const 4 (", left = ") + 45 bin_op + + 46 load_var 7 (_21) + 47 bin_op + + 48 load_const 5 (", right = ") + 49 bin_op + + 50 load_var 8 (_22) + 51 bin_op + + 52 call 260 ntypeargs=0 (baml.sys.panic) + 53 jump +3 (to 56) + + 78 54 load_const 6 ("assertion failed: epsilon must be a non-negative number") + 55 call 260 ntypeargs=0 (baml.sys.panic) + 56 return +} + +function assert.contains(haystack: string, needle: string) -> null { + 100 0 load_var2 1 2 + 1 call 147 ntypeargs=0 (baml.String.includes) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 103 5 load_const 0 (null) + + 100 6 jump +3 (to 9) + + 101 7 load_const 1 ("assertion failed: string does not contain expected substring") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function assert.equal(actual: unknown, expected: unknown) -> null { + 50 0 load_var2 1 2 + 1 call 635 ntypeargs=0 (baml.ops.equals_equals) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 58 5 load_const 0 (null) + + 50 6 jump +15 (to 21) + + 53 7 load_var 1 (actual) + 8 call 779 ntypeargs=0 (assert.format_operand) + 9 store_var 3 (_8) + + 55 10 load_var 2 (expected) + 11 call 779 ntypeargs=0 (assert.format_operand) + 12 store_var 4 (_9) + + 53 13 load_const 1 ("assertion failed: left = ") + 14 load_var 3 (_8) + 15 bin_op + + 16 load_const 2 (", right = ") + 17 bin_op + + 18 load_var 4 (_9) + 19 bin_op + + 20 call 260 ntypeargs=0 (baml.sys.panic) + 21 return +} + +function assert.format_operand(value: unknown) -> string { + 32 0 load_type 0 + 1 load_var 1 (value) + 2 call 138 ntypeargs=1 (baml.String.from) + 3 return +} + +function assert.is_true(condition: bool) -> null { + 5 0 load_var 1 (condition) + 1 unary_op ! + 2 pop_jump_if_false +2 (to 4) + 3 jump +3 (to 6) + + 8 4 load_const 0 (null) + + 5 5 jump +3 (to 8) + + 6 6 load_const 1 ("assertion failed: expected true") + 7 call 260 ntypeargs=0 (baml.sys.panic) + 8 return +} + +function assert.not_null(value: unknown | null) -> null { + 14 0 load_var 1 (value) + 1 load_const 0 (null) + 2 call 635 ntypeargs=0 (baml.ops.equals_equals) + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 17 5 load_const 0 (null) + + 14 6 jump +3 (to 9) + + 15 7 load_const 1 ("assertion failed: expected non-null value") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function boundary.LocalId.capture(self: boundary.LocalId, inputs: bool | null, output: bool | null, error: bool | null) -> boundary.LocalId { +} + +function boundary.id() -> boundary.LocalId { +} + +function boundary.id.current() -> string { +} + +function claude_code.ClaudeCodeClient.ai.Client.id(self: claude_code.ClaudeCodeClient) -> string { + 40 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 1 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 2 (_2) + 5 load_const 1 ("claude-code/") + 6 load_var 2 (_2) + 7 bin_op + + 8 return +} + +function claude_code.ClaudeCodeClient.ai.Client.invoke(self: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 44 0 load_var2 1 2 + 1 call 902 ntypeargs=0 (claude_code.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 45 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function claude_code.ClaudeCodeClient.new(model: string, executable: string, cwd: string | null, timeout_ms: int, permission_mode: string, harness_tools: string[], mcp_servers: map | null) -> claude_code.ClaudeCodeClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 18 4 load_const 1 ("haiku") + 5 store_var 1 (model) + 6 load_var 2 (executable) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 19 10 load_const 2 ("claude") + 11 store_var 2 (executable) + 12 load_var 3 (cwd) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 20 16 load_const 3 (null) + 17 store_var 3 (cwd) + 18 load_var 4 (timeout_ms) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 21 22 load_const 4 (240000) + 23 store_var 4 (timeout_ms) + 24 load_var 5 (permission_mode) + 25 load_const 0 () + 26 cmp_op == + 27 pop_jump_if_false +3 (to 30) + + 22 28 load_const 5 ("default") + 29 store_var 5 (permission_mode) + 30 load_var 6 (harness_tools) + 31 load_const 0 () + 32 cmp_op == + 33 pop_jump_if_false +4 (to 37) + + 23 34 load_type 6 + 35 alloc_array 0 + 36 store_var 6 (harness_tools) + 37 load_var 7 (mcp_servers) + 38 load_const 0 () + 39 cmp_op == + 40 pop_jump_if_false +3 (to 43) + + 24 41 load_const 3 (null) + 42 store_var 7 (mcp_servers) + + 34 43 load_var 7 (mcp_servers) + 44 store_var 8 (_16) + 45 load_var 7 (mcp_servers) + 46 load_const 3 (null) + 47 cmp_op == + 48 pop_jump_if_false +5 (to 53) + + 26 49 load_type 6 + 50 load_type 7 + 51 alloc_map 0 + 52 store_var 8 (_16) + + 27 53 load_var2 2 1 + 54 load_var2 3 4 + 55 load_var2 5 6 + 56 load_var 8 (_16) + 57 init_instance 0 (claude_code.ClaudeCodeClient .executable, .model, .cwd, .timeout_ms, .permission_mode, .harness_tools, .mcp_servers) + 58 return +} + +function claude_code.internal._log_cc_event(raw: baml.json.json) -> null { + 163 0 load_type 0 + 1 load_var 1 (raw) + 2 load_const 1 (".type") + 3 load_const 2 ("?") + 4 call 342 ntypeargs=1 (baml.json.path_or) + 5 store_var 2 (kind) + + 164 6 load_var 2 (kind) + 7 load_const 3 ("system") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +178 (to 188) + + 177 11 load_var 2 (kind) + 12 load_const 4 ("assistant") + 13 cmp_op == + 14 jump_if_false +2 (to 16) + 15 jump +5 (to 20) + 16 pop 1 + 17 load_var 2 (kind) + 18 load_const 5 ("user") + 19 cmp_op == + 20 pop_jump_if_false +2 (to 22) + 21 jump +23 (to 44) + + 195 22 load_var 2 (kind) + 23 load_const 6 ("result") + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +228 (to 254) + + 198 27 load_type 0 + 28 load_var 2 (kind) + 29 call 138 ntypeargs=1 (baml.String.from) + 30 store_var 23 (_83) + 31 load_const 7 ("$baml_log") + 32 load_const 8 ("info") + 33 load_const 9 ("cc event: ") + 34 load_var 23 (_83) + 35 bin_op + + 36 load_const 10 ("level") + 37 load_const 11 ("data") + 38 load_type 0 + 39 load_type 12 + 40 alloc_map 2 + 41 send_event + 42 pop 1 + 43 jump +211 (to 254) + + 178 44 load_type 0 + 45 alloc_array 0 + 46 store_var 9 (parts) + + 179 47 load_type 13 + 48 load_var 1 (raw) + 49 load_const 14 (".message.content") + 50 load_type 15 + 51 alloc_array 0 + 52 call 342 ntypeargs=1 (baml.json.path_or) + + 180 53 load_type 16 + 54 load_const 17 ("iter") + 55 virtual_call nargs=1 ntypeargs=0 + 56 store_var 10 (_35) + 57 load_var 10 (_35) + 58 load_type 18 + 59 load_const 19 ("next") + 60 virtual_call nargs=1 ntypeargs=0 + 61 store_var 11 (_36) + 62 load_var 11 (_36) + 63 is_type 20 + 64 pop_jump_if_false +2 (to 66) + 65 jump +91 (to 156) + 66 load_var 11 (_36) + 67 store_var 12 (b) + + 181 68 load_type 0 + 69 load_var 12 (b) + 70 load_const 21 (".type") + 71 load_const 22 ("?") + 72 call 342 ntypeargs=1 (baml.json.path_or) + 73 store_var 13 (bt) + + 182 74 load_var 13 (bt) + 75 load_const 23 ("text") + 76 cmp_op == + 77 pop_jump_if_false +2 (to 79) + 78 jump +60 (to 138) + 79 load_var 13 (bt) + 80 load_const 24 ("thinking") + 81 cmp_op == + 82 pop_jump_if_false +2 (to 84) + 83 jump +37 (to 120) + 84 load_var 13 (bt) + 85 load_const 25 ("tool_use") + 86 cmp_op == + 87 pop_jump_if_false +2 (to 89) + 88 jump +15 (to 103) + 89 load_var 13 (bt) + 90 load_const 26 ("tool_result") + 91 cmp_op == + 92 pop_jump_if_false +2 (to 94) + 93 jump +5 (to 98) + + 191 94 load_var2 9 13 + 95 call 4 ntypeargs=0 (baml.Array.push) + 96 pop 1 + 97 jump -40 (to 57) + + 190 98 load_var 9 (parts) + 99 load_const 27 ("tool_result") + 100 call 4 ntypeargs=0 (baml.Array.push) + 101 pop 1 + 102 jump -45 (to 57) + + 189 103 load_type 0 + 104 load_var 12 (b) + 105 load_const 28 (".name") + 106 load_const 29 ("?") + 107 call 342 ntypeargs=1 (baml.json.path_or) + 108 store_var 19 (_63) + 109 load_type 0 + 110 load_var 19 (_63) + 111 call 138 ntypeargs=1 (baml.String.from) + 112 store_var 18 (_62) + 113 load_var 9 (parts) + 114 load_const 30 ("tool_use: ") + 115 load_var 18 (_62) + 116 bin_op + + 117 call 4 ntypeargs=0 (baml.Array.push) + 118 pop 1 + 119 jump -62 (to 57) + + 186 120 load_type 0 + 121 load_var 12 (b) + 122 load_const 31 (".thinking") + 123 load_const 32 ("") + 124 call 342 ntypeargs=1 (baml.json.path_or) + 125 call 898 ntypeargs=0 (claude_code.internal._preview) + 126 store_var 17 (_55) + 127 load_type 0 + 128 load_var 17 (_55) + 129 call 138 ntypeargs=1 (baml.String.from) + 130 store_var 16 (_54) + + 185 131 load_var 9 (parts) + + 186 132 load_const 33 ("thinking: ") + 133 load_var 16 (_54) + 134 bin_op + + 135 call 4 ntypeargs=0 (baml.Array.push) + 136 pop 1 + 137 jump -80 (to 57) + + 183 138 load_type 0 + 139 load_var 12 (b) + 140 load_const 34 (".text") + 141 load_const 35 ("") + 142 call 342 ntypeargs=1 (baml.json.path_or) + 143 call 898 ntypeargs=0 (claude_code.internal._preview) + 144 store_var 15 (_47) + 145 load_type 0 + 146 load_var 15 (_47) + 147 call 138 ntypeargs=1 (baml.String.from) + 148 store_var 14 (_46) + 149 load_var 9 (parts) + 150 load_const 36 ("text: ") + 151 load_var 14 (_46) + 152 bin_op + + 153 call 4 ntypeargs=0 (baml.Array.push) + 154 pop 1 + 155 jump -98 (to 57) + + 194 156 load_type 0 + 157 load_var 2 (kind) + 158 call 138 ntypeargs=1 (baml.String.from) + 159 store_var 20 (_73) + 160 load_type 0 + 161 load_var 9 (parts) + 162 load_const 37 (" | ") + 163 call 15 ntypeargs=1 (baml.Array.join) + 164 store_var 22 (_77) + 165 load_type 0 + 166 load_var 22 (_77) + 167 call 138 ntypeargs=1 (baml.String.from) + 168 store_var 21 (_76) + 169 load_const 38 ("$baml_log") + 170 load_const 39 ("info") + 171 load_const 40 ("cc event: ") + 172 load_var 20 (_73) + 173 bin_op + + 174 load_const 41 (" [") + 175 bin_op + + 176 load_var 21 (_76) + 177 bin_op + + 178 load_const 42 ("]") + 179 bin_op + + 180 load_const 43 ("level") + 181 load_const 44 ("data") + 182 load_type 0 + 183 load_type 12 + 184 alloc_map 2 + 185 send_event + 186 pop 1 + 187 jump +67 (to 254) + + 165 188 load_type 0 + 189 load_var 1 (raw) + 190 load_const 45 (".subtype") + 191 load_const 46 ("?") + 192 call 342 ntypeargs=1 (baml.json.path_or) + 193 store_var 3 (subtype) + + 166 194 load_var 3 (subtype) + 195 load_const 47 ("thinking_tokens") + 196 cmp_op == + 197 pop_jump_if_false +2 (to 199) + 198 jump +32 (to 230) + + 174 199 load_type 0 + 200 load_var 3 (subtype) + 201 call 138 ntypeargs=1 (baml.String.from) + 202 store_var 6 (_19) + 203 load_type 0 + 204 load_var 1 (raw) + 205 load_const 48 (".model") + 206 load_const 49 ("?") + 207 call 342 ntypeargs=1 (baml.json.path_or) + 208 store_var 8 (_23) + 209 load_type 0 + 210 load_var 8 (_23) + 211 call 138 ntypeargs=1 (baml.String.from) + 212 store_var 7 (_22) + + 173 213 load_const 50 ("$baml_log") + 214 load_const 51 ("info") + + 174 215 load_const 52 ("cc event: system/") + 216 load_var 6 (_19) + 217 bin_op + + 218 load_const 53 (" model=") + 219 bin_op + + 220 load_var 7 (_22) + 221 bin_op + + 222 load_const 54 ("level") + 223 load_const 55 ("data") + 224 load_type 0 + 225 load_type 12 + 226 alloc_map 2 + + 173 227 send_event + 228 pop 1 + 229 jump +25 (to 254) + + 170 230 load_type 56 + 231 load_var 1 (raw) + 232 load_const 57 (".estimated_tokens") + 233 load_const 58 (0) + 234 call 342 ntypeargs=1 (baml.json.path_or) + 235 store_var 5 (_13) + 236 load_type 56 + 237 load_var 5 (_13) + 238 call 138 ntypeargs=1 (baml.String.from) + 239 store_var 4 (_12) + + 169 240 load_const 59 ("$baml_log") + 241 load_const 60 ("debug") + + 170 242 load_const 61 ("cc event: thinking ~") + 243 load_var 4 (_12) + 244 bin_op + + 245 load_const 62 (" tokens") + 246 bin_op + + 247 load_const 63 ("level") + 248 load_const 64 ("data") + 249 load_type 0 + 250 load_type 12 + 251 alloc_map 2 + + 169 252 send_event + 253 pop 1 + + 200 254 load_const 65 (null) + 255 return +} + +function claude_code.internal._preview(text: string) -> string { + 154 0 load_var 1 (text) + 1 call 139 ntypeargs=0 (baml.String.length) + 2 load_const 0 (120) + 3 cmp_int_op > + 4 pop_jump_if_false +2 (to 6) + 5 jump +3 (to 8) + + 157 6 load_var 1 (text) + + 154 7 jump +11 (to 18) + + 155 8 load_var 1 (text) + 9 load_const 1 (0) + 10 load_const 0 (120) + 11 call 153 ntypeargs=0 (baml.String.substring) + 12 store_var 2 (_5) + 13 load_type 2 + 14 load_var 2 (_5) + 15 call 138 ntypeargs=1 (baml.String.from) + 16 load_const 3 ("...") + 17 bin_op + + 18 return +} + +function claude_code.internal._read_result(p: baml.sys.Process) -> baml.json.json { + 127 0 load_const 0 (null) + 1 store_var 2 (result) + + 128 2 load_var 1 (p) + 3 load_field 0 (stdout) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_4) + 8 load_var 3 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_5) + 13 load_var 4 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +33 (to 49) + 17 load_var 4 (_5) + 18 call 144 ntypeargs=0 (baml.String.trim) + 19 store_var 5 (trimmed) + + 130 20 load_var 5 (trimmed) + 21 call 139 ntypeargs=0 (baml.String.length) + 22 load_const 6 (0) + 23 cmp_int_op > + 24 pop_jump_if_false -16 (to 8) + + 131 25 load_var 5 (trimmed) + 26 call 329 ntypeargs=0 (baml.json.parse) + 27 store_var 6 (raw) + 28 jump +7 (to 35) + 29 load_var 7 (e) + 30 throw_if_panic + + 133 31 load_const 7 ("claude-code") + 32 load_var 5 (trimmed) + 33 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) + 34 throw + + 136 35 load_var 6 (raw) + 36 call 899 ntypeargs=0 (claude_code.internal._log_cc_event) + 37 pop 1 + + 137 38 load_type 8 + 39 load_var 6 (raw) + 40 load_const 9 (".type") + 41 load_const 10 ("") + 42 call 342 ntypeargs=1 (baml.json.path_or) + 43 load_const 11 ("result") + 44 cmp_op == + 45 pop_jump_if_false -37 (to 8) + + 138 46 load_var 6 (raw) + 47 store_var 2 (result) + + 137 48 jump -40 (to 8) + + 144 49 load_var 2 (result) + 50 load_const 0 (null) + 51 call 635 ntypeargs=0 (baml.ops.equals_equals) + 52 pop_jump_if_false +2 (to 54) + 53 jump +3 (to 56) + + 150 54 load_var 2 (result) + 55 return + + 145 56 load_const 12 ("claude-code") + 57 load_const 13 ("the Claude Code CLI stream ended without a result event") + 58 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) + 59 throw +} + +function claude_code.internal._type_schema(t: string) -> map { + 89 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 2 (m) + + 90 4 load_type 0 + 5 load_type 1 + 6 load_var 2 (m) + 7 load_const 2 ("type") + 8 load_var 1 (t) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 91 11 load_var 2 (m) + 12 return +} + +function claude_code.internal.allowed_mcp_tools(c: claude_code.ClaudeCodeClient) -> string { + 219 0 load_type 0 + 1 load_type 1 + 2 load_var 1 (c) + 3 load_field 6 (mcp_servers) + 4 call 35 ntypeargs=2 (baml.Map.keys) + 5 store_var 3 (_3) + 6 load_type 0 + 7 load_type 0 + 8 load_type 2 + 9 load_var 3 (_3) + + 220 10 make_closure 2215 0 + 11 call 16 ntypeargs=3 (baml.Array.map) + 12 store_var 2 (_2) + + 219 13 load_type 0 + 14 load_var 2 (_2) + 15 load_const 3 (",") + 16 call 15 ntypeargs=1 (baml.Array.join) + 17 return +} + +function claude_code.internal.envelope_schema(output_type: type) -> map { + 52 0 load_var 1 (output_type) + 1 sys_op 343 (baml.json.schema) + 2 store_var 3 (_3) + 3 load_type 0 + 4 load_var 3 (_3) + 5 call 336 ntypeargs=1 (baml.json.from_json) + 6 store_var 2 (final_root) + + 53 7 load_type 1 + 8 load_type 2 + 9 load_var 2 (final_root) + 10 load_const 3 ("$defs") + 11 call 39 ntypeargs=2 (baml.Map.delete) + 12 store_var 4 (definitions) + + 54 13 load_type 1 + 14 load_type 2 + 15 alloc_map 0 + 16 store_var 5 (call_props) + + 55 17 load_const 4 ("string") + 18 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 19 store_var 6 (_10) + 20 load_type 1 + 21 load_type 2 + 22 load_var 5 (call_props) + 23 load_const 5 ("id") + 24 load_var 6 (_10) + 25 call 37 ntypeargs=2 (baml.Map.set) + 26 pop 1 + + 56 27 load_const 6 ("string") + 28 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 29 store_var 7 (_14) + 30 load_type 1 + 31 load_type 2 + 32 load_var 5 (call_props) + 33 load_const 7 ("name") + 34 load_var 7 (_14) + 35 call 37 ntypeargs=2 (baml.Map.set) + 36 pop 1 + + 57 37 load_const 8 ("object") + 38 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 39 store_var 8 (_18) + 40 load_type 1 + 41 load_type 2 + 42 load_var 5 (call_props) + 43 load_const 9 ("args") + 44 load_var 8 (_18) + 45 call 37 ntypeargs=2 (baml.Map.set) + 46 pop 1 + + 58 47 load_type 1 + 48 load_type 2 + 49 alloc_map 0 + 50 store_var 9 (call_item) + + 59 51 load_type 1 + 52 load_type 2 + 53 load_var 9 (call_item) + 54 load_const 10 ("type") + 55 load_const 11 ("object") + 56 call 37 ntypeargs=2 (baml.Map.set) + 57 pop 1 + + 60 58 load_type 1 + 59 load_type 2 + 60 load_var 9 (call_item) + 61 load_const 12 ("properties") + 62 load_var 5 (call_props) + 63 call 37 ntypeargs=2 (baml.Map.set) + 64 pop 1 + + 61 65 load_type 1 + 66 load_type 2 + 67 load_var 9 (call_item) + 68 load_const 13 ("required") + 69 load_const 14 ("id") + 70 load_const 15 ("name") + 71 load_const 16 ("args") + 72 load_type 1 + 73 alloc_array 3 + 74 call 37 ntypeargs=2 (baml.Map.set) + 75 pop 1 + + 62 76 load_type 1 + 77 load_type 2 + 78 load_var 9 (call_item) + 79 load_const 17 ("additionalProperties") + 80 load_const 18 (false) + 81 call 37 ntypeargs=2 (baml.Map.set) + 82 pop 1 + + 63 83 load_type 1 + 84 load_type 2 + 85 alloc_map 0 + 86 store_var 10 (calls_array) + + 64 87 load_type 1 + 88 load_type 2 + 89 load_var 10 (calls_array) + 90 load_const 19 ("type") + 91 load_const 20 ("array") + 92 call 37 ntypeargs=2 (baml.Map.set) + 93 pop 1 + + 65 94 load_type 1 + 95 load_type 2 + 96 load_var 10 (calls_array) + 97 load_const 21 ("items") + 98 load_var 9 (call_item) + 99 call 37 ntypeargs=2 (baml.Map.set) + 100 pop 1 + + 66 101 load_type 1 + 102 load_type 2 + 103 alloc_map 0 + 104 store_var 11 (calls_props) + + 67 105 load_type 1 + 106 load_type 2 + 107 load_var 11 (calls_props) + 108 load_const 22 ("calls") + 109 load_var 10 (calls_array) + 110 call 37 ntypeargs=2 (baml.Map.set) + 111 pop 1 + + 68 112 load_type 1 + 113 load_type 2 + 114 alloc_map 0 + 115 store_var 12 (calls_schema) + + 69 116 load_type 1 + 117 load_type 2 + 118 load_var 12 (calls_schema) + 119 load_const 23 ("type") + 120 load_const 24 ("object") + 121 call 37 ntypeargs=2 (baml.Map.set) + 122 pop 1 + + 70 123 load_type 1 + 124 load_type 2 + 125 load_var 12 (calls_schema) + 126 load_const 25 ("properties") + 127 load_var 11 (calls_props) + 128 call 37 ntypeargs=2 (baml.Map.set) + 129 pop 1 + + 71 130 load_type 1 + 131 load_type 2 + 132 load_var 12 (calls_schema) + 133 load_const 26 ("required") + 134 load_const 27 ("calls") + 135 load_type 1 + 136 alloc_array 1 + 137 call 37 ntypeargs=2 (baml.Map.set) + 138 pop 1 + + 72 139 load_type 1 + 140 load_type 2 + 141 load_var 12 (calls_schema) + 142 load_const 28 ("additionalProperties") + 143 load_const 18 (false) + 144 call 37 ntypeargs=2 (baml.Map.set) + 145 pop 1 + + 73 146 load_type 1 + 147 load_type 2 + 148 alloc_map 0 + 149 store_var 13 (outcome) + + 74 150 load_type 0 + 151 load_var 2 (final_root) + 152 call 333 ntypeargs=1 (baml.json.to_json) + 153 store_var 14 (_67) + 154 load_type 0 + 155 load_var 12 (calls_schema) + 156 call 333 ntypeargs=1 (baml.json.to_json) + 157 store_var 15 (_70) + 158 load_type 1 + 159 load_type 2 + 160 load_var 13 (outcome) + 161 load_const 29 ("anyOf") + 162 load_var2 14 15 + 163 load_type 30 + 164 alloc_array 2 + 165 call 37 ntypeargs=2 (baml.Map.set) + 166 pop 1 + + 75 167 load_type 1 + 168 load_type 2 + 169 alloc_map 0 + 170 store_var 16 (props) + + 76 171 load_type 1 + 172 load_type 2 + 173 load_var 16 (props) + 174 load_const 31 ("outcome") + 175 load_var 13 (outcome) + 176 call 37 ntypeargs=2 (baml.Map.set) + 177 pop 1 + + 77 178 load_type 1 + 179 load_type 2 + 180 alloc_map 0 + 181 store_var 17 (envelope) + + 78 182 load_type 1 + 183 load_type 2 + 184 load_var 17 (envelope) + 185 load_const 32 ("type") + 186 load_const 33 ("object") + 187 call 37 ntypeargs=2 (baml.Map.set) + 188 pop 1 + + 79 189 load_type 1 + 190 load_type 2 + 191 load_var 17 (envelope) + 192 load_const 34 ("properties") + 193 load_var 16 (props) + 194 call 37 ntypeargs=2 (baml.Map.set) + 195 pop 1 + + 80 196 load_type 1 + 197 load_type 2 + 198 load_var 17 (envelope) + 199 load_const 35 ("required") + 200 load_const 36 ("outcome") + 201 load_type 1 + 202 alloc_array 1 + 203 call 37 ntypeargs=2 (baml.Map.set) + 204 pop 1 + + 81 205 load_type 1 + 206 load_type 2 + 207 load_var 17 (envelope) + 208 load_const 37 ("additionalProperties") + 209 load_const 18 (false) + 210 call 37 ntypeargs=2 (baml.Map.set) + 211 pop 1 + + 82 212 load_var 4 (definitions) + 213 load_const 38 (null) + 214 call 635 ntypeargs=0 (baml.ops.equals_equals) + 215 unary_op ! + 216 pop_jump_if_false +8 (to 224) + + 83 217 load_type 1 + 218 load_type 2 + 219 load_var 17 (envelope) + 220 load_const 39 ("$defs") + 221 load_var 4 (definitions) + 222 call 37 ntypeargs=2 (baml.Map.set) + 223 pop 1 + + 85 224 load_var 17 (envelope) + 225 return +} + +function claude_code.internal.invoke(c: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 233 0 load_const 0 ("") + 1 load_var 2 (input) + 2 load_field 0 (prompt) + 3 call_indirect + 4 call 786 ntypeargs=0 (ai.Prompt.text) + 5 store_var 4 (instructions) + + 234 6 load_var 2 (input) + 7 load_field 2 (toolbox) + 8 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 9 unary_op ! + 10 store_var_load_var 5 (has_tools) + + 235 11 pop_jump_if_false +2 (to 13) + 12 jump +6 (to 18) + + 238 13 load_var 2 (input) + 14 load_field 3 (output_type) + 15 sys_op 343 (baml.json.schema) + 16 store_var 6 (schema) + 17 jump +9 (to 26) + + 236 18 load_var 2 (input) + 19 load_field 3 (output_type) + 20 call 894 ntypeargs=0 (claude_code.internal.envelope_schema) + 21 store_var 7 (_11) + 22 load_type 1 + 23 load_var 7 (_11) + 24 call 333 ntypeargs=1 (baml.json.to_json) + 25 store_var 6 (schema) + + 240 26 load_var 5 (has_tools) + 27 pop_jump_if_false +2 (to 29) + 28 jump +17 (to 45) + + 243 29 load_type 2 + 30 load_var 4 (instructions) + 31 call 138 ntypeargs=1 (baml.String.from) + 32 store_var 14 (_29) + 33 load_var 2 (input) + 34 load_field 1 (journal) + 35 call 893 ntypeargs=0 (claude_code.internal.transcript_text) + 36 store_var 16 (_33) + 37 load_type 2 + 38 load_var 16 (_33) + 39 call 138 ntypeargs=1 (baml.String.from) + 40 store_var 15 (_32) + 41 load_var2 14 15 + 42 bin_op + + 43 store_var 8 (prompt_text) + + 240 44 jump +26 (to 70) + + 241 45 load_type 2 + 46 load_var 4 (instructions) + 47 call 138 ntypeargs=1 (baml.String.from) + 48 store_var 9 (_18) + 49 load_var 2 (input) + 50 load_field 1 (journal) + 51 call 893 ntypeargs=0 (claude_code.internal.transcript_text) + 52 store_var 11 (_22) + 53 load_type 2 + 54 load_var 11 (_22) + 55 call 138 ntypeargs=1 (baml.String.from) + 56 store_var 10 (_21) + 57 load_var 2 (input) + 58 load_field 2 (toolbox) + 59 call 896 ntypeargs=0 (claude_code.internal.tool_protocol) + 60 store_var 13 (_26) + 61 load_type 2 + 62 load_var 13 (_26) + 63 call 138 ntypeargs=1 (baml.String.from) + 64 store_var 12 (_25) + 65 load_var2 9 10 + 66 bin_op + + 67 load_var 12 (_25) + 68 bin_op + + 69 store_var 8 (prompt_text) + + 247 70 load_type 2 + 71 load_var 1 (c) + 72 load_field 1 (model) + 73 call 138 ntypeargs=1 (baml.String.from) + 74 store_var 17 (_41) + 75 load_var 8 (prompt_text) + 76 call 139 ntypeargs=0 (baml.String.length) + 77 store_var 19 (_45) + 78 load_type 3 + 79 load_var 19 (_45) + 80 call 138 ntypeargs=1 (baml.String.from) + 81 store_var 18 (_44) + 82 load_var 2 (input) + 83 load_field 2 (toolbox) + 84 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 85 container_len + 86 store_var 21 (_48) + 87 load_type 3 + 88 load_var 21 (_48) + 89 call 138 ntypeargs=1 (baml.String.from) + 90 store_var 20 (_47) + + 246 91 load_const 4 ("$baml_log") + 92 load_const 5 ("info") + + 247 93 load_const 6 ("claude-code invoke: model=") + 94 load_var 17 (_41) + 95 bin_op + + 96 load_const 7 (" prompt_chars=") + 97 bin_op + + 98 load_var 18 (_44) + 99 bin_op + + 100 load_const 8 (" baml_tools=") + 101 bin_op + + 102 load_var 20 (_47) + 103 bin_op + + 104 load_const 9 ("level") + 105 load_const 10 ("data") + 106 load_type 2 + 107 load_type 11 + 108 alloc_map 2 + + 246 109 send_event + 110 pop 1 + + 249 111 load_type 2 + 112 alloc_array 0 + 113 store_var 22 (args) + + 250 114 load_var 22 (args) + 115 load_const 12 ("-p") + 116 call 4 ntypeargs=0 (baml.Array.push) + 117 pop 1 + + 251 118 load_var 22 (args) + 119 load_const 13 ("--output-format") + 120 call 4 ntypeargs=0 (baml.Array.push) + 121 pop 1 + + 252 122 load_var 22 (args) + 123 load_const 14 ("stream-json") + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + + 253 126 load_var 22 (args) + 127 load_const 15 ("--verbose") + 128 call 4 ntypeargs=0 (baml.Array.push) + 129 pop 1 + + 254 130 load_var 22 (args) + 131 load_const 16 ("--model") + 132 call 4 ntypeargs=0 (baml.Array.push) + 133 pop 1 + + 255 134 load_var2 22 1 + 135 load_field 1 (model) + 136 call 4 ntypeargs=0 (baml.Array.push) + 137 pop 1 + + 256 138 load_var 22 (args) + 139 load_const 17 ("--permission-mode") + 140 call 4 ntypeargs=0 (baml.Array.push) + 141 pop 1 + + 257 142 load_var2 22 1 + 143 load_field 4 (permission_mode) + 144 call 4 ntypeargs=0 (baml.Array.push) + 145 pop 1 + + 258 146 load_var 22 (args) + 147 load_const 18 ("--no-session-persistence") + 148 call 4 ntypeargs=0 (baml.Array.push) + 149 pop 1 + + 259 150 load_var 22 (args) + 151 load_const 19 ("--tools") + 152 call 4 ntypeargs=0 (baml.Array.push) + 153 pop 1 + + 260 154 load_type 2 + 155 load_var 1 (c) + 156 load_field 5 (harness_tools) + 157 load_const 20 (",") + 158 call 15 ntypeargs=1 (baml.Array.join) + 159 store_var 23 (_66) + 160 load_var2 22 23 + 161 call 4 ntypeargs=0 (baml.Array.push) + 162 pop 1 + + 267 163 load_var 1 (c) + 164 call 900 ntypeargs=0 (claude_code.internal.mcp_config_json) + 165 store_var 24 (_70) + 166 load_var 24 (_70) + 167 narrow_bind 21 24 + 168 pop_jump_if_false +27 (to 195) + 169 load_var 24 (_70) + 170 store_var 25 (mcp) + + 268 171 load_var 22 (args) + 172 load_const 22 ("--mcp-config") + 173 call 4 ntypeargs=0 (baml.Array.push) + 174 pop 1 + + 269 175 load_var2 22 25 + 176 call 4 ntypeargs=0 (baml.Array.push) + 177 pop 1 + + 270 178 load_var 22 (args) + 179 load_const 23 ("--strict-mcp-config") + 180 call 4 ntypeargs=0 (baml.Array.push) + 181 pop 1 + + 271 182 load_var 1 (c) + 183 call 901 ntypeargs=0 (claude_code.internal.allowed_mcp_tools) + 184 store_var 27 (_79) + 185 load_type 2 + 186 load_var 27 (_79) + 187 call 138 ntypeargs=1 (baml.String.from) + 188 store_var 26 (_78) + 189 load_var 22 (args) + 190 load_const 24 ("--allowedTools=") + 191 load_var 26 (_78) + 192 bin_op + + 193 call 4 ntypeargs=0 (baml.Array.push) + 194 pop 1 + + 273 195 load_var 22 (args) + 196 load_const 25 ("--json-schema") + 197 call 4 ntypeargs=0 (baml.Array.push) + 198 pop 1 + + 274 199 load_var 6 (schema) + 200 call 330 ntypeargs=0 (baml.json.stringify) + 201 store_var 28 (_83) + 202 load_var2 22 28 + 203 call 4 ntypeargs=0 (baml.Array.push) + 204 pop 1 + + 275 205 load_var2 22 8 + 206 call 4 ntypeargs=0 (baml.Array.push) + 207 pop 1 + + 278 208 load_var 1 (c) + 209 load_field 0 (executable) + + 279 210 load_var2 22 1 + + 280 211 load_field 2 (cwd) + 212 load_const 26 (null) + 213 load_var 1 (c) + 214 load_field 3 (timeout_ms) + 215 load_const 26 (null) + 216 load_const 26 (null) + 217 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) + 218 sys_op 256 (baml.sys.start_process) + 219 store_var 29 (p) + 220 jump +18 (to 238) + + 277 221 load_var 30 (e) + 222 throw_if_panic + + 285 223 load_type 27 + 224 load_var 30 (e) + 225 call 138 ntypeargs=1 (baml.String.from) + 226 store_var 32 (_97) + 227 load_type 2 + 228 load_var 32 (_97) + 229 call 138 ntypeargs=1 (baml.String.from) + 230 store_var 31 (_96) + + 283 231 load_const 28 ("claude-code") + + 285 232 load_const 29 ("the Claude Code CLI could not start: ") + 233 load_var 31 (_96) + 234 bin_op + + 235 load_const 26 (null) + 236 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 237 throw + + 294 238 load_var 29 (p) + 239 sys_op 251 (baml.sys.Process.close_stdin) + 240 pop 1 + 241 jump +3 (to 244) + 242 load_var 35 (e) + 243 throw_if_panic + + 299 244 load_var 29 (p) + 245 call 897 ntypeargs=0 (claude_code.internal._read_result) + 246 store_var 36 (result) + + 300 247 load_var 29 (p) + 248 sys_op 252 (baml.sys.Process.wait) + 249 store_var 37 (exit) + 250 jump +18 (to 268) + 251 load_var 38 (e) + 252 throw_if_panic + + 304 253 load_type 30 + 254 load_var 38 (e) + 255 call 138 ntypeargs=1 (baml.String.from) + 256 store_var 40 (_111) + 257 load_type 2 + 258 load_var 40 (_111) + 259 call 138 ntypeargs=1 (baml.String.from) + 260 store_var 39 (_110) + + 302 261 load_const 31 ("claude-code") + + 304 262 load_const 32 ("the Claude Code CLI did not terminate cleanly: ") + 263 load_var 39 (_110) + 264 bin_op + + 265 load_const 26 (null) + 266 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 267 throw + + 309 268 load_var 37 (exit) + 269 call 245 ntypeargs=0 (baml.sys.ProcessExit.ok) + 270 unary_op ! + 271 pop_jump_if_false +2 (to 273) + 272 jump +248 (to 520) + + 318 273 load_type 33 + 274 load_var 36 (result) + 275 load_const 34 (".is_error") + 276 load_const 35 (false) + 277 call 342 ntypeargs=1 (baml.json.path_or) + 278 pop_jump_if_false +2 (to 280) + 279 jump +228 (to 507) + + 326 280 load_type 2 + 281 load_var 36 (result) + 282 load_const 36 (".subtype") + 283 load_const 37 ("?") + 284 call 342 ntypeargs=1 (baml.json.path_or) + 285 store_var 45 (_136) + 286 load_type 2 + 287 load_var 45 (_136) + 288 call 138 ntypeargs=1 (baml.String.from) + 289 store_var 44 (_135) + 290 load_type 38 + 291 load_var 36 (result) + 292 load_const 39 (".total_cost_usd") + 293 load_const 40 (0.0) + 294 call 342 ntypeargs=1 (baml.json.path_or) + 295 store_var 47 (_141) + 296 load_type 38 + 297 load_var 47 (_141) + 298 call 138 ntypeargs=1 (baml.String.from) + 299 store_var 46 (_140) + 300 load_type 2 + 301 load_var 36 (result) + 302 load_const 41 (".session_id") + 303 load_const 42 ("?") + 304 call 342 ntypeargs=1 (baml.json.path_or) + 305 store_var 49 (_146) + 306 load_type 2 + 307 load_var 49 (_146) + 308 call 138 ntypeargs=1 (baml.String.from) + 309 store_var 48 (_145) + + 325 310 load_const 43 ("$baml_log") + 311 load_const 44 ("info") + + 326 312 load_const 45 ("claude-code result: subtype=") + 313 load_var 44 (_135) + 314 bin_op + + 315 load_const 46 (" cost_usd=") + 316 bin_op + + 317 load_var 46 (_140) + 318 bin_op + + 319 load_const 47 (" session=") + 320 bin_op + + 321 load_var 48 (_145) + 322 bin_op + + 323 load_const 48 ("level") + 324 load_const 49 ("data") + 325 load_type 2 + 326 load_type 11 + 327 alloc_map 2 + + 325 328 send_event + 329 pop 1 + + 328 330 load_type 50 + 331 load_var 36 (result) + 332 load_const 51 (".structured_output") + 333 call 341 ntypeargs=1 (baml.json.path) + 334 store_var 50 (structured) + 335 jump +20 (to 355) + 336 load_var 51 (e) + 337 throw_if_panic + + 330 338 load_type 2 + 339 load_var 36 (result) + 340 load_const 52 (".result") + 341 load_const 53 ("") + 342 call 342 ntypeargs=1 (baml.json.path_or) + 343 call 329 ntypeargs=0 (baml.json.parse) + 344 store_var 50 (structured) + 345 jump +10 (to 355) + 346 load_var 52 (inner) + 347 throw_if_panic + + 334 348 load_var 36 (result) + 349 call 330 ntypeargs=0 (baml.json.stringify) + 350 store_var 53 (_159) + + 332 351 load_const 54 ("claude-code") + 352 load_var 53 (_159) + 353 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) + 354 throw + + 342 355 load_type 3 + 356 load_var 36 (result) + 357 load_const 55 (".usage.input_tokens") + 358 load_const 56 (0) + 359 call 342 ntypeargs=1 (baml.json.path_or) + 360 store_var 54 (_162) + + 343 361 load_type 3 + 362 load_var 36 (result) + 363 load_const 57 (".usage.output_tokens") + 364 load_const 56 (0) + 365 call 342 ntypeargs=1 (baml.json.path_or) + 366 store_var 55 (_165) + + 344 367 load_type 58 + 368 load_var 36 (result) + 369 load_const 59 (".usage.cache_read_input_tokens") + 370 load_const 26 (null) + 371 call 342 ntypeargs=1 (baml.json.path_or) + 372 store_var 56 (_168) + + 348 373 load_type 60 + 374 alloc_array 0 + 375 store_var 57 (content) + + 349 376 load_const 56 (ai.content.StopReason.Complete) + 377 alloc_variant 436 (ai.content.StopReason) + 378 store_var 58 (stop) + + 350 379 load_var 5 (has_tools) + 380 pop_jump_if_false +2 (to 382) + 381 jump +9 (to 390) + + 378 382 load_var 50 (structured) + 383 call 330 ntypeargs=0 (baml.json.stringify) + 384 store_var 74 (_227) + 385 load_var2 57 74 + 386 init_instance 4 (ai.content.Text .text) + 387 call 4 ntypeargs=0 (baml.Array.push) + 388 pop 1 + 389 jump +106 (to 495) + + 351 390 load_type 50 + 391 load_var 36 (result) + 392 load_const 61 (".structured_output.outcome") + 393 load_var 50 (structured) + 394 call 342 ntypeargs=1 (baml.json.path_or) + 395 store_var 59 (outcome) + + 352 396 load_type 62 + 397 load_var 59 (outcome) + 398 load_const 63 (".calls") + 399 load_const 26 (null) + 400 call 342 ntypeargs=1 (baml.json.path_or) + + 353 401 store_var 60 (_181) + 402 load_var 60 (_181) + 403 narrow_bind 64 60 + 404 pop_jump_if_false +2 (to 406) + 405 jump +9 (to 414) + + 375 406 load_var 59 (outcome) + 407 call 330 ntypeargs=0 (baml.json.stringify) + 408 store_var 73 (_223) + 409 load_var2 57 73 + 410 init_instance 5 (ai.content.Text .text) + 411 call 4 ntypeargs=0 (baml.Array.push) + 412 pop 1 + 413 jump +82 (to 495) + + 354 414 load_const 56 (0) + 415 store_var 61 (i) + + 353 416 load_var 60 (_181) + 417 load_type 65 + 418 load_const 66 ("iter") + 419 virtual_call nargs=1 ntypeargs=0 + 420 store_var 62 (_185) + + 355 421 load_var 62 (_185) + 422 load_type 67 + 423 load_const 68 ("next") + 424 virtual_call nargs=1 ntypeargs=0 + 425 store_var 63 (_186) + 426 load_var 63 (_186) + 427 is_type 69 + 428 pop_jump_if_false +2 (to 430) + 429 jump +63 (to 492) + 430 load_var 63 (_186) + 431 store_var 64 (raw_call) + + 359 432 load_var 2 (input) + 433 load_field 1 (journal) + 434 call 783 ntypeargs=0 (ai.Journal.entries) + 435 container_len + 436 store_var 67 (_196) + 437 load_type 3 + 438 load_var 67 (_196) + 439 call 138 ntypeargs=1 (baml.String.from) + 440 store_var 66 (_195) + 441 load_type 3 + 442 load_var 61 (i) + 443 call 138 ntypeargs=1 (baml.String.from) + 444 store_var 68 (_200) + + 356 445 load_type 2 + + 357 446 load_var 64 (raw_call) + 447 load_const 70 (".id") + + 359 448 load_const 71 ("cc_call_") + 449 load_var 66 (_195) + 450 bin_op + + 451 load_const 72 ("_") + 452 bin_op + + 453 load_var 68 (_200) + 454 bin_op + + 455 call 342 ntypeargs=1 (baml.json.path_or) + 456 store_var 65 (id) + + 361 457 load_type 2 + 458 load_var 64 (raw_call) + 459 load_const 73 (".name") + 460 load_const 74 ("") + 461 call 342 ntypeargs=1 (baml.json.path_or) + 462 store_var 69 (name) + + 363 463 load_type 50 + 464 load_var 64 (raw_call) + 465 load_const 75 (".args") + 466 load_type 2 + 467 load_type 50 + 468 alloc_map 0 + 469 call 342 ntypeargs=1 (baml.json.path_or) + 470 store_var 72 (_209) + + 362 471 load_type 1 + 472 load_var 72 (_209) + 473 call 336 ntypeargs=1 (baml.json.from_json) + 474 store_var 70 (call_args) + 475 jump +7 (to 482) + 476 load_var 71 (e) + 477 throw_if_panic + + 366 478 load_type 2 + 479 load_type 11 + 480 alloc_map 0 + 481 store_var 70 (call_args) + + 370 482 load_var2 57 65 + 483 load_var2 69 70 + 484 init_instance 6 (ai.content.ToolUse .id, .name, .args) + 485 call 4 ntypeargs=0 (baml.Array.push) + 486 pop 1 + + 371 487 load_var 61 (i) + 488 load_const 21 (1) + 489 add_int + 490 store_var 61 (i) + + 355 491 jump -70 (to 421) + + 373 492 load_const 21 (ai.content.StopReason.ToolUse) + 493 alloc_variant 436 (ai.content.StopReason) + 494 store_var 58 (stop) + + 380 495 load_var2 57 58 + + 341 496 load_var2 54 55 + 497 load_var 56 (_168) + 498 load_const 26 (null) + 499 init_instance 7 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 500 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) + 501 store_var 3 (_0) + + 291 502 load_var 29 (p) + 503 sys_op 254 (baml.sys.Process.close) + 504 pop 1 + 505 load_var 3 (_0) + 506 return + + 321 507 load_type 2 + 508 load_var 36 (result) + 509 load_const 76 (".subtype") + 510 load_const 77 ("error") + 511 call 342 ntypeargs=1 (baml.json.path_or) + 512 store_var 42 (_125) + + 322 513 load_var 36 (result) + 514 call 330 ntypeargs=0 (baml.json.stringify) + 515 store_var 43 (_128) + + 319 516 load_const 78 ("claude-code") + 517 load_var2 42 43 + 518 init_instance 9 (ai.errors.Refused .provider, .reason, .raw_body) + 519 throw + + 313 520 load_type 3 + 521 load_var 37 (exit) + 522 load_field 0 (exit_code) + 523 call 138 ntypeargs=1 (baml.String.from) + 524 store_var 41 (_118) + 525 jump +6 (to 531) + + 291 526 load_var 29 (p) + 527 sys_op 254 (baml.sys.Process.close) + 528 pop 1 + + 227 529 load_var 33 (_100) + 530 rethrow + + 310 531 load_const 79 ("claude-code") + 532 load_const 26 (null) + + 313 533 load_const 80 ("the Claude Code CLI exited with code ") + 534 load_var 41 (_118) + 535 bin_op + + 536 load_const 26 (null) + 537 init_instance 10 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + 538 throw +} + +function claude_code.internal.mcp_config_json(c: claude_code.ClaudeCodeClient) -> string | null { + 207 0 load_var 1 (c) + 1 load_field 6 (mcp_servers) + 2 container_len + 3 store_var 2 (_3) + 4 load_var 2 (_3) + 5 load_const 0 (0) + 6 cmp_int_op == + 7 pop_jump_if_false +2 (to 9) + 8 jump +18 (to 26) + + 210 9 load_type 1 + 10 load_type 2 + 11 alloc_map 0 + 12 store_var 3 (wrapper) + + 211 13 load_type 1 + 14 load_type 2 + 15 load_var 3 (wrapper) + 16 load_const 3 ("mcpServers") + 17 load_var 1 (c) + 18 load_field 6 (mcp_servers) + 19 call 37 ntypeargs=2 (baml.Map.set) + 20 pop 1 + + 212 21 load_type 4 + 22 load_var 3 (wrapper) + 23 call 333 ntypeargs=1 (baml.json.to_json) + 24 call 330 ntypeargs=0 (baml.json.stringify) + 25 jump +2 (to 27) + + 208 26 load_const 5 (null) + 27 return +} + +function claude_code.internal.tool_protocol(tb: ai.tools.Toolbox) -> string { + 99 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (catalog) + + 100 3 load_var 1 (tb) + 4 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +40 (to 57) + 18 load_var 4 (_5) + 19 store_var 5 (t) + + 102 20 load_type 0 + 21 load_var 5 (t) + 22 load_field 0 (name) + 23 call 138 ntypeargs=1 (baml.String.from) + 24 store_var 6 (_16) + 25 load_type 0 + 26 load_var 5 (t) + 27 load_field 1 (description) + 28 call 138 ntypeargs=1 (baml.String.from) + 29 store_var 7 (_19) + 30 load_type 6 + 31 load_var 5 (t) + 32 load_field 2 (input_schema) + 33 call 333 ntypeargs=1 (baml.json.to_json) + 34 call 330 ntypeargs=0 (baml.json.stringify) + 35 store_var 9 (_23) + 36 load_type 0 + 37 load_var 9 (_23) + 38 call 138 ntypeargs=1 (baml.String.from) + 39 store_var 8 (_22) + + 101 40 load_var 2 (catalog) + + 102 41 load_const 7 ("{\"name\": \"") + 42 load_var 6 (_16) + 43 bin_op + + 44 load_const 8 ("\", \"description\": \"") + 45 bin_op + + 46 load_var 7 (_19) + 47 bin_op + + 48 load_const 9 ("\", \"parameters\": ") + 49 bin_op + + 50 load_var 8 (_22) + 51 bin_op + + 52 load_const 10 ("}") + 53 bin_op + + 54 call 4 ntypeargs=0 (baml.Array.push) + 55 pop 1 + 56 jump -47 (to 9) + + 121 57 load_type 0 + 58 load_var 2 (catalog) + 59 load_const 11 (", ") + 60 call 15 ntypeargs=1 (baml.Array.join) + 61 store_var 11 (_30) + + 105 62 load_type 0 + 63 load_var 11 (_30) + 64 call 138 ntypeargs=1 (baml.String.from) + 65 store_var 10 (_29) + 66 load_const 12 ("\n\nThe output contract is one object with an outcome field. Set outcome\nto either the final result or a tool request. The tools in the catalog\nbelow are NOT installed in your environment — never attempt to invoke\nthem directly; any such attempt fails. The ONLY way to run one is to\nfinish your reply with outcome set to\n{\"calls\": [{\"id\": \"\", \"name\": \"\", \"args\": {...}}]};\nthe caller executes the calls and re-invokes you with their results in\nthe conversation. If the Conversation so far section shows no tool\nresults yet, your outcome MUST be a calls request — never invent data a\ntool can provide. After tool results appear in the conversation, use\nthem; the Conversation so far section is authoritative. A tool result\nwith is_error=false means that call already ran — never repeat the same\nsuccessful tool call. Request only tools that are still necessary, or\nreturn the final result.\n\nApplication tool catalog (request via outcome.calls only):\n[") + 67 load_var 10 (_29) + 68 bin_op + + 69 load_const 13 ("]") + 70 bin_op + + 71 return +} + +function claude_code.internal.transcript_text(j: ai.Journal) -> string { + 7 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (lines) + + 8 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +163 (to 180) + 18 load_var 4 (_5) + 19 store_var 5 (e) + + 9 20 load_var 5 (e) + 21 store_var 6 (_9) + 22 load_var 6 (_9) + 23 narrow_bind 6 6 + 24 pop_jump_if_false +2 (to 26) + 25 jump +143 (to 168) + 26 load_var 5 (e) + 27 store_var 8 (_16) + 28 load_var 8 (_16) + 29 narrow_bind 7 8 + 30 pop_jump_if_false +2 (to 32) + 31 jump +58 (to 89) + 32 load_var 5 (e) + 33 store_var 20 (_52) + 34 load_var 20 (_52) + 35 narrow_bind 8 20 + 36 pop_jump_if_false +2 (to 38) + 37 jump +29 (to 66) + 38 load_var 5 (e) + 39 store_var 24 (_64) + 40 load_var 24 (_64) + 41 narrow_bind 9 24 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 24 (_64) + 44 store_var 25 (failed) + + 34 45 load_type 0 + 46 load_var 25 (failed) + 47 load_field 0 (id) + 48 call 138 ntypeargs=1 (baml.String.from) + 49 store_var 26 (_70) + 50 load_type 0 + 51 load_var 25 (failed) + 52 load_field 1 (message) + 53 call 138 ntypeargs=1 (baml.String.from) + 54 store_var 27 (_73) + 55 load_var 2 (lines) + 56 load_const 10 ("tool result id=") + 57 load_var 26 (_70) + 58 bin_op + + 59 load_const 11 (" is_error=true: ") + 60 bin_op + + 61 load_var 27 (_73) + 62 bin_op + + 63 call 4 ntypeargs=0 (baml.Array.push) + 64 pop 1 + 65 jump -56 (to 9) + + 9 66 load_var 20 (_52) + 67 store_var 21 (done) + + 31 68 load_type 0 + 69 load_var 21 (done) + 70 load_field 0 (id) + 71 call 138 ntypeargs=1 (baml.String.from) + 72 store_var 22 (_58) + 73 load_type 0 + 74 load_var 21 (done) + 75 load_field 1 (output) + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 23 (_61) + 78 load_var 2 (lines) + 79 load_const 12 ("tool result id=") + 80 load_var 22 (_58) + 81 bin_op + + 82 load_const 13 (" is_error=false: ") + 83 bin_op + + 84 load_var 23 (_61) + 85 bin_op + + 86 call 4 ntypeargs=0 (baml.Array.push) + 87 pop 1 + 88 jump -79 (to 9) + + 9 89 load_var 8 (_16) + 90 load_field 0 (content) + 91 load_type 14 + 92 load_const 15 ("iter") + 93 virtual_call nargs=1 ntypeargs=0 + 94 store_var 9 (_19) + + 14 95 load_var 9 (_19) + 96 load_type 16 + 97 load_const 17 ("next") + 98 virtual_call nargs=1 ntypeargs=0 + 99 store_var 10 (_20) + 100 load_var 10 (_20) + 101 is_type 5 + 102 pop_jump_if_false +2 (to 104) + 103 jump -94 (to 9) + 104 load_var 10 (_20) + 105 store_var 11 (b) + + 15 106 load_var 11 (b) + 107 store_var 12 (_24) + 108 load_var 12 (_24) + 109 narrow_bind 18 12 + 110 pop_jump_if_false +2 (to 112) + 111 jump +45 (to 156) + 112 load_var 11 (b) + 113 store_var 14 (_31) + 114 load_var 14 (_31) + 115 narrow_bind 19 14 + 116 pop_jump_if_false -21 (to 95) + 117 load_var 14 (_31) + 118 store_var 15 (c) + + 21 119 load_type 0 + 120 load_var 15 (c) + 121 load_field 0 (id) + 122 call 138 ntypeargs=1 (baml.String.from) + 123 store_var 16 (_40) + 124 load_type 0 + 125 load_var 15 (c) + 126 load_field 1 (name) + 127 call 138 ntypeargs=1 (baml.String.from) + 128 store_var 17 (_43) + 129 load_type 20 + 130 load_var 15 (c) + 131 load_field 2 (args) + 132 call 333 ntypeargs=1 (baml.json.to_json) + 133 call 330 ntypeargs=0 (baml.json.stringify) + 134 store_var 19 (_47) + 135 load_type 0 + 136 load_var 19 (_47) + 137 call 138 ntypeargs=1 (baml.String.from) + 138 store_var 18 (_46) + + 20 139 load_var 2 (lines) + + 21 140 load_const 21 ("assistant tool_call: {\"id\": \"") + 141 load_var 16 (_40) + 142 bin_op + + 143 load_const 22 ("\", \"name\": \"") + 144 bin_op + + 145 load_var 17 (_43) + 146 bin_op + + 147 load_const 23 ("\", \"args\": ") + 148 bin_op + + 149 load_var 18 (_46) + 150 bin_op + + 151 load_const 24 ("}") + 152 bin_op + + 153 call 4 ntypeargs=0 (baml.Array.push) + 154 pop 1 + 155 jump -60 (to 95) + + 17 156 load_type 0 + + 15 157 load_var 12 (_24) + 158 load_field 0 (text) + 159 call 138 ntypeargs=1 (baml.String.from) + 160 store_var 13 (_28) + + 17 161 load_var 2 (lines) + 162 load_const 25 ("assistant: ") + 163 load_var 13 (_28) + 164 bin_op + + 165 call 4 ntypeargs=0 (baml.Array.push) + 166 pop 1 + 167 jump -72 (to 95) + + 11 168 load_type 0 + + 9 169 load_var 6 (_9) + 170 load_field 0 (content) + 171 call 138 ntypeargs=1 (baml.String.from) + 172 store_var 7 (_13) + + 11 173 load_var 2 (lines) + 174 load_const 26 ("user: ") + 175 load_var 7 (_13) + 176 bin_op + + 177 call 4 ntypeargs=0 (baml.Array.push) + 178 pop 1 + 179 jump -170 (to 9) + + 41 180 load_var 2 (lines) + 181 container_len + 182 store_var 28 (_77) + 183 load_var 28 (_77) + 184 load_const 27 (0) + 185 cmp_int_op == + 186 pop_jump_if_false +2 (to 188) + 187 jump +14 (to 201) + + 44 188 load_type 0 + 189 load_var 2 (lines) + 190 load_const 28 ("\n") + 191 call 15 ntypeargs=1 (baml.Array.join) + 192 store_var 30 (_79) + 193 load_type 0 + 194 load_var 30 (_79) + 195 call 138 ntypeargs=1 (baml.String.from) + 196 store_var 29 (_78) + 197 load_const 29 ("\n\nConversation so far:\n") + 198 load_var 29 (_78) + 199 bin_op + + + 41 200 jump +2 (to 202) + + 42 201 load_const 30 ("") + 202 return +} + +function google.GoogleClient.ai.Client.id(self: google.GoogleClient) -> string { + 18 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 2 (_2) + 5 load_const 1 ("google/") + 6 load_var 2 (_2) + 7 bin_op + + 8 return +} + +function google.GoogleClient.ai.Client.invoke(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 22 0 load_var2 1 2 + 1 call 887 ntypeargs=0 (google.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 23 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function google.GoogleClient.ai.stream.StreamingClient.invoke_stream(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 30 0 load_var2 1 2 + 1 call 889 ntypeargs=0 (google.internal.invoke_stream) + 2 return +} + +function google.GoogleClient.new(model: string, api_key: string | null, base_url: string | null) -> google.GoogleClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 9 4 load_const 1 ("gemini-2.5-flash") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 10 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 11 16 load_const 2 (null) + 17 store_var 3 (base_url) + + 13 18 load_var2 1 2 + 19 load_var 3 (base_url) + 20 init_instance 0 (google.GoogleClient .model, .api_key, .base_url) + 21 return +} + +function google.internal._gm_content(role: string, parts: map[]) -> map { + 44 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 3 (m) + + 45 4 load_type 0 + 5 load_type 1 + 6 load_var 3 (m) + 7 load_const 2 ("role") + 8 load_var 1 (role) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 46 11 load_type 0 + 12 load_type 1 + 13 load_var 3 (m) + 14 load_const 3 ("parts") + 15 load_var 2 (parts) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 47 18 load_var 3 (m) + 19 return +} + +function google.internal._gm_function_response(name: string, response: map) -> map { + 62 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 3 (fr) + + 63 4 load_type 0 + 5 load_type 1 + 6 load_var 3 (fr) + 7 load_const 2 ("name") + 8 load_var 1 (name) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 64 11 load_type 0 + 12 load_type 1 + 13 load_var 3 (fr) + 14 load_const 3 ("response") + 15 load_var 2 (response) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 65 18 load_type 0 + 19 load_type 1 + 20 alloc_map 0 + 21 store_var 4 (part) + + 66 22 load_type 0 + 23 load_type 1 + 24 load_var 4 (part) + 25 load_const 4 ("functionResponse") + 26 load_var 3 (fr) + 27 call 37 ntypeargs=2 (baml.Map.set) + 28 pop 1 + + 67 29 load_var 4 (part) + 30 return +} + +function google.internal._gm_text_part(text: string) -> map { + 52 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 2 (p) + + 53 4 load_type 0 + 5 load_type 1 + 6 load_var 2 (p) + 7 load_const 2 ("text") + 8 load_var 1 (text) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 54 11 load_var 2 (p) + 12 return +} + +function google.internal._gm_tool_name_for(j: ai.Journal, id: string) -> string { + 109 0 load_const 0 ("") + 1 store_var 3 (name) + + 110 2 load_var 1 (j) + 3 call 783 ntypeargs=0 (ai.Journal.entries) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_5) + 8 load_var 4 (_5) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_6) + 13 load_var 5 (_6) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +36 (to 52) + 17 load_var 5 (_6) + 18 store_var 6 (_10) + + 111 19 load_var 6 (_10) + 20 narrow_bind 6 6 + 21 pop_jump_if_false -13 (to 8) + 22 load_var 6 (_10) + 23 load_field 0 (content) + 24 load_type 7 + 25 load_const 8 ("iter") + 26 virtual_call nargs=1 ntypeargs=0 + 27 store_var 7 (_13) + + 113 28 load_var 7 (_13) + 29 load_type 9 + 30 load_const 10 ("next") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 8 (_14) + 33 load_var 8 (_14) + 34 is_type 5 + 35 pop_jump_if_false +2 (to 37) + 36 jump -28 (to 8) + 37 load_var 8 (_14) + 38 store_var 9 (_18) + + 114 39 load_var 9 (_18) + 40 narrow_bind 11 9 + 41 pop_jump_if_false -13 (to 28) + 42 load_var 9 (_18) + 43 store_var_load_var 10 (u) + + 116 44 load_field 0 (id) + 45 load_var 2 (id) + 46 cmp_op == + 47 pop_jump_if_false -19 (to 28) + + 117 48 load_var 10 (u) + 49 load_field 1 (name) + 50 store_var 3 (name) + + 116 51 jump -23 (to 28) + + 131 52 load_var 3 (name) + 53 return +} + +function google.internal._google_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 367 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 368 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +232 (to 249) + 18 load_var 4 (_5) + 19 load_field 1 (data) + 20 store_var 5 (_10) + + 369 21 load_var 5 (_10) + 22 narrow_bind 6 5 + 23 pop_jump_if_false -14 (to 9) + + 370 24 load_type 7 + + 369 25 load_var 5 (_10) + 26 call 335 ntypeargs=1 (baml.json.from_string) + 27 jump +4 (to 31) + + 370 28 load_var 6 (e) + 29 throw_if_panic + + 371 30 load_const 8 (null) + + 373 31 store_var 7 (_16) + 32 load_var 7 (_16) + 33 narrow_bind 9 7 + 34 pop_jump_if_false -25 (to 9) + 35 load_var 7 (_16) + 36 store_var_load_var 8 (resp) + + 374 37 load_field 0 (candidates) + 38 load_const 8 (null) + 39 cmp_op == + 40 pop_jump_if_false +2 (to 42) + 41 jump +8 (to 49) + 42 load_const 10 (0) + 43 load_var 8 (resp) + 44 load_field 0 (candidates) + 45 make_bound_method 3 + 46 call_indirect + 47 store_var 9 (cand) + 48 jump +3 (to 51) + 49 load_const 8 (null) + 50 store_var 9 (cand) + + 375 51 load_var 9 (cand) + 52 load_const 8 (null) + 53 cmp_op == + 54 pop_jump_if_false +2 (to 56) + 55 jump +17 (to 72) + 56 load_var 9 (cand) + 57 load_field 0 (0) + 58 load_const 8 (null) + 59 cmp_op == + 60 pop_jump_if_false +2 (to 62) + 61 jump +11 (to 72) + 62 load_var 9 (cand) + 63 load_const 8 (null) + 64 cmp_op == + 65 pop_jump_if_false +2 (to 67) + 66 jump +6 (to 72) + 67 load_var 9 (cand) + 68 load_field 0 (0) + 69 load_field 0 (0) + 70 store_var 11 (_24) + 71 jump +3 (to 74) + 72 load_const 8 (null) + 73 store_var 11 (_24) + 74 load_var 11 (_24) + 75 store_var 10 (parts) + 76 load_var 11 (_24) + 77 load_const 8 (null) + 78 cmp_op == + 79 pop_jump_if_false +4 (to 83) + 80 load_type 11 + 81 alloc_array 0 + 82 store_var 10 (parts) + + 376 83 load_var 10 (parts) + 84 load_type 12 + 85 load_const 13 ("iter") + 86 virtual_call nargs=1 ntypeargs=0 + 87 store_var 12 (_36) + 88 load_var 12 (_36) + 89 load_type 14 + 90 load_const 15 ("next") + 91 virtual_call nargs=1 ntypeargs=0 + 92 store_var 13 (_37) + 93 load_var 13 (_37) + 94 is_type 5 + 95 pop_jump_if_false +2 (to 97) + 96 jump +29 (to 125) + 97 load_var 13 (_37) + 98 store_var_load_var 14 (p) + + 377 99 load_field 0 (text) + 100 store_var 15 (_42) + 101 load_var 15 (_42) + 102 narrow_bind 6 15 + 103 pop_jump_if_false -15 (to 88) + 104 load_var 15 (_42) + 105 store_var 16 (t) + + 378 106 load_var 14 (p) + 107 load_field 1 (thought) + 108 store_var 18 (_45) + 109 load_var 18 (_45) + 110 store_var 17 (_44) + 111 load_var 18 (_45) + 112 load_const 8 (null) + 113 cmp_op == + 114 pop_jump_if_false +3 (to 117) + 115 load_const 16 (false) + 116 store_var 17 (_44) + 117 load_var 17 (_44) + 118 pop_jump_if_false +2 (to 120) + 119 jump -31 (to 88) + + 381 120 load_var2 2 16 + 121 init_instance 0 (ai.stream.TextDelta .text) + 122 call 4 ntypeargs=0 (baml.Array.push) + 123 pop 1 + 124 jump -36 (to 88) + + 388 125 load_var 9 (cand) + 126 load_const 8 (null) + 127 cmp_op == + 128 pop_jump_if_false +2 (to 130) + 129 jump +5 (to 134) + 130 load_var 9 (cand) + 131 load_field 1 (1) + 132 store_var 20 (_51) + 133 jump +3 (to 136) + 134 load_const 8 (null) + 135 store_var 20 (_51) + 136 load_var 20 (_51) + 137 store_var 19 (finish) + 138 load_var 20 (_51) + 139 load_const 8 (null) + 140 cmp_op == + 141 pop_jump_if_false +3 (to 144) + 142 load_const 17 ("") + 143 store_var 19 (finish) + + 389 144 load_var 8 (resp) + 145 load_field 2 (promptFeedback) + 146 load_const 8 (null) + 147 cmp_op == + 148 pop_jump_if_false +2 (to 150) + 149 jump +5 (to 154) + 150 load_var 8 (resp) + 151 load_field 2 (promptFeedback) + 152 load_field 0 (0) + 153 jump +2 (to 155) + 154 load_const 8 (null) + 155 load_const 8 (null) + 156 call 635 ntypeargs=0 (baml.ops.equals_equals) + 157 store_var 21 (_61) + + 390 158 load_var 19 (finish) + 159 load_const 18 ("MAX_TOKENS") + 160 cmp_op == + 161 pop_jump_if_false +2 (to 163) + 162 jump +39 (to 201) + + 389 163 load_var 21 (_61) + 164 unary_op ! + 165 jump_if_false +2 (to 167) + 166 jump +5 (to 171) + 167 pop 1 + + 394 168 load_var 19 (finish) + 169 load_const 19 ("SAFETY") + 170 cmp_op == + + 393 171 jump_if_false +2 (to 173) + 172 jump +5 (to 177) + 173 pop 1 + + 395 174 load_var 19 (finish) + 175 load_const 20 ("RECITATION") + 176 cmp_op == + + 393 177 jump_if_false +2 (to 179) + 178 jump +5 (to 183) + 179 pop 1 + + 396 180 load_var 19 (finish) + 181 load_const 21 ("PROHIBITED_CONTENT") + 182 cmp_op == + + 392 183 pop_jump_if_false +2 (to 185) + 184 jump +13 (to 197) + + 399 185 load_var 19 (finish) + 186 load_const 22 ("") + 187 cmp_op != + 188 pop_jump_if_false +2 (to 190) + 189 jump +4 (to 193) + + 402 190 load_const 8 (null) + 191 store_var 22 (stop) + + 399 192 jump +12 (to 204) + + 400 193 load_const 10 (ai.content.StopReason.Complete) + 194 alloc_variant 436 (ai.content.StopReason) + 195 store_var 22 (stop) + + 399 196 jump +8 (to 204) + + 398 197 load_const 23 (ai.content.StopReason.Refused) + 198 alloc_variant 436 (ai.content.StopReason) + 199 store_var 22 (stop) + + 392 200 jump +4 (to 204) + + 391 201 load_const 24 (ai.content.StopReason.MaxTokens) + 202 alloc_variant 436 (ai.content.StopReason) + 203 store_var 22 (stop) + + 404 204 load_var 8 (resp) + 205 load_field 1 (usageMetadata) + 206 store_var 23 (usage) + + 405 207 load_var 22 (stop) + 208 load_const 8 (null) + 209 call 635 ntypeargs=0 (baml.ops.equals_equals) + 210 unary_op ! + 211 jump_if_false +2 (to 213) + 212 jump +6 (to 218) + 213 pop 1 + 214 load_var 23 (usage) + 215 load_const 8 (null) + 216 call 635 ntypeargs=0 (baml.ops.equals_equals) + 217 unary_op ! + 218 pop_jump_if_false -209 (to 9) + + 408 219 load_var 22 (stop) + 220 store_var 24 (_83) + + 409 221 load_var 23 (usage) + 222 load_const 8 (null) + 223 cmp_op == + 224 pop_jump_if_false +2 (to 226) + 225 jump +5 (to 230) + 226 load_var 23 (usage) + 227 load_field 0 (0) + 228 store_var 25 (_84) + 229 jump +3 (to 232) + 230 load_const 8 (null) + 231 store_var 25 (_84) + + 410 232 load_var 23 (usage) + 233 load_const 8 (null) + 234 cmp_op == + 235 pop_jump_if_false +2 (to 237) + 236 jump +5 (to 241) + 237 load_var 23 (usage) + 238 load_field 1 (1) + 239 store_var 26 (_88) + 240 jump +3 (to 243) + 241 load_const 8 (null) + 242 store_var 26 (_88) + + 406 243 load_var2 2 24 + + 407 244 load_var2 25 26 + 245 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 246 call 4 ntypeargs=0 (baml.Array.push) + 247 pop 1 + 248 jump -239 (to 9) + + 426 249 load_var 2 (out) + 250 return +} + +function google.internal._google_request(c: google.GoogleClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 226 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 4 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 4 (_5) + 7 call_indirect + + 227 8 call 881 ntypeargs=0 (google.internal.google_lower_prompt) + 9 store_var 5 (prompt_parts) + + 228 10 load_var 5 (prompt_parts) + 11 load_field 1 (contents) + 12 store_var 6 (contents) + + 229 13 load_var 2 (input) + 14 load_field 1 (journal) + 15 call 883 ntypeargs=0 (google.internal.google_lower_journal) + 16 load_type 0 + 17 load_const 1 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 7 (_13) + 20 load_var 7 (_13) + 21 load_type 2 + 22 load_const 3 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 8 (_14) + 25 load_var 8 (_14) + 26 is_type 4 + 27 pop_jump_if_false +2 (to 29) + 28 jump +5 (to 33) + + 230 29 load_var2 6 8 + + 229 30 call 4 ntypeargs=0 (baml.Array.push) + 31 pop 1 + 32 jump -12 (to 20) + + 232 33 load_type 5 + 34 load_type 6 + 35 alloc_map 0 + 36 store_var 9 (body) + + 237 37 load_var 5 (prompt_parts) + 38 load_field 2 (first_role) + 39 load_const 7 ("user") + 40 cmp_op != + 41 jump_if_false +9 (to 50) + 42 pop 1 + + 238 43 load_var 5 (prompt_parts) + 44 load_field 0 (system_parts) + 45 container_len + 46 store_var 10 (_25) + 47 load_var 10 (_25) + 48 load_const 8 (0) + 49 cmp_int_op > + 50 pop_jump_if_false +2 (to 52) + 51 jump +29 (to 80) + + 241 52 load_var 5 (prompt_parts) + 53 load_field 0 (system_parts) + 54 container_len + 55 store_var 12 (_33) + 56 load_var 12 (_33) + 57 load_const 8 (0) + 58 cmp_int_op > + 59 pop_jump_if_false +33 (to 92) + + 242 60 load_type 5 + 61 load_type 6 + 62 alloc_map 0 + 63 store_var 13 (system_instruction) + + 243 64 load_type 5 + 65 load_type 6 + 66 load_var 13 (system_instruction) + 67 load_const 9 ("parts") + 68 load_var 5 (prompt_parts) + 69 load_field 0 (system_parts) + 70 call 37 ntypeargs=2 (baml.Map.set) + 71 pop 1 + + 244 72 load_type 5 + 73 load_type 6 + 74 load_var 9 (body) + 75 load_const 10 ("systemInstruction") + 76 load_var 13 (system_instruction) + 77 call 37 ntypeargs=2 (baml.Map.set) + 78 pop 1 + 79 jump +13 (to 92) + + 239 80 load_const 11 ("user") + 81 load_var 5 (prompt_parts) + 82 load_field 0 (system_parts) + 83 call 878 ntypeargs=0 (google.internal._gm_content) + 84 store_var 11 (_28) + 85 load_type 12 + 86 load_var 11 (_28) + 87 load_type 12 + 88 alloc_array 1 + 89 load_var 6 (contents) + 90 call 7 ntypeargs=1 (baml.Array.concat) + 91 store_var 6 (contents) + + 249 92 load_type 5 + 93 load_type 6 + 94 load_var 9 (body) + 95 load_const 13 ("contents") + 96 load_var 6 (contents) + 97 call 37 ntypeargs=2 (baml.Map.set) + 98 pop 1 + + 250 99 load_var 2 (input) + 100 load_field 2 (toolbox) + 101 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 102 unary_op ! + 103 pop_jump_if_false +103 (to 206) + + 251 104 load_type 12 + 105 alloc_array 0 + 106 store_var 14 (decls) + + 252 107 load_var 2 (input) + 108 load_field 2 (toolbox) + 109 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 110 load_type 14 + 111 load_const 15 ("iter") + 112 virtual_call nargs=1 ntypeargs=0 + 113 store_var 15 (_54) + 114 load_var 15 (_54) + 115 load_type 16 + 116 load_const 17 ("next") + 117 virtual_call nargs=1 ntypeargs=0 + 118 store_var 16 (_55) + 119 load_var 16 (_55) + 120 is_type 4 + 121 pop_jump_if_false +2 (to 123) + 122 jump +35 (to 157) + 123 load_var 16 (_55) + 124 store_var 17 (t) + + 253 125 load_type 5 + 126 load_type 6 + 127 alloc_map 0 + 128 store_var 18 (d) + + 254 129 load_type 5 + 130 load_type 6 + 131 load_var 18 (d) + 132 load_const 18 ("name") + 133 load_var 17 (t) + 134 load_field 0 (name) + 135 call 37 ntypeargs=2 (baml.Map.set) + 136 pop 1 + + 255 137 load_type 5 + 138 load_type 6 + 139 load_var 18 (d) + 140 load_const 19 ("description") + 141 load_var 17 (t) + 142 load_field 1 (description) + 143 call 37 ntypeargs=2 (baml.Map.set) + 144 pop 1 + + 256 145 load_type 5 + 146 load_type 6 + 147 load_var 18 (d) + 148 load_const 20 ("parametersJsonSchema") + 149 load_var 17 (t) + 150 load_field 2 (input_schema) + 151 call 37 ntypeargs=2 (baml.Map.set) + 152 pop 1 + + 257 153 load_var2 14 18 + 154 call 4 ntypeargs=0 (baml.Array.push) + 155 pop 1 + 156 jump -42 (to 114) + + 259 157 load_type 5 + 158 load_type 6 + 159 alloc_map 0 + 160 store_var 19 (group) + + 260 161 load_type 5 + 162 load_type 6 + 163 load_var 19 (group) + 164 load_const 21 ("functionDeclarations") + 165 load_var 14 (decls) + 166 call 37 ntypeargs=2 (baml.Map.set) + 167 pop 1 + + 261 168 load_type 5 + 169 load_type 6 + 170 load_var 9 (body) + 171 load_const 22 ("tools") + 172 load_var 19 (group) + 173 load_type 12 + 174 alloc_array 1 + 175 call 37 ntypeargs=2 (baml.Map.set) + 176 pop 1 + + 262 177 load_type 5 + 178 load_type 6 + 179 alloc_map 0 + 180 store_var 20 (fcc) + + 263 181 load_type 5 + 182 load_type 6 + 183 load_var 20 (fcc) + 184 load_const 23 ("mode") + 185 load_const 24 ("AUTO") + 186 call 37 ntypeargs=2 (baml.Map.set) + 187 pop 1 + + 264 188 load_type 5 + 189 load_type 6 + 190 alloc_map 0 + 191 store_var 21 (tc) + + 265 192 load_type 5 + 193 load_type 6 + 194 load_var 21 (tc) + 195 load_const 25 ("functionCallingConfig") + 196 load_var 20 (fcc) + 197 call 37 ntypeargs=2 (baml.Map.set) + 198 pop 1 + + 266 199 load_type 5 + 200 load_type 6 + 201 load_var 9 (body) + 202 load_const 26 ("toolConfig") + 203 load_var 21 (tc) + 204 call 37 ntypeargs=2 (baml.Map.set) + 205 pop 1 + + 271 206 load_var 3 (stream) + 207 pop_jump_if_false +2 (to 209) + 208 jump +4 (to 212) + + 274 209 load_const 27 (":generateContent") + 210 store_var 22 (method) + + 271 211 jump +3 (to 214) + + 272 212 load_const 28 (":streamGenerateContent?alt=sse") + 213 store_var 22 (method) + + 278 214 load_var 1 (c) + 215 load_field 2 (base_url) + 216 store_var 25 (_103) + 217 load_var 25 (_103) + 218 store_var 24 (_102) + 219 load_var 25 (_103) + 220 load_const 29 (null) + 221 cmp_op == + 222 pop_jump_if_false +3 (to 225) + 223 load_const 30 ("https://generativelanguage.googleapis.com/v1beta") + 224 store_var 24 (_102) + 225 load_type 5 + 226 load_var 24 (_102) + 227 call 138 ntypeargs=1 (baml.String.from) + 228 store_var 23 (_101) + 229 load_type 5 + 230 load_var 1 (c) + 231 load_field 0 (model) + 232 call 138 ntypeargs=1 (baml.String.from) + 233 store_var 26 (_106) + 234 load_type 5 + 235 load_var 22 (method) + 236 call 138 ntypeargs=1 (baml.String.from) + 237 store_var 27 (_109) + + 280 238 load_var 1 (c) + 239 load_field 1 (api_key) + 240 store_var 29 (_114) + 241 load_var2 29 29 + 242 load_const 29 (null) + 243 cmp_op == + 244 pop_jump_if_false +3 (to 247) + 245 load_const 31 ("GOOGLE_API_KEY") + 246 call 211 ntypeargs=0 (baml.env.get_or_panic) + + 279 247 load_const 32 ("application/json") + 248 load_const 33 ("x-goog-api-key") + 249 load_const 34 ("content-type") + 250 load_type 5 + 251 load_type 5 + 252 alloc_map 2 + 253 store_var 28 (_112) + + 283 254 load_type 12 + 255 load_var 9 (body) + 256 call 333 ntypeargs=1 (baml.json.to_json) + 257 call 330 ntypeargs=0 (baml.json.stringify) + 258 store_var 30 (_116) + + 276 259 load_const 35 ("POST") + + 278 260 load_var 23 (_101) + 261 load_const 36 ("/models/") + 262 bin_op + + 263 load_var 26 (_106) + 264 bin_op + + 265 load_var 27 (_109) + 266 bin_op + + 267 load_var2 28 30 + 268 init_instance 0 (baml.http.Request .method, .url, .headers, .body) + 269 return +} + +function google.internal.google_lower_journal(j: ai.Journal) -> map[] { + 139 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (contents) + + 140 3 load_type 0 + 4 alloc_array 0 + 5 store_var 3 (pending) + + 141 6 load_var 1 (j) + 7 call 783 ntypeargs=0 (ai.Journal.entries) + 8 load_type 1 + 9 load_const 2 ("iter") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 load_type 3 + 14 load_const 4 ("next") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 5 (_6) + 17 load_var 5 (_6) + 18 is_type 5 + 19 pop_jump_if_false +2 (to 21) + 20 jump +217 (to 237) + 21 load_var 5 (_6) + 22 store_var 6 (e) + + 142 23 load_var 6 (e) + 24 store_var 7 (_10) + 25 load_var 7 (_10) + 26 narrow_bind 6 7 + 27 pop_jump_if_false +2 (to 29) + 28 jump +176 (to 204) + 29 load_var 6 (e) + 30 store_var 13 (_22) + 31 load_var 13 (_22) + 32 narrow_bind 7 13 + 33 pop_jump_if_false +2 (to 35) + 34 jump +60 (to 94) + 35 load_var 6 (e) + 36 store_var 29 (_64) + 37 load_var 29 (_64) + 38 narrow_bind 8 29 + 39 pop_jump_if_false +2 (to 41) + 40 jump +30 (to 70) + 41 load_var 6 (e) + 42 store_var 33 (_76) + 43 load_var 33 (_76) + 44 narrow_bind 9 33 + 45 pop_jump_if_false -33 (to 12) + 46 load_var 33 (_76) + 47 store_var 34 (f) + + 197 48 load_type 10 + 49 load_type 11 + 50 alloc_map 0 + 51 store_var 35 (response) + + 198 52 load_type 10 + 53 load_type 11 + 54 load_var 35 (response) + 55 load_const 12 ("error") + 56 load_var 34 (f) + 57 load_field 1 (message) + 58 call 37 ntypeargs=2 (baml.Map.set) + 59 pop 1 + + 199 60 load_var2 1 34 + 61 load_field 0 (id) + 62 call 882 ntypeargs=0 (google.internal._gm_tool_name_for) + 63 load_var 35 (response) + 64 call 880 ntypeargs=0 (google.internal._gm_function_response) + 65 store_var 36 (_84) + 66 load_var2 3 36 + 67 call 4 ntypeargs=0 (baml.Array.push) + 68 pop 1 + 69 jump -57 (to 12) + + 142 70 load_var 29 (_64) + 71 store_var 30 (c) + + 191 72 load_type 10 + 73 load_type 11 + 74 alloc_map 0 + 75 store_var 31 (response) + + 192 76 load_type 10 + 77 load_type 11 + 78 load_var 31 (response) + 79 load_const 13 ("result") + 80 load_var 30 (c) + 81 load_field 1 (output) + 82 call 37 ntypeargs=2 (baml.Map.set) + 83 pop 1 + + 193 84 load_var2 1 30 + 85 load_field 0 (id) + 86 call 882 ntypeargs=0 (google.internal._gm_tool_name_for) + 87 load_var 31 (response) + 88 call 880 ntypeargs=0 (google.internal._gm_function_response) + 89 store_var 32 (_72) + 90 load_var2 3 32 + 91 call 4 ntypeargs=0 (baml.Array.push) + 92 pop 1 + 93 jump -81 (to 12) + + 142 94 load_var 13 (_22) + 95 store_var 14 (a) + + 155 96 load_var 3 (pending) + 97 container_len + 98 store_var 15 (_25) + 99 load_var 15 (_25) + 100 load_const 14 (0) + 101 cmp_int_op > + 102 pop_jump_if_false +11 (to 113) + + 156 103 load_const 15 ("user") + 104 load_var 3 (pending) + 105 call 878 ntypeargs=0 (google.internal._gm_content) + 106 store_var 16 (_27) + 107 load_var2 2 16 + 108 call 4 ntypeargs=0 (baml.Array.push) + 109 pop 1 + + 157 110 load_type 0 + 111 alloc_array 0 + 112 store_var 3 (pending) + + 162 113 load_type 0 + 114 alloc_array 0 + 115 store_var 17 (parts) + + 163 116 load_var 14 (a) + 117 load_field 0 (content) + 118 load_type 16 + 119 load_const 17 ("iter") + 120 virtual_call nargs=1 ntypeargs=0 + 121 store_var 18 (_31) + 122 load_var 18 (_31) + 123 load_type 18 + 124 load_const 19 ("next") + 125 virtual_call nargs=1 ntypeargs=0 + 126 store_var 19 (_32) + 127 load_var 19 (_32) + 128 is_type 5 + 129 pop_jump_if_false +2 (to 131) + 130 jump +59 (to 189) + 131 load_var 19 (_32) + 132 store_var 20 (b) + + 164 133 load_var 20 (b) + 134 store_var 21 (_36) + 135 load_var 21 (_36) + 136 narrow_bind 20 21 + 137 pop_jump_if_false +2 (to 139) + 138 jump +43 (to 181) + 139 load_var 20 (b) + 140 store_var 23 (_41) + 141 load_var 23 (_41) + 142 narrow_bind 21 23 + 143 pop_jump_if_false -21 (to 122) + 144 load_var 23 (_41) + 145 store_var 24 (use) + + 170 146 load_type 10 + 147 load_type 11 + 148 alloc_map 0 + 149 store_var 25 (fc) + + 171 150 load_type 10 + 151 load_type 11 + 152 load_var 25 (fc) + 153 load_const 22 ("name") + 154 load_var 24 (use) + 155 load_field 1 (name) + 156 call 37 ntypeargs=2 (baml.Map.set) + 157 pop 1 + + 172 158 load_type 10 + 159 load_type 11 + 160 load_var 25 (fc) + 161 load_const 23 ("args") + 162 load_var 24 (use) + 163 load_field 2 (args) + 164 call 37 ntypeargs=2 (baml.Map.set) + 165 pop 1 + + 173 166 load_type 10 + 167 load_type 11 + 168 alloc_map 0 + 169 store_var 26 (part) + + 174 170 load_type 10 + 171 load_type 11 + 172 load_var 26 (part) + 173 load_const 24 ("functionCall") + 174 load_var 25 (fc) + 175 call 37 ntypeargs=2 (baml.Map.set) + 176 pop 1 + + 175 177 load_var2 17 26 + 178 call 4 ntypeargs=0 (baml.Array.push) + 179 pop 1 + 180 jump -58 (to 122) + + 164 181 load_var 21 (_36) + 182 load_field 0 (text) + 183 call 879 ntypeargs=0 (google.internal._gm_text_part) + 184 store_var 22 (_39) + + 166 185 load_var2 17 22 + 186 call 4 ntypeargs=0 (baml.Array.push) + 187 pop 1 + 188 jump -66 (to 122) + + 182 189 load_var 17 (parts) + 190 container_len + 191 store_var 27 (_60) + 192 load_var 27 (_60) + 193 load_const 14 (0) + 194 cmp_int_op > + 195 pop_jump_if_false -183 (to 12) + + 183 196 load_const 25 ("model") + 197 load_var 17 (parts) + 198 call 878 ntypeargs=0 (google.internal._gm_content) + 199 store_var 28 (_62) + 200 load_var2 2 28 + 201 call 4 ntypeargs=0 (baml.Array.push) + 202 pop 1 + 203 jump -191 (to 12) + + 142 204 load_var 7 (_10) + 205 store_var 8 (u) + + 144 206 load_var 3 (pending) + 207 container_len + 208 store_var 9 (_13) + 209 load_var 9 (_13) + 210 load_const 14 (0) + 211 cmp_int_op > + 212 pop_jump_if_false +11 (to 223) + + 145 213 load_const 26 ("user") + 214 load_var 3 (pending) + 215 call 878 ntypeargs=0 (google.internal._gm_content) + 216 store_var 10 (_15) + 217 load_var2 2 10 + 218 call 4 ntypeargs=0 (baml.Array.push) + 219 pop 1 + + 146 220 load_type 0 + 221 alloc_array 0 + 222 store_var 3 (pending) + + 151 223 load_var 8 (u) + 224 load_field 0 (content) + 225 call 879 ntypeargs=0 (google.internal._gm_text_part) + 226 store_var 12 (_20) + 227 load_const 27 ("user") + 228 load_var 12 (_20) + 229 load_type 0 + 230 alloc_array 1 + 231 call 878 ntypeargs=0 (google.internal._gm_content) + 232 store_var 11 (_18) + 233 load_var2 2 11 + 234 call 4 ntypeargs=0 (baml.Array.push) + 235 pop 1 + 236 jump -224 (to 12) + + 205 237 load_var 3 (pending) + 238 container_len + 239 store_var 37 (_89) + 240 load_var 37 (_89) + 241 load_const 14 (0) + 242 cmp_int_op > + 243 pop_jump_if_false +8 (to 251) + + 206 244 load_const 28 ("user") + 245 load_var 3 (pending) + 246 call 878 ntypeargs=0 (google.internal._gm_content) + 247 store_var 38 (_91) + 248 load_var2 2 38 + 249 call 4 ntypeargs=0 (baml.Array.push) + 250 pop 1 + + 211 251 load_var 2 (contents) + 252 return +} + +function google.internal.google_lower_prompt(prompt: ai.Prompt) -> google.internal.GooglePrompt { + 79 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (system_parts) + + 80 3 load_type 0 + 4 alloc_array 0 + 5 store_var 3 (contents) + + 81 6 load_const 1 ("") + 7 store_var 4 (first_role) + + 82 8 load_var 1 (prompt) + 9 call 787 ntypeargs=0 (ai.Prompt.messages) + 10 load_type 2 + 11 load_const 3 ("iter") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_6) + 14 load_var 5 (_6) + 15 load_type 4 + 16 load_const 5 ("next") + 17 virtual_call nargs=1 ntypeargs=0 + 18 store_var 6 (_7) + 19 load_var 6 (_7) + 20 is_type 6 + 21 pop_jump_if_false +2 (to 23) + 22 jump +42 (to 64) + 23 load_var 6 (_7) + 24 store_var_load_var 7 (message) + + 83 25 load_field 1 (content) + 26 call 879 ntypeargs=0 (google.internal._gm_text_part) + 27 store_var 8 (part) + + 84 28 load_var 7 (message) + 29 load_field 0 (role) + 30 load_const 7 ("system") + 31 cmp_op == + 32 pop_jump_if_false +2 (to 34) + 33 jump +27 (to 60) + + 88 34 load_var 7 (message) + 35 load_field 0 (role) + 36 load_const 8 ("assistant") + 37 cmp_op == + 38 pop_jump_if_false +2 (to 40) + 39 jump +4 (to 43) + + 91 40 load_const 9 ("user") + 41 store_var 9 (role) + + 88 42 jump +3 (to 45) + + 89 43 load_const 10 ("model") + 44 store_var 9 (role) + + 93 45 load_var 4 (first_role) + 46 load_const 11 ("") + 47 cmp_op == + 48 pop_jump_if_false +3 (to 51) + + 94 49 load_var 9 (role) + 50 store_var 4 (first_role) + + 99 51 load_var2 9 8 + 52 load_type 0 + 53 alloc_array 1 + 54 call 878 ntypeargs=0 (google.internal._gm_content) + 55 store_var 10 (_23) + 56 load_var2 3 10 + 57 call 4 ntypeargs=0 (baml.Array.push) + 58 pop 1 + 59 jump -45 (to 14) + + 85 60 load_var2 2 8 + 61 call 4 ntypeargs=0 (baml.Array.push) + 62 pop 1 + 63 jump -49 (to 14) + + 103 64 load_var2 2 3 + 65 load_var 4 (first_role) + 66 init_instance 0 (google.internal.GooglePrompt .system_parts, .contents, .first_role) + 67 return +} + +function google.internal.google_parse(resp: google.internal.GmResponse, seq: int) -> ai.ModelTurn { + 291 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (content) + + 292 3 load_const 1 (false) + 4 store_var 4 (has_call) + + 293 5 load_const 2 (0) + 6 store_var 5 (call_index) + + 294 7 load_var 1 (resp) + 8 load_field 0 (candidates) + 9 load_const 3 (null) + 10 cmp_op == + 11 pop_jump_if_false +2 (to 13) + 12 jump +8 (to 20) + 13 load_const 2 (0) + 14 load_var 1 (resp) + 15 load_field 0 (candidates) + 16 make_bound_method 3 + 17 call_indirect + 18 store_var 6 (cand) + 19 jump +3 (to 22) + 20 load_const 3 (null) + 21 store_var 6 (cand) + + 295 22 load_var 6 (cand) + 23 load_const 3 (null) + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +5 (to 31) + 27 load_var 6 (cand) + 28 load_field 1 (1) + 29 store_var 8 (_12) + 30 jump +3 (to 33) + 31 load_const 3 (null) + 32 store_var 8 (_12) + 33 load_var 8 (_12) + 34 store_var 7 (finish) + 35 load_var 8 (_12) + 36 load_const 3 (null) + 37 cmp_op == + 38 pop_jump_if_false +3 (to 41) + 39 load_const 4 ("") + 40 store_var 7 (finish) + + 296 41 load_var 6 (cand) + 42 load_const 3 (null) + 43 cmp_op == + 44 pop_jump_if_false +2 (to 46) + 45 jump +17 (to 62) + 46 load_var 6 (cand) + 47 load_field 0 (0) + 48 load_const 3 (null) + 49 cmp_op == + 50 pop_jump_if_false +2 (to 52) + 51 jump +11 (to 62) + 52 load_var 6 (cand) + 53 load_const 3 (null) + 54 cmp_op == + 55 pop_jump_if_false +2 (to 57) + 56 jump +6 (to 62) + 57 load_var 6 (cand) + 58 load_field 0 (0) + 59 load_field 0 (0) + 60 store_var 10 (_18) + 61 jump +3 (to 64) + 62 load_const 3 (null) + 63 store_var 10 (_18) + 64 load_var 10 (_18) + 65 store_var 9 (parts) + 66 load_var 10 (_18) + 67 load_const 3 (null) + 68 cmp_op == + 69 pop_jump_if_false +4 (to 73) + 70 load_type 5 + 71 alloc_array 0 + 72 store_var 9 (parts) + + 297 73 load_var 9 (parts) + 74 load_type 6 + 75 load_const 7 ("iter") + 76 virtual_call nargs=1 ntypeargs=0 + 77 store_var 11 (_30) + 78 load_var 11 (_30) + 79 load_type 8 + 80 load_const 9 ("next") + 81 virtual_call nargs=1 ntypeargs=0 + 82 store_var 12 (_31) + 83 load_var 12 (_31) + 84 is_type 10 + 85 pop_jump_if_false +2 (to 87) + 86 jump +84 (to 170) + 87 load_var 12 (_31) + 88 store_var_load_var 13 (p) + + 298 89 load_field 2 (functionCall) + 90 store_var 14 (_36) + 91 load_var 14 (_36) + 92 narrow_bind 11 14 + 93 pop_jump_if_false +2 (to 95) + 94 jump +33 (to 127) + + 310 95 load_var 13 (p) + 96 load_field 0 (text) + 97 store_var 20 (_55) + 98 load_var 20 (_55) + 99 narrow_bind 12 20 + 100 pop_jump_if_false -22 (to 78) + 101 load_var 20 (_55) + 102 store_var 21 (t) + + 311 103 load_var 13 (p) + 104 load_field 1 (thought) + 105 store_var 23 (_58) + 106 load_var 23 (_58) + 107 store_var 22 (_57) + 108 load_var 23 (_58) + 109 load_const 3 (null) + 110 cmp_op == + 111 pop_jump_if_false +3 (to 114) + 112 load_const 1 (false) + 113 store_var 22 (_57) + 114 load_var 22 (_57) + 115 pop_jump_if_false +2 (to 117) + 116 jump +6 (to 122) + + 315 117 load_var2 3 21 + 118 init_instance 0 (ai.content.Text .text) + 119 call 4 ntypeargs=0 (baml.Array.push) + 120 pop 1 + 121 jump -43 (to 78) + + 312 122 load_var2 3 21 + 123 init_instance 1 (ai.content.Reasoning .summary) + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + 126 jump -48 (to 78) + + 298 127 load_var 14 (_36) + 128 store_var 15 (fc) + + 299 129 load_type 13 + 130 load_type 14 + 131 alloc_map 0 + 132 store_var 16 (args) + + 300 133 load_var 15 (fc) + 134 load_field 1 (args) + 135 store_var 17 (_40) + 136 load_var 17 (_40) + 137 narrow_bind 15 17 + 138 pop_jump_if_false +3 (to 141) + 139 load_var 17 (_40) + 140 store_var 16 (args) + + 304 141 load_type 16 + 142 load_var 2 (seq) + 143 call 138 ntypeargs=1 (baml.String.from) + 144 store_var 18 (_47) + 145 load_type 16 + 146 load_var 5 (call_index) + 147 call 138 ntypeargs=1 (baml.String.from) + 148 store_var 19 (_49) + + 303 149 load_var 3 (content) + + 304 150 load_const 17 ("call_") + 151 load_var 18 (_47) + 152 bin_op + + 153 load_const 18 ("_") + 154 bin_op + + 155 load_var 19 (_49) + 156 bin_op + + 157 load_var 15 (fc) + 158 load_field 0 (name) + 159 load_var 16 (args) + 160 init_instance 2 (ai.content.ToolUse .id, .name, .args) + 161 call 4 ntypeargs=0 (baml.Array.push) + 162 pop 1 + + 306 163 load_var 5 (call_index) + 164 load_const 12 (1) + 165 add_int + 166 store_var 5 (call_index) + + 307 167 load_const 19 (true) + 168 store_var 4 (has_call) + + 298 169 jump -91 (to 78) + + 323 170 load_var 1 (resp) + 171 load_field 2 (promptFeedback) + 172 load_const 3 (null) + 173 cmp_op == + 174 pop_jump_if_false +2 (to 176) + 175 jump +5 (to 180) + 176 load_var 1 (resp) + 177 load_field 2 (promptFeedback) + 178 load_field 0 (0) + 179 jump +2 (to 181) + 180 load_const 3 (null) + 181 load_const 3 (null) + 182 call 635 ntypeargs=0 (baml.ops.equals_equals) + 183 store_var 24 (_71) + + 324 184 load_var 4 (has_call) + 185 pop_jump_if_false +2 (to 187) + 186 jump +40 (to 226) + + 326 187 load_var 7 (finish) + 188 load_const 20 ("MAX_TOKENS") + 189 cmp_op == + 190 pop_jump_if_false +2 (to 192) + 191 jump +31 (to 222) + + 323 192 load_var 24 (_71) + 193 unary_op ! + 194 jump_if_false +2 (to 196) + 195 jump +5 (to 200) + 196 pop 1 + + 328 197 load_var 7 (finish) + 198 load_const 21 ("SAFETY") + 199 cmp_op == + 200 jump_if_false +2 (to 202) + 201 jump +5 (to 206) + 202 pop 1 + 203 load_var 7 (finish) + 204 load_const 22 ("RECITATION") + 205 cmp_op == + 206 jump_if_false +2 (to 208) + 207 jump +5 (to 212) + 208 pop 1 + 209 load_var 7 (finish) + 210 load_const 23 ("PROHIBITED_CONTENT") + 211 cmp_op == + 212 pop_jump_if_false +2 (to 214) + 213 jump +5 (to 218) + + 331 214 load_const 2 (ai.content.StopReason.Complete) + 215 alloc_variant 436 (ai.content.StopReason) + 216 store_var 25 (stop) + + 328 217 jump +12 (to 229) + + 329 218 load_const 24 (ai.content.StopReason.Refused) + 219 alloc_variant 436 (ai.content.StopReason) + 220 store_var 25 (stop) + + 328 221 jump +8 (to 229) + + 327 222 load_const 25 (ai.content.StopReason.MaxTokens) + 223 alloc_variant 436 (ai.content.StopReason) + 224 store_var 25 (stop) + + 326 225 jump +4 (to 229) + + 325 226 load_const 12 (ai.content.StopReason.ToolUse) + 227 alloc_variant 436 (ai.content.StopReason) + 228 store_var 25 (stop) + + 333 229 load_var 1 (resp) + 230 load_field 1 (usageMetadata) + 231 store_var 27 (_85) + 232 load_var 27 (_85) + 233 narrow_bind 26 27 + 234 pop_jump_if_false +2 (to 236) + 235 jump +4 (to 239) + + 341 236 load_const 3 (null) + 237 store_var 26 (usage) + + 333 238 jump +30 (to 268) + 239 load_var 27 (_85) + 240 store_var 28 (um) + + 335 241 load_var 28 (um) + 242 load_field 0 (promptTokenCount) + 243 store_var 30 (_88) + 244 load_var 30 (_88) + 245 store_var 29 (_87) + 246 load_var 30 (_88) + 247 load_const 3 (null) + 248 cmp_op == + 249 pop_jump_if_false +3 (to 252) + 250 load_const 2 (0) + 251 store_var 29 (_87) + + 336 252 load_var 28 (um) + 253 load_field 1 (candidatesTokenCount) + 254 store_var 32 (_91) + 255 load_var 32 (_91) + 256 store_var 31 (_90) + 257 load_var 32 (_91) + 258 load_const 3 (null) + 259 cmp_op == + 260 pop_jump_if_false +3 (to 263) + 261 load_const 2 (0) + 262 store_var 31 (_90) + + 334 263 load_var2 29 31 + 264 load_const 3 (null) + 265 load_const 3 (null) + 266 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 267 store_var 26 (usage) + + 343 268 load_var2 3 25 + 269 load_var 26 (usage) + 270 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 271 return +} + +function google.internal.google_render(c: google.GoogleClient, input: ai.ModelTurnInput) -> baml.http.Request { + 216 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 885 ntypeargs=0 (google.internal._google_request) + 3 return +} + +function google.internal.invoke(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 351 0 load_var 2 (input) + 1 load_field 1 (journal) + 2 call 783 ntypeargs=0 (ai.Journal.entries) + 3 container_len + 4 store_var 3 (seq) + + 352 5 load_var2 1 2 + 6 call 884 ntypeargs=0 (google.internal.google_render) + 7 store_var 4 (req) + + 353 8 load_type 0 + 9 load_var 4 (req) + 10 load_const 1 ("google") + 11 call 804 ntypeargs=1 (ai.wire.send_as) + + 354 12 load_var 3 (seq) + 13 call 886 ntypeargs=0 (google.internal.google_parse) + 14 return +} + +function google.internal.invoke_stream(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 432 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 885 ntypeargs=0 (google.internal._google_request) + + 433 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 437 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 435 15 load_const 3 ("google") + + 437 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 442 22 load_const 6 (google.internal._google_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function openai.OpenAiClient.ai.Client.id(self: openai.OpenAiClient) -> string { + 58 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 2 (_2) + 5 load_const 1 ("openai/") + 6 load_var 2 (_2) + 7 bin_op + + 8 return +} + +function openai.OpenAiClient.ai.Client.invoke(self: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 62 0 load_var2 1 2 + 1 call 857 ntypeargs=0 (openai.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 63 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function openai.OpenAiClient.ai.stream.StreamingClient.invoke_stream(self: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 70 0 load_var2 1 2 + 1 call 859 ntypeargs=0 (openai.internal.invoke_stream) + 2 return +} + +function openai.OpenAiClient.new(model: string, api_key: string | null, base_url: string | null, api_key_env: string | null, base_url_env: string | null) -> openai.OpenAiClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 16 4 load_const 1 ("gpt-4o-mini") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 17 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 18 16 load_const 2 (null) + 17 store_var 3 (base_url) + 18 load_var 4 (api_key_env) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 19 22 load_const 2 (null) + 23 store_var 4 (api_key_env) + 24 load_var 5 (base_url_env) + 25 load_const 0 () + 26 cmp_op == + 27 pop_jump_if_false +3 (to 30) + + 20 28 load_const 2 (null) + 29 store_var 5 (base_url_env) + + 22 30 load_var2 1 2 + 31 load_var2 3 4 + 32 load_var 5 (base_url_env) + 33 init_instance 0 (openai.OpenAiClient .model, .api_key, .base_url, .api_key_env, .base_url_env) + 34 return +} + +function openai.OpenAiClient.resolved_api_key(self: openai.OpenAiClient) -> string { + 34 0 load_var 1 (self) + 1 load_field 1 (api_key) + 2 store_var 2 (_3) + 3 load_var 2 (_3) + 4 narrow_bind 0 2 + 5 pop_jump_if_false +2 (to 7) + 6 jump +19 (to 25) + + 37 7 load_var 1 (self) + 8 load_field 3 (api_key_env) + 9 store_var 3 (_6) + 10 load_var 3 (_6) + 11 narrow_bind 0 3 + 12 pop_jump_if_false +8 (to 20) + 13 load_var 3 (_6) + 14 sys_op 210 (baml.env.get) + + 38 15 store_var 4 (_10) + 16 load_var 4 (_10) + 17 narrow_bind 0 4 + 18 pop_jump_if_false +2 (to 20) + 19 jump +4 (to 23) + + 42 20 load_const 1 ("OPENAI_API_KEY") + 21 call 211 ntypeargs=0 (baml.env.get_or_panic) + 22 jump +4 (to 26) + + 38 23 load_var 4 (_10) + + 39 24 jump +2 (to 26) + + 34 25 load_var 2 (_3) + 26 return +} + +function openai.OpenAiClient.resolved_base_url(self: openai.OpenAiClient) -> string | null { + 47 0 load_var 1 (self) + 1 load_field 2 (base_url) + 2 store_var 2 (_3) + 3 load_var 2 (_3) + 4 narrow_bind 0 2 + 5 pop_jump_if_false +2 (to 7) + 6 jump +13 (to 19) + + 50 7 load_var 1 (self) + 8 load_field 4 (base_url_env) + 9 store_var 3 (_6) + 10 load_var 3 (_6) + 11 narrow_bind 0 3 + 12 pop_jump_if_false +2 (to 14) + 13 jump +3 (to 16) + + 53 14 load_const 1 (null) + 15 jump +5 (to 20) + + 50 16 load_var 3 (_6) + 17 sys_op 210 (baml.env.get) + 18 jump +2 (to 20) + + 47 19 load_var 2 (_3) + 20 return +} + +function openai.internal._openai_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 254 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 255 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +121 (to 138) + 18 load_var 4 (_5) + 19 store_var_load_var 5 (raw) + + 256 20 load_field 1 (data) + 21 store_var 6 (_10) + 22 load_var 6 (_10) + 23 narrow_bind 6 6 + 24 pop_jump_if_false -15 (to 9) + + 257 25 load_type 7 + + 256 26 load_var 6 (_10) + 27 call 335 ntypeargs=1 (baml.json.from_string) + 28 jump +4 (to 32) + + 257 29 load_var 7 (e) + 30 throw_if_panic + + 258 31 load_const 8 (null) + + 260 32 store_var 8 (_16) + 33 load_var 8 (_16) + 34 narrow_bind 9 8 + 35 pop_jump_if_false -26 (to 9) + 36 load_var 8 (_16) + 37 store_var 9 (event) + + 261 38 load_var 9 (event) + 39 load_field 0 (type) + 40 store_var 12 (_20) + 41 load_var 12 (_20) + 42 store_var 11 (_19) + 43 load_var 12 (_20) + 44 load_const 8 (null) + 45 cmp_op == + 46 pop_jump_if_false +4 (to 50) + 47 load_var 5 (raw) + 48 load_field 0 (event) + 49 store_var 11 (_19) + 50 load_var 11 (_19) + 51 store_var 10 (t) + 52 load_var 11 (_19) + 53 load_const 8 (null) + 54 cmp_op == + 55 pop_jump_if_false +3 (to 58) + 56 load_const 10 ("") + 57 store_var 10 (t) + + 262 58 load_var 10 (t) + 59 load_const 11 ("response.output_text.delta") + 60 cmp_op == + 61 pop_jump_if_false +2 (to 63) + 62 jump +65 (to 127) + + 270 63 load_var 10 (t) + 64 load_const 12 ("response.completed") + 65 cmp_op == + 66 jump_if_false +2 (to 68) + 67 jump +5 (to 72) + 68 pop 1 + 69 load_var 10 (t) + 70 load_const 13 ("response.incomplete") + 71 cmp_op == + 72 jump_if_false +2 (to 74) + 73 jump +5 (to 78) + 74 pop 1 + 75 load_var 10 (t) + 76 load_const 14 ("response.failed") + 77 cmp_op == + 78 pop_jump_if_false -69 (to 9) + + 271 79 load_var 9 (event) + 80 load_field 2 (response) + 81 store_var 14 (_38) + 82 load_var 14 (_38) + 83 narrow_bind 15 14 + 84 pop_jump_if_false +38 (to 122) + 85 load_var 14 (_38) + 86 call 856 ntypeargs=0 (openai.internal.openai_parse) + 87 store_var 15 (turn) + + 275 88 load_var 15 (turn) + 89 load_field 1 (stop_reason) + 90 store_var 16 (_44) + + 276 91 load_var 15 (turn) + 92 load_field 2 (usage) + 93 load_const 8 (null) + 94 cmp_op == + 95 pop_jump_if_false +2 (to 97) + 96 jump +6 (to 102) + 97 load_var 15 (turn) + 98 load_field 2 (usage) + 99 load_field 0 (0) + 100 store_var 17 (_45) + 101 jump +3 (to 104) + 102 load_const 8 (null) + 103 store_var 17 (_45) + + 277 104 load_var 15 (turn) + 105 load_field 2 (usage) + 106 load_const 8 (null) + 107 cmp_op == + 108 pop_jump_if_false +2 (to 110) + 109 jump +6 (to 115) + 110 load_var 15 (turn) + 111 load_field 2 (usage) + 112 load_field 1 (1) + 113 store_var 18 (_49) + 114 jump +3 (to 117) + 115 load_const 8 (null) + 116 store_var 18 (_49) + + 273 117 load_var2 2 16 + + 274 118 load_var2 17 18 + 119 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 120 call 4 ntypeargs=0 (baml.Array.push) + 121 pop 1 + + 284 122 load_var 2 (out) + 123 alloc_instance 358 ntypeargs=0 (ai.stream.TurnDone) + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + 126 jump -117 (to 9) + + 263 127 load_var 9 (event) + 128 load_field 1 (delta) + 129 store_var 13 (_26) + 130 load_var 13 (_26) + 131 narrow_bind 6 13 + 132 pop_jump_if_false -123 (to 9) + + 264 133 load_var2 2 13 + + 263 134 init_instance 1 (ai.stream.TextDelta .text) + 135 call 4 ntypeargs=0 (baml.Array.push) + 136 pop 1 + 137 jump -128 (to 9) + + 298 138 load_var 2 (out) + 139 return +} + +function openai.internal._openai_request(c: openai.OpenAiClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 128 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 4 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 4 (_5) + 7 call_indirect + + 129 8 call 852 ntypeargs=0 (openai.internal.openai_lower_prompt) + 9 store_var 5 (items) + + 130 10 load_var 2 (input) + 11 load_field 1 (journal) + 12 call 853 ntypeargs=0 (openai.internal.openai_lower_journal) + 13 load_type 0 + 14 load_const 1 ("iter") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 6 (_12) + 17 load_var 6 (_12) + 18 load_type 2 + 19 load_const 3 ("next") + 20 virtual_call nargs=1 ntypeargs=0 + 21 store_var 7 (_13) + 22 load_var 7 (_13) + 23 is_type 4 + 24 pop_jump_if_false +2 (to 26) + 25 jump +5 (to 30) + + 131 26 load_var2 5 7 + + 130 27 call 4 ntypeargs=0 (baml.Array.push) + 28 pop 1 + 29 jump -12 (to 17) + + 133 30 load_type 5 + 31 load_type 6 + 32 alloc_map 0 + 33 store_var 8 (body) + + 134 34 load_type 5 + 35 load_type 6 + 36 load_var 8 (body) + 37 load_const 7 ("model") + 38 load_var 1 (c) + 39 load_field 0 (model) + 40 call 37 ntypeargs=2 (baml.Map.set) + 41 pop 1 + + 135 42 load_type 5 + 43 load_type 6 + 44 load_var 8 (body) + 45 load_const 8 ("store") + 46 load_const 9 (false) + 47 call 37 ntypeargs=2 (baml.Map.set) + 48 pop 1 + + 136 49 load_type 5 + 50 load_type 6 + 51 load_var 8 (body) + 52 load_const 10 ("input") + 53 load_var 5 (items) + 54 call 37 ntypeargs=2 (baml.Map.set) + 55 pop 1 + + 137 56 load_var 2 (input) + 57 load_field 2 (toolbox) + 58 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 59 unary_op ! + 60 pop_jump_if_false +82 (to 142) + + 138 61 load_type 11 + 62 alloc_array 0 + 63 store_var 9 (tools) + + 139 64 load_var 2 (input) + 65 load_field 2 (toolbox) + 66 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 67 load_type 12 + 68 load_const 13 ("iter") + 69 virtual_call nargs=1 ntypeargs=0 + 70 store_var 10 (_37) + 71 load_var 10 (_37) + 72 load_type 14 + 73 load_const 15 ("next") + 74 virtual_call nargs=1 ntypeargs=0 + 75 store_var 11 (_38) + 76 load_var 11 (_38) + 77 is_type 4 + 78 pop_jump_if_false +2 (to 80) + 79 jump +49 (to 128) + 80 load_var 11 (_38) + 81 store_var 12 (t) + + 140 82 load_type 5 + 83 load_type 6 + 84 alloc_map 0 + 85 store_var 13 (entry) + + 141 86 load_type 5 + 87 load_type 6 + 88 load_var 13 (entry) + 89 load_const 16 ("type") + 90 load_const 17 ("function") + 91 call 37 ntypeargs=2 (baml.Map.set) + 92 pop 1 + + 142 93 load_type 5 + 94 load_type 6 + 95 load_var 13 (entry) + 96 load_const 18 ("name") + 97 load_var 12 (t) + 98 load_field 0 (name) + 99 call 37 ntypeargs=2 (baml.Map.set) + 100 pop 1 + + 143 101 load_type 5 + 102 load_type 6 + 103 load_var 13 (entry) + 104 load_const 19 ("description") + 105 load_var 12 (t) + 106 load_field 1 (description) + 107 call 37 ntypeargs=2 (baml.Map.set) + 108 pop 1 + + 144 109 load_type 5 + 110 load_type 6 + 111 load_var 13 (entry) + 112 load_const 20 ("parameters") + 113 load_var 12 (t) + 114 load_field 2 (input_schema) + 115 call 37 ntypeargs=2 (baml.Map.set) + 116 pop 1 + + 145 117 load_type 5 + 118 load_type 6 + 119 load_var 13 (entry) + 120 load_const 21 ("strict") + 121 load_const 9 (false) + 122 call 37 ntypeargs=2 (baml.Map.set) + 123 pop 1 + + 146 124 load_var2 9 13 + 125 call 4 ntypeargs=0 (baml.Array.push) + 126 pop 1 + 127 jump -56 (to 71) + + 148 128 load_type 5 + 129 load_type 6 + 130 load_var 8 (body) + 131 load_const 22 ("tools") + 132 load_var 9 (tools) + 133 call 37 ntypeargs=2 (baml.Map.set) + 134 pop 1 + + 149 135 load_type 5 + 136 load_type 6 + 137 load_var 8 (body) + 138 load_const 23 ("tool_choice") + 139 load_const 24 ("auto") + 140 call 37 ntypeargs=2 (baml.Map.set) + 141 pop 1 + + 154 142 load_var 3 (stream) + 143 pop_jump_if_false +8 (to 151) + + 155 144 load_type 5 + 145 load_type 6 + 146 load_var 8 (body) + 147 load_const 25 ("stream") + 148 load_const 26 (true) + 149 call 37 ntypeargs=2 (baml.Map.set) + 150 pop 1 + + 162 151 load_var 1 (c) + 152 call 848 ntypeargs=0 (openai.OpenAiClient.resolved_base_url) + 153 store_var 16 (_76) + 154 load_var 16 (_76) + 155 store_var 15 (_75) + 156 load_var 16 (_76) + 157 load_const 27 (null) + 158 cmp_op == + 159 pop_jump_if_false +3 (to 162) + 160 load_const 28 ("https://api.openai.com/v1") + 161 store_var 15 (_75) + 162 load_type 5 + 163 load_var 15 (_75) + 164 call 138 ntypeargs=1 (baml.String.from) + 165 store_var 14 (_74) + + 163 166 load_var 1 (c) + 167 call 847 ntypeargs=0 (openai.OpenAiClient.resolved_api_key) + 168 store_var 18 (_82) + 169 load_type 5 + 170 load_var 18 (_82) + 171 call 138 ntypeargs=1 (baml.String.from) + 172 store_var 17 (_81) + + 164 173 load_type 11 + 174 load_var 8 (body) + 175 call 333 ntypeargs=1 (baml.json.to_json) + 176 call 330 ntypeargs=0 (baml.json.stringify) + 177 store_var 19 (_84) + + 160 178 load_const 29 ("POST") + + 162 179 load_var 14 (_74) + 180 load_const 30 ("/responses") + 181 bin_op + + + 163 182 load_const 31 ("Bearer ") + 183 load_var 17 (_81) + 184 bin_op + + 185 load_const 32 ("application/json") + 186 load_const 33 ("authorization") + 187 load_const 34 ("content-type") + 188 load_type 5 + 189 load_type 5 + 190 alloc_map 2 + 191 load_var 19 (_84) + 192 init_instance 0 (baml.http.Request .method, .url, .headers, .body) + 193 return +} + +function openai.internal.invoke(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 231 0 load_var2 1 2 + 1 call 854 ntypeargs=0 (openai.internal.openai_render) + 2 store_var 3 (req) + + 232 3 load_type 0 + 4 load_var 3 (req) + 5 load_const 1 ("openai") + 6 call 804 ntypeargs=1 (ai.wire.send_as) + + 233 7 call 856 ntypeargs=0 (openai.internal.openai_parse) + 8 return +} + +function openai.internal.invoke_stream(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 304 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 855 ntypeargs=0 (openai.internal._openai_request) + + 305 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 309 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 307 15 load_const 3 ("openai") + + 309 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 314 22 load_const 6 (openai.internal._openai_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function openai.internal.openai_lower_journal(j: ai.Journal) -> map[] { + 57 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (items) + + 58 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +232 (to 249) + 18 load_var 4 (_5) + 19 store_var 5 (e) + + 59 20 load_var 5 (e) + 21 store_var 6 (_9) + 22 load_var 6 (_9) + 23 narrow_bind 6 6 + 24 pop_jump_if_false +2 (to 26) + 25 jump +199 (to 224) + 26 load_var 5 (e) + 27 store_var 9 (_21) + 28 load_var 9 (_21) + 29 narrow_bind 7 9 + 30 pop_jump_if_false +2 (to 32) + 31 jump +94 (to 125) + 32 load_var 5 (e) + 33 store_var 20 (_64) + 34 load_var 20 (_64) + 35 narrow_bind 8 20 + 36 pop_jump_if_false +2 (to 38) + 37 jump +55 (to 92) + 38 load_var 5 (e) + 39 store_var 23 (_80) + 40 load_var 23 (_80) + 41 narrow_bind 9 23 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 23 (_80) + 44 store_var 24 (f) + + 101 45 load_type 10 + 46 load_type 11 + 47 alloc_map 0 + 48 store_var 25 (err) + + 102 49 load_type 10 + 50 load_type 11 + 51 load_var 25 (err) + 52 load_const 12 ("error") + 53 load_var 24 (f) + 54 load_field 1 (message) + 55 call 37 ntypeargs=2 (baml.Map.set) + 56 pop 1 + + 103 57 load_type 10 + 58 load_type 11 + 59 alloc_map 0 + 60 store_var 26 (m) + + 104 61 load_type 10 + 62 load_type 11 + 63 load_var 26 (m) + 64 load_const 13 ("type") + 65 load_const 14 ("function_call_output") + 66 call 37 ntypeargs=2 (baml.Map.set) + 67 pop 1 + + 105 68 load_type 10 + 69 load_type 11 + 70 load_var 26 (m) + 71 load_const 15 ("call_id") + 72 load_var 24 (f) + 73 load_field 0 (id) + 74 call 37 ntypeargs=2 (baml.Map.set) + 75 pop 1 + + 106 76 load_type 0 + 77 load_var 25 (err) + 78 call 333 ntypeargs=1 (baml.json.to_json) + 79 call 330 ntypeargs=0 (baml.json.stringify) + 80 store_var 27 (_96) + 81 load_type 10 + 82 load_type 11 + 83 load_var 26 (m) + 84 load_const 16 ("output") + 85 load_var 27 (_96) + 86 call 37 ntypeargs=2 (baml.Map.set) + 87 pop 1 + + 107 88 load_var2 2 26 + 89 call 4 ntypeargs=0 (baml.Array.push) + 90 pop 1 + 91 jump -82 (to 9) + + 59 92 load_var 20 (_64) + 93 store_var 21 (c) + + 93 94 load_type 10 + 95 load_type 11 + 96 alloc_map 0 + 97 store_var 22 (m) + + 94 98 load_type 10 + 99 load_type 11 + 100 load_var 22 (m) + 101 load_const 17 ("type") + 102 load_const 18 ("function_call_output") + 103 call 37 ntypeargs=2 (baml.Map.set) + 104 pop 1 + + 95 105 load_type 10 + 106 load_type 11 + 107 load_var 22 (m) + 108 load_const 19 ("call_id") + 109 load_var 21 (c) + 110 load_field 0 (id) + 111 call 37 ntypeargs=2 (baml.Map.set) + 112 pop 1 + + 96 113 load_type 10 + 114 load_type 11 + 115 load_var 22 (m) + 116 load_const 20 ("output") + 117 load_var 21 (c) + 118 load_field 1 (output) + 119 call 37 ntypeargs=2 (baml.Map.set) + 120 pop 1 + + 97 121 load_var2 2 22 + 122 call 4 ntypeargs=0 (baml.Array.push) + 123 pop 1 + 124 jump -115 (to 9) + + 59 125 load_var 9 (_21) + 126 load_field 0 (content) + 127 load_type 21 + 128 load_const 22 ("iter") + 129 virtual_call nargs=1 ntypeargs=0 + 130 store_var 10 (_24) + + 68 131 load_var 10 (_24) + 132 load_type 23 + 133 load_const 24 ("next") + 134 virtual_call nargs=1 ntypeargs=0 + 135 store_var 11 (_25) + 136 load_var 11 (_25) + 137 is_type 5 + 138 pop_jump_if_false +2 (to 140) + 139 jump -130 (to 9) + 140 load_var 11 (_25) + 141 store_var 12 (b) + + 69 142 load_var 12 (b) + 143 store_var 13 (_29) + 144 load_var 13 (_29) + 145 narrow_bind 25 13 + 146 pop_jump_if_false +2 (to 148) + 147 jump +52 (to 199) + 148 load_var 12 (b) + 149 store_var 16 (_41) + 150 load_var 16 (_41) + 151 narrow_bind 26 16 + 152 pop_jump_if_false -21 (to 131) + 153 load_var 16 (_41) + 154 store_var 17 (use) + + 78 155 load_type 10 + 156 load_type 11 + 157 alloc_map 0 + 158 store_var 18 (m) + + 79 159 load_type 10 + 160 load_type 11 + 161 load_var 18 (m) + 162 load_const 27 ("type") + 163 load_const 28 ("function_call") + 164 call 37 ntypeargs=2 (baml.Map.set) + 165 pop 1 + + 80 166 load_type 10 + 167 load_type 11 + 168 load_var 18 (m) + 169 load_const 29 ("call_id") + 170 load_var 17 (use) + 171 load_field 0 (id) + 172 call 37 ntypeargs=2 (baml.Map.set) + 173 pop 1 + + 81 174 load_type 10 + 175 load_type 11 + 176 load_var 18 (m) + 177 load_const 30 ("name") + 178 load_var 17 (use) + 179 load_field 1 (name) + 180 call 37 ntypeargs=2 (baml.Map.set) + 181 pop 1 + + 82 182 load_type 0 + 183 load_var 17 (use) + 184 load_field 2 (args) + 185 call 333 ntypeargs=1 (baml.json.to_json) + 186 call 330 ntypeargs=0 (baml.json.stringify) + 187 store_var 19 (_56) + 188 load_type 10 + 189 load_type 11 + 190 load_var 18 (m) + 191 load_const 31 ("arguments") + 192 load_var 19 (_56) + 193 call 37 ntypeargs=2 (baml.Map.set) + 194 pop 1 + + 83 195 load_var2 2 18 + 196 call 4 ntypeargs=0 (baml.Array.push) + 197 pop 1 + 198 jump -67 (to 131) + + 69 199 load_var 13 (_29) + 200 store_var 14 (t) + + 71 201 load_type 10 + 202 load_type 11 + 203 alloc_map 0 + 204 store_var 15 (m) + + 72 205 load_type 10 + 206 load_type 11 + 207 load_var 15 (m) + 208 load_const 32 ("role") + 209 load_const 33 ("assistant") + 210 call 37 ntypeargs=2 (baml.Map.set) + 211 pop 1 + + 73 212 load_type 10 + 213 load_type 11 + 214 load_var 15 (m) + 215 load_const 34 ("content") + 216 load_var 14 (t) + 217 load_field 0 (text) + 218 call 37 ntypeargs=2 (baml.Map.set) + 219 pop 1 + + 74 220 load_var2 2 15 + 221 call 4 ntypeargs=0 (baml.Array.push) + 222 pop 1 + 223 jump -92 (to 131) + + 59 224 load_var 6 (_9) + 225 store_var 7 (u) + + 61 226 load_type 10 + 227 load_type 11 + 228 alloc_map 0 + 229 store_var 8 (m) + + 62 230 load_type 10 + 231 load_type 11 + 232 load_var 8 (m) + 233 load_const 35 ("role") + 234 load_const 36 ("user") + 235 call 37 ntypeargs=2 (baml.Map.set) + 236 pop 1 + + 63 237 load_type 10 + 238 load_type 11 + 239 load_var 8 (m) + 240 load_const 37 ("content") + 241 load_var 7 (u) + 242 load_field 0 (content) + 243 call 37 ntypeargs=2 (baml.Map.set) + 244 pop 1 + + 64 245 load_var2 2 8 + 246 call 4 ntypeargs=0 (baml.Array.push) + 247 pop 1 + 248 jump -239 (to 9) + + 113 249 load_var 2 (items) + 250 return +} + +function openai.internal.openai_lower_prompt(prompt: ai.Prompt) -> map[] { + 37 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (items) + + 38 3 load_var 1 (prompt) + 4 call 787 ntypeargs=0 (ai.Prompt.messages) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +46 (to 63) + 18 load_var 4 (_5) + 19 store_var_load_var 5 (message) + + 39 20 load_field 0 (role) + 21 load_const 6 ("") + 22 cmp_op == + 23 pop_jump_if_false +2 (to 25) + 24 jump +14 (to 38) + + 41 25 load_var 5 (message) + 26 load_field 0 (role) + 27 load_const 7 ("tool") + 28 cmp_op == + 29 pop_jump_if_false +2 (to 31) + 30 jump +5 (to 35) + + 44 31 load_var 5 (message) + 32 load_field 0 (role) + 33 store_var 6 (role) + + 41 34 jump +6 (to 40) + + 42 35 load_const 8 ("user") + 36 store_var 6 (role) + + 41 37 jump +3 (to 40) + + 40 38 load_const 9 ("user") + 39 store_var 6 (role) + + 46 40 load_type 10 + 41 load_type 11 + 42 alloc_map 0 + 43 store_var 7 (item) + + 47 44 load_type 10 + 45 load_type 11 + 46 load_var 7 (item) + 47 load_const 12 ("role") + 48 load_var 6 (role) + 49 call 37 ntypeargs=2 (baml.Map.set) + 50 pop 1 + + 48 51 load_type 10 + 52 load_type 11 + 53 load_var 7 (item) + 54 load_const 13 ("content") + 55 load_var 5 (message) + 56 load_field 1 (content) + 57 call 37 ntypeargs=2 (baml.Map.set) + 58 pop 1 + + 49 59 load_var2 2 7 + 60 call 4 ntypeargs=0 (baml.Array.push) + 61 pop 1 + 62 jump -53 (to 9) + + 51 63 load_var 2 (items) + 64 return +} + +function openai.internal.openai_parse(resp: openai.internal.OaResponse) -> ai.ModelTurn { + 170 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (content) + + 171 3 load_const 1 (false) + 4 store_var 3 (has_call) + + 172 5 load_var 1 (resp) + 6 load_field 1 (output) + 7 load_type 2 + 8 load_const 3 ("iter") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 4 (_5) + 11 load_var 4 (_5) + 12 load_type 4 + 13 load_const 5 ("next") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 5 (_6) + 16 load_var 5 (_6) + 17 is_type 6 + 18 pop_jump_if_false +2 (to 20) + 19 jump +159 (to 178) + 20 load_var 5 (_6) + 21 store_var_load_var 6 (item) + + 173 22 load_field 0 (type) + 23 load_const 7 ("function_call") + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +108 (to 134) + + 183 27 load_var 6 (item) + 28 load_field 0 (type) + 29 load_const 8 ("message") + 30 cmp_op == + 31 pop_jump_if_false +2 (to 33) + 32 jump +43 (to 75) + + 194 33 load_var 6 (item) + 34 load_field 0 (type) + 35 load_const 9 ("reasoning") + 36 cmp_op == + 37 pop_jump_if_false -26 (to 11) + + 195 38 load_var 6 (item) + 39 load_field 5 (summary) + 40 store_var 23 (_50) + 41 load_var 23 (_50) + 42 store_var 22 (parts) + 43 load_var 23 (_50) + 44 load_const 10 (null) + 45 cmp_op == + 46 pop_jump_if_false +4 (to 50) + 47 load_type 11 + 48 alloc_array 0 + 49 store_var 22 (parts) + + 196 50 load_var 22 (parts) + 51 load_type 12 + 52 load_const 13 ("iter") + 53 virtual_call nargs=1 ntypeargs=0 + 54 store_var 24 (_53) + 55 load_var 24 (_53) + 56 load_type 14 + 57 load_const 15 ("next") + 58 virtual_call nargs=1 ntypeargs=0 + 59 store_var 25 (_54) + 60 load_var 25 (_54) + 61 is_type 6 + 62 pop_jump_if_false +2 (to 64) + 63 jump -52 (to 11) + 64 load_var 25 (_54) + 65 load_field 1 (text) + 66 store_var 26 (_59) + + 197 67 load_var 26 (_59) + 68 narrow_bind 16 26 + 69 pop_jump_if_false -14 (to 55) + + 198 70 load_var2 2 26 + + 197 71 init_instance 0 (ai.content.Reasoning .summary) + 72 call 4 ntypeargs=0 (baml.Array.push) + 73 pop 1 + 74 jump -19 (to 55) + + 184 75 load_var 6 (item) + 76 load_field 4 (content) + 77 store_var 14 (_30) + 78 load_var 14 (_30) + 79 store_var 13 (parts) + 80 load_var 14 (_30) + 81 load_const 10 (null) + 82 cmp_op == + 83 pop_jump_if_false +4 (to 87) + 84 load_type 11 + 85 alloc_array 0 + 86 store_var 13 (parts) + + 185 87 load_var 13 (parts) + 88 load_type 12 + 89 load_const 17 ("iter") + 90 virtual_call nargs=1 ntypeargs=0 + 91 store_var 15 (_33) + 92 load_var 15 (_33) + 93 load_type 14 + 94 load_const 18 ("next") + 95 virtual_call nargs=1 ntypeargs=0 + 96 store_var 16 (_34) + 97 load_var 16 (_34) + 98 is_type 6 + 99 pop_jump_if_false +2 (to 101) + 100 jump -89 (to 11) + 101 load_var 16 (_34) + 102 store_var 17 (part) + + 186 103 load_var 17 (part) + 104 load_field 0 (type) + 105 store_var 19 (_40) + 106 load_var 19 (_40) + 107 store_var 18 (_39) + 108 load_var 19 (_40) + 109 load_const 10 (null) + 110 cmp_op == + 111 pop_jump_if_false +3 (to 114) + 112 load_const 19 ("") + 113 store_var 18 (_39) + 114 load_var 18 (_39) + 115 load_const 20 ("output_text") + 116 cmp_op == + 117 pop_jump_if_false -25 (to 92) + + 187 118 load_var 17 (part) + 119 load_field 1 (text) + 120 store_var 21 (_45) + 121 load_var 21 (_45) + 122 store_var 20 (_44) + 123 load_var 21 (_45) + 124 load_const 10 (null) + 125 cmp_op == + 126 pop_jump_if_false +3 (to 129) + 127 load_const 21 ("") + 128 store_var 20 (_44) + 129 load_var2 2 20 + 130 init_instance 1 (ai.content.Text .text) + 131 call 4 ntypeargs=0 (baml.Array.push) + 132 pop 1 + 133 jump -41 (to 92) + + 174 134 load_const 22 (true) + 135 store_var 3 (has_call) + + 175 136 load_type 23 + 137 load_type 24 + 138 alloc_map 0 + 139 store_var 7 (args) + + 176 140 load_var 6 (item) + 141 load_field 3 (arguments) + 142 store_var 8 (_14) + 143 load_var 8 (_14) + 144 narrow_bind 16 8 + 145 pop_jump_if_false +5 (to 150) + + 177 146 load_type 25 + + 176 147 load_var 8 (_14) + 148 call 335 ntypeargs=1 (baml.json.from_string) + 149 store_var 7 (args) + + 180 150 load_var 6 (item) + 151 load_field 1 (call_id) + 152 store_var 10 (_21) + 153 load_var 10 (_21) + 154 store_var 9 (_20) + 155 load_var 10 (_21) + 156 load_const 10 (null) + 157 cmp_op == + 158 pop_jump_if_false +3 (to 161) + 159 load_const 26 ("") + 160 store_var 9 (_20) + 161 load_var 6 (item) + 162 load_field 2 (name) + 163 store_var 12 (_24) + 164 load_var 12 (_24) + 165 store_var 11 (_23) + 166 load_var 12 (_24) + 167 load_const 10 (null) + 168 cmp_op == + 169 pop_jump_if_false +3 (to 172) + 170 load_const 27 ("") + 171 store_var 11 (_23) + + 179 172 load_var2 2 9 + + 180 173 load_var2 11 7 + 174 init_instance 2 (ai.content.ToolUse .id, .name, .args) + 175 call 4 ntypeargs=0 (baml.Array.push) + 176 pop 1 + 177 jump -166 (to 11) + + 209 178 load_var 3 (has_call) + 179 pop_jump_if_false +2 (to 181) + 180 jump +25 (to 205) + + 211 181 load_var 1 (resp) + 182 load_field 0 (status) + 183 store_var 29 (_68) + 184 load_var 29 (_68) + 185 store_var 28 (_67) + 186 load_var 29 (_68) + 187 load_const 10 (null) + 188 cmp_op == + 189 pop_jump_if_false +3 (to 192) + 190 load_const 28 ("") + 191 store_var 28 (_67) + 192 load_var 28 (_67) + 193 load_const 29 ("incomplete") + 194 cmp_op == + 195 pop_jump_if_false +2 (to 197) + 196 jump +5 (to 201) + + 214 197 load_const 30 (ai.content.StopReason.Complete) + 198 alloc_variant 436 (ai.content.StopReason) + 199 store_var 27 (stop) + + 211 200 jump +8 (to 208) + + 212 201 load_const 31 (ai.content.StopReason.MaxTokens) + 202 alloc_variant 436 (ai.content.StopReason) + 203 store_var 27 (stop) + + 211 204 jump +4 (to 208) + + 210 205 load_const 16 (ai.content.StopReason.ToolUse) + 206 alloc_variant 436 (ai.content.StopReason) + 207 store_var 27 (stop) + + 216 208 load_var 1 (resp) + 209 load_field 2 (usage) + 210 store_var 31 (_72) + 211 load_var 31 (_72) + 212 narrow_bind 32 31 + 213 pop_jump_if_false +2 (to 215) + 214 jump +4 (to 218) + + 224 215 load_const 10 (null) + 216 store_var 30 (usage) + + 216 217 jump +10 (to 227) + 218 load_var 31 (_72) + 219 store_var_load_var 32 (u) + + 218 220 load_field 0 (input_tokens) + + 219 221 load_var 32 (u) + 222 load_field 1 (output_tokens) + 223 load_const 10 (null) + 224 load_const 10 (null) + 225 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 226 store_var 30 (usage) + + 226 227 load_var2 2 27 + 228 load_var 30 (usage) + 229 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 230 return +} + +function openai.internal.openai_render(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> baml.http.Request { + 118 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 855 ntypeargs=0 (openai.internal._openai_request) + 3 return +} + +function reflect.call_any(f: baml.AnyFunction, args: map) -> #0 { +} + +function reflect.signature(f: baml.AnyFunction) -> reflect.Signature { +} + +function testing.$invoke_collector(collector: (testing.TestCollector) -> void throws unknown, c: testing.TestCollector) -> void { + 143 0 load_var2 2 1 + 1 call_indirect + 2 return +} + +function testing.FailFast() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 104 0 make_closure 1596 0 + 1 return +} + +function testing.PassRate(threshold: float) -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 70 3 load_deref 1 + 4 load_const 0 (0.0) + 5 cmp_float_op < + 6 jump_if_false +2 (to 8) + 7 jump +5 (to 12) + 8 pop 1 + 9 load_deref 1 + 10 load_const 1 (1.0) + 11 cmp_float_op > + 12 pop_jump_if_false +4 (to 16) + + 71 13 load_const 2 ("testing.PassRate requires 0.0 <= threshold <= 1.0") + 14 call 260 ntypeargs=0 (baml.sys.panic) + 15 pop 1 + + 76 16 load_var 1 (threshold) + 17 make_closure 1591 1 + 18 return +} + +function testing.Quorum(n: int, m: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 2 6 load_deref 1 + 7 load_const 0 (0) + 8 cmp_int_op <= + 9 pop_jump_if_false +2 (to 11) + 10 jump +15 (to 25) + + 4 11 load_deref 2 + 12 load_const 0 (0) + 13 cmp_int_op < + 14 jump_if_false +2 (to 16) + 15 jump +5 (to 20) + 16 pop 1 + 17 load_deref 2 + 18 load_deref 1 + 19 cmp_int_op > + 20 pop_jump_if_false +8 (to 28) + + 5 21 load_const 1 ("testing.Quorum requires 0 <= m <= n") + 22 call 260 ntypeargs=0 (baml.sys.panic) + 23 pop 1 + 24 jump +4 (to 28) + + 3 25 load_const 2 ("testing.Quorum requires n > 0") + 26 call 260 ntypeargs=0 (baml.sys.panic) + 27 pop 1 + + 10 28 load_var2 1 2 + 29 make_closure 1575 2 + 30 return +} + +function testing.Retry(max_attempts: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 36 3 load_deref 1 + 4 load_const 0 (0) + 5 cmp_int_op <= + 6 pop_jump_if_false +4 (to 10) + + 37 7 load_const 1 ("testing.Retry requires max_attempts > 0") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 pop 1 + + 42 10 load_var 1 (max_attempts) + 11 make_closure 1585 1 + 12 return +} + +function testing.Sequential() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 98 0 make_closure 1594 0 + 1 return +} + +function testing.TestCollector.find_test(self: testing.TestCollector, name: string) -> testing.TestRegistration { + 131 0 load_var 1 (self) + 1 load_field 1 (tests) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 3 (_4) + 6 load_var 3 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 4 (_5) + 11 load_var 4 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +9 (to 23) + 15 load_var 4 (_5) + 16 store_var_load_var 5 (t) + + 132 17 load_field 0 (name) + 18 load_var 2 (name) + 19 cmp_op == + 20 pop_jump_if_false -14 (to 6) + + 133 21 load_var 5 (t) + 22 return + + 136 23 load_const 5 ("Test not found: ") + 24 load_var 2 (name) + 25 bin_op + + 26 throw +} + +function testing.TestCollector.find_testset(self: testing.TestCollector, name: string) -> testing.TestSetRegistration { + 122 0 load_var 1 (self) + 1 load_field 2 (testsets) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 3 (_4) + 6 load_var 3 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 4 (_5) + 11 load_var 4 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +9 (to 23) + 15 load_var 4 (_5) + 16 store_var_load_var 5 (ts) + + 123 17 load_field 0 (name) + 18 load_var 2 (name) + 19 cmp_op == + 20 pop_jump_if_false -14 (to 6) + + 124 21 load_var 5 (ts) + 22 return + + 127 23 load_const 5 ("TestSet not found: ") + 24 load_var 2 (name) + 25 bin_op + + 26 throw +} + +function testing.TestCollector.new(prefix: string) -> testing.TestCollector { + 30 0 load_var 1 (prefix) + 1 load_type 0 + 2 alloc_array 0 + 3 load_type 1 + 4 alloc_array 0 + 5 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 6 return +} + +function testing.TestCollector.register_test(self: testing.TestCollector, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { + 34 0 load_var 2 (name) + 1 load_const 0 ("::") + 2 call 147 ntypeargs=0 (baml.String.includes) + 3 pop_jump_if_false +2 (to 5) + 4 jump +87 (to 91) + + 39 5 load_var 1 (self) + 6 load_field 0 (prefix) + 7 load_const 1 ("") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +9 (to 19) + + 42 11 load_var 1 (self) + 12 load_field 0 (prefix) + 13 load_const 2 ("::") + 14 bin_op + + 15 load_var 2 (name) + 16 bin_op + + 17 store_var 5 (full_name) + + 39 18 jump +3 (to 21) + + 40 19 load_var 2 (name) + 20 store_var 5 (full_name) + + 44 21 load_const 3 (0) + 22 store_var 6 (count) + + 45 23 load_var 5 (full_name) + 24 load_const 4 ("#") + 25 bin_op + + 26 store_var 7 (hash_prefix) + + 46 27 load_var 1 (self) + 28 load_field 1 (tests) + 29 load_type 5 + 30 load_const 6 ("iter") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 8 (_17) + 33 load_var 8 (_17) + 34 load_type 7 + 35 load_const 8 ("next") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 9 (_18) + 38 load_var 9 (_18) + 39 is_type 9 + 40 pop_jump_if_false +2 (to 42) + 41 jump +19 (to 60) + 42 load_var 9 (_18) + 43 store_var_load_var 10 (t) + + 47 44 load_field 0 (name) + 45 load_var 5 (full_name) + 46 cmp_op == + 47 jump_if_false +2 (to 49) + 48 jump +6 (to 54) + 49 pop 1 + 50 load_var 10 (t) + 51 load_field 0 (name) + 52 load_var 7 (hash_prefix) + 53 call 148 ntypeargs=0 (baml.String.starts_with) + 54 pop_jump_if_false -21 (to 33) + + 48 55 load_var 6 (count) + 56 load_const 10 (1) + 57 add_int + 58 store_var 6 (count) + + 47 59 jump -26 (to 33) + + 53 60 load_var 6 (count) + 61 load_const 3 (0) + 62 cmp_int_op > + 63 pop_jump_if_false +2 (to 65) + 64 jump +4 (to 68) + + 56 65 load_var 5 (full_name) + 66 store_var 11 (final_name) + + 53 67 jump +14 (to 81) + + 54 68 load_var 5 (full_name) + 69 load_const 11 ("#") + 70 bin_op + + 71 store_var 12 (_31) + 72 load_type 12 + 73 load_var 6 (count) + 74 load_const 10 (1) + 75 add_int + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 13 (_33) + 78 load_var2 12 13 + 79 bin_op + + 80 store_var 11 (final_name) + + 58 81 load_type 13 + 82 load_var 1 (self) + 83 load_field 1 (tests) + 84 load_var2 11 3 + 85 load_var 4 (runner) + 86 init_instance 0 (testing.TestRegistration .name, .body, .runner) + 87 call 4 ntypeargs=1 (baml.Array.push) + 88 pop 1 + + 33 89 load_const 14 (null) + 90 return + + 35 91 load_const 15 ("test name may not contain reserved separator `::`: ") + 92 load_var 2 (name) + 93 bin_op + + 94 init_instance 1 (testing.InvalidTestName .message) + 95 throw +} + +function testing.TestCollector.register_test_at(self: testing.TestCollector, owner: string, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { + 106 0 load_var2 2 1 + 1 load_field 1 (tests) + 2 load_var 1 (self) + 3 load_field 2 (testsets) + 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 5 load_var2 3 4 + 6 load_var 5 (runner) + 7 call 721 ntypeargs=0 (testing.TestCollector.register_test) + 8 return +} + +function testing.TestCollector.register_test_set(self: testing.TestCollector, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { + 67 0 load_var 2 (name) + 1 load_const 0 ("::") + 2 call 147 ntypeargs=0 (baml.String.includes) + 3 pop_jump_if_false +2 (to 5) + 4 jump +87 (to 91) + + 72 5 load_var 1 (self) + 6 load_field 0 (prefix) + 7 load_const 1 ("") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +9 (to 19) + + 75 11 load_var 1 (self) + 12 load_field 0 (prefix) + 13 load_const 2 ("::") + 14 bin_op + + 15 load_var 2 (name) + 16 bin_op + + 17 store_var 5 (full_name) + + 72 18 jump +3 (to 21) + + 73 19 load_var 2 (name) + 20 store_var 5 (full_name) + + 77 21 load_const 3 (0) + 22 store_var 6 (count) + + 78 23 load_var 5 (full_name) + 24 load_const 4 ("#") + 25 bin_op + + 26 store_var 7 (hash_prefix) + + 79 27 load_var 1 (self) + 28 load_field 2 (testsets) + 29 load_type 5 + 30 load_const 6 ("iter") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 8 (_17) + 33 load_var 8 (_17) + 34 load_type 7 + 35 load_const 8 ("next") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 9 (_18) + 38 load_var 9 (_18) + 39 is_type 9 + 40 pop_jump_if_false +2 (to 42) + 41 jump +19 (to 60) + 42 load_var 9 (_18) + 43 store_var_load_var 10 (ts) + + 80 44 load_field 0 (name) + 45 load_var 5 (full_name) + 46 cmp_op == + 47 jump_if_false +2 (to 49) + 48 jump +6 (to 54) + 49 pop 1 + 50 load_var 10 (ts) + 51 load_field 0 (name) + 52 load_var 7 (hash_prefix) + 53 call 148 ntypeargs=0 (baml.String.starts_with) + 54 pop_jump_if_false -21 (to 33) + + 81 55 load_var 6 (count) + 56 load_const 10 (1) + 57 add_int + 58 store_var 6 (count) + + 80 59 jump -26 (to 33) + + 86 60 load_var 6 (count) + 61 load_const 3 (0) + 62 cmp_int_op > + 63 pop_jump_if_false +2 (to 65) + 64 jump +4 (to 68) + + 89 65 load_var 5 (full_name) + 66 store_var 11 (final_name) + + 86 67 jump +14 (to 81) + + 87 68 load_var 5 (full_name) + 69 load_const 11 ("#") + 70 bin_op + + 71 store_var 12 (_31) + 72 load_type 12 + 73 load_var 6 (count) + 74 load_const 10 (1) + 75 add_int + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 13 (_33) + 78 load_var2 12 13 + 79 bin_op + + 80 store_var 11 (final_name) + + 91 81 load_type 13 + 82 load_var 1 (self) + 83 load_field 2 (testsets) + + 92 84 load_var2 11 3 + 85 load_var 4 (runner) + 86 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) + 87 call 4 ntypeargs=1 (baml.Array.push) + 88 pop 1 + + 66 89 load_const 14 (null) + 90 return + + 68 91 load_const 15 ("testset name may not contain reserved separator `::`: ") + 92 load_var 2 (name) + 93 bin_op + + 94 init_instance 1 (testing.InvalidTestName .message) + 95 throw +} + +function testing.TestCollector.register_test_set_at(self: testing.TestCollector, owner: string, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { + 117 0 load_var2 2 1 + 1 load_field 1 (tests) + 2 load_var 1 (self) + 3 load_field 2 (testsets) + 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 5 load_var2 3 4 + 6 load_var 5 (runner) + 7 call 722 ntypeargs=0 (testing.TestCollector.register_test_set) + 8 return +} + +function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: string) -> (testing.SerializedTest | testing.SerializedTestSet)[] { + 288 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 2 (testsets) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +13 (to 28) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (ts) + + 289 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 290 22 load_var2 1 5 + 23 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 24 pop 1 + + 291 25 load_var 1 (self) + 26 call 729 ntypeargs=0 (testing.TestRegistry.serialize) + 27 jump +33 (to 60) + + 295 28 load_type 5 + 29 load_type 6 + 30 load_var 1 (self) + 31 load_field 1 (expansions) + 32 call 35 ntypeargs=2 (baml.Map.keys) + 33 load_type 7 + 34 load_const 8 ("iter") + 35 virtual_call nargs=1 ntypeargs=0 + 36 store_var 6 (_17) + 37 load_var 6 (_17) + 38 load_type 9 + 39 load_const 10 ("next") + 40 virtual_call nargs=1 ntypeargs=0 + 41 store_var 7 (_18) + 42 load_var 7 (_18) + 43 is_type 4 + 44 pop_jump_if_false +2 (to 46) + 45 jump +16 (to 61) + 46 load_var 7 (_18) + 47 store_var 8 (k) + + 296 48 load_var 1 (self) + 49 load_field 1 (expansions) + 50 load_var 8 (k) + 51 load_map_element + 52 store_var 9 (sub) + + 297 53 load_var2 2 8 + 54 load_const 11 ("::") + 55 bin_op + + 56 call 148 ntypeargs=0 (baml.String.starts_with) + 57 pop_jump_if_false -20 (to 37) + + 298 58 load_var2 9 2 + 59 call 736 ntypeargs=0 (testing.TestRegistry.expand_set) + 60 return + + 301 61 load_const 12 ("TestSet not found for expansion: ") + 62 load_var 2 (name) + 63 bin_op + + 64 throw +} + +function testing.TestRegistry.expand_testset_registry(self: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestRegistry { + 305 0 load_type 0 + 1 load_type 1 + 2 load_var 1 (self) + 3 load_field 1 (expansions) + 4 load_var 2 (ts) + 5 load_field 0 (name) + 6 call 38 ntypeargs=2 (baml.Map.get) + 7 store_var 3 (_8) + 8 load_var 3 (_8) + 9 narrow_bind 2 3 + 10 pop_jump_if_false +2 (to 12) + 11 jump +51 (to 62) + + 308 12 sys_op 522 (baml.time.Instant.now) + 13 store_var 4 (start) + + 309 14 load_var 2 (ts) + 15 load_field 0 (name) + 16 load_type 3 + 17 alloc_array 0 + 18 load_type 4 + 19 alloc_array 0 + 20 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 21 store_var_load_var 5 (sub_collector) + + 310 22 load_var 2 (ts) + 23 load_field 1 (collector) + 24 call_indirect + 25 pop 1 + + 315 26 load_var 4 (start) + 27 call 523 ntypeargs=0 (baml.time.Instant.elapsed) + 28 call 510 ntypeargs=0 (baml.time.Duration.to_milliseconds) + 29 call 92 ntypeargs=0 (baml.Bigint.to_int) + 30 store_var 6 (elapsed) + 31 jump +13 (to 44) + 32 load_var 7 (_) + 33 is_type 5 + 34 pop_jump_if_false +2 (to 36) + 35 jump +3 (to 38) + 36 load_var 7 (_) + 37 rethrow + + 317 38 load_const 6 ("testing: expansion duration: ") + + 315 39 load_var 7 (_) + 40 load_field 0 (0) + 41 bin_op + + 42 call 260 ntypeargs=0 (baml.sys.panic) + 43 store_var 6 (elapsed) + + 320 44 load_var 5 (sub_collector) + 45 load_type 0 + 46 load_type 1 + 47 alloc_map 0 + 48 load_var 6 (elapsed) + 49 init_instance 1 (testing.TestRegistry .collector, .expansions, .loading_time_ms) + 50 store_var 8 (sub_registry) + + 321 51 load_type 0 + 52 load_type 1 + 53 load_var 1 (self) + 54 load_field 1 (expansions) + 55 load_var 2 (ts) + 56 load_field 0 (name) + 57 load_var 8 (sub_registry) + 58 call 37 ntypeargs=2 (baml.Map.set) + 59 pop 1 + + 322 60 load_var 8 (sub_registry) + + 305 61 jump +2 (to 63) + 62 load_var 3 (_8) + 63 return +} + +function testing.TestRegistry.list_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 281 0 load_var2 1 2 + 1 load_var2 3 4 + 2 load_var 5 (cli_exclude) + 3 call 757 ntypeargs=0 (testing.select_names_layered) + 4 return +} + +function testing.TestRegistry.new(collector: testing.TestCollector) -> testing.TestRegistry { + 169 0 load_var 1 (collector) + 1 load_type 0 + 2 load_type 1 + 3 alloc_map 0 + 4 load_const 2 (0) + 5 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) + 6 return +} + +function testing.TestRegistry.run_all(self: testing.TestRegistry) -> testing.TestSetReport { + 237 0 load_var 1 (self) + 1 call 738 ntypeargs=0 (testing.testset_children) + 2 load_const 0 (null) + 3 call 748 ntypeargs=0 (testing.run_testset) + 4 return +} + +function testing.TestRegistry.run_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> testing.FlatTestReport { + 259 0 load_var2 1 2 + 1 load_var2 3 4 + 2 load_var 5 (cli_exclude) + 3 call 757 ntypeargs=0 (testing.select_names_layered) + 4 store_var 6 (selected_names) + + 261 5 load_var 2 (profile_include) + 6 container_len + 7 store_var 7 (_12) + 8 load_var 7 (_12) + 9 load_const 0 (0) + 10 cmp_int_op == + 11 jump_if_false +8 (to 19) + 12 pop 1 + + 262 13 load_var 3 (profile_exclude) + 14 container_len + 15 store_var 8 (_13) + 16 load_var 8 (_13) + 17 load_const 0 (0) + 18 cmp_int_op == + + 261 19 jump_if_false +8 (to 27) + 20 pop 1 + + 263 21 load_var 4 (cli_include) + 22 container_len + 23 store_var 9 (_14) + 24 load_var 9 (_14) + 25 load_const 0 (0) + 26 cmp_int_op == + + 261 27 jump_if_false +8 (to 35) + 28 pop 1 + + 264 29 load_var 5 (cli_exclude) + 30 container_len + 31 store_var 10 (_15) + 32 load_var 10 (_15) + 33 load_const 0 (0) + 34 cmp_int_op == + + 260 35 pop_jump_if_false +2 (to 37) + 36 jump +4 (to 40) + + 268 37 load_var2 1 6 + 38 call 733 ntypeargs=0 (testing.TestRegistry.run_selected) + 39 jump +3 (to 42) + + 266 40 load_var 1 (self) + 41 call 732 ntypeargs=0 (testing.TestRegistry.run_all) + + 270 42 load_var 6 (selected_names) + 43 call 763 ntypeargs=0 (testing.flatten_with_tolerated) + 44 return +} + +function testing.TestRegistry.run_selected(self: testing.TestRegistry, names: string[]) -> testing.TestSetReport { + 241 0 load_var2 1 2 + 1 call 739 ntypeargs=0 (testing.testset_children_selected) + 2 load_const 0 (null) + 3 call 748 ntypeargs=0 (testing.run_testset) + 4 return +} + +function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) -> testing.TestReport { + 205 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 1 (tests) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +13 (to 28) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (t) + + 206 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 207 22 load_var 5 (t) + 23 load_field 1 (body) + 24 load_var 5 (t) + 25 load_field 2 (runner) + 26 call 747 ntypeargs=0 (testing.run_test) + 27 jump +33 (to 60) + + 211 28 load_type 5 + 29 load_type 6 + 30 load_var 1 (self) + 31 load_field 1 (expansions) + 32 call 35 ntypeargs=2 (baml.Map.keys) + 33 load_type 7 + 34 load_const 8 ("iter") + 35 virtual_call nargs=1 ntypeargs=0 + 36 store_var 6 (_17) + 37 load_var 6 (_17) + 38 load_type 9 + 39 load_const 10 ("next") + 40 virtual_call nargs=1 ntypeargs=0 + 41 store_var 7 (_18) + 42 load_var 7 (_18) + 43 is_type 4 + 44 pop_jump_if_false +2 (to 46) + 45 jump +16 (to 61) + 46 load_var 7 (_18) + 47 store_var 8 (k) + + 212 48 load_var 1 (self) + 49 load_field 1 (expansions) + 50 load_var 8 (k) + 51 load_map_element + 52 store_var 9 (sub) + + 214 53 load_var2 2 8 + 54 load_const 11 ("::") + 55 bin_op + + 56 call 148 ntypeargs=0 (baml.String.starts_with) + 57 pop_jump_if_false -20 (to 37) + + 215 58 load_var2 9 2 + 59 call 730 ntypeargs=0 (testing.TestRegistry.run_test) + 60 return + + 218 61 load_const 12 ("Test not found: ") + 62 load_var 2 (name) + 63 bin_op + + 64 throw +} + +function testing.TestRegistry.run_testset(self: testing.TestRegistry, name: string) -> testing.TestSetReport { + 222 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 2 (testsets) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +14 (to 29) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (ts) + + 223 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 224 22 load_var2 1 5 + 23 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 24 call 738 ntypeargs=0 (testing.testset_children) + 25 load_var 5 (ts) + 26 load_field 2 (runner) + 27 call 748 ntypeargs=0 (testing.run_testset) + 28 jump +33 (to 61) + + 227 29 load_type 5 + 30 load_type 6 + 31 load_var 1 (self) + 32 load_field 1 (expansions) + 33 call 35 ntypeargs=2 (baml.Map.keys) + 34 load_type 7 + 35 load_const 8 ("iter") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 6 (_19) + 38 load_var 6 (_19) + 39 load_type 9 + 40 load_const 10 ("next") + 41 virtual_call nargs=1 ntypeargs=0 + 42 store_var 7 (_20) + 43 load_var 7 (_20) + 44 is_type 4 + 45 pop_jump_if_false +2 (to 47) + 46 jump +16 (to 62) + 47 load_var 7 (_20) + 48 store_var 8 (k) + + 228 49 load_var 1 (self) + 50 load_field 1 (expansions) + 51 load_var 8 (k) + 52 load_map_element + 53 store_var 9 (sub) + + 229 54 load_var2 2 8 + 55 load_const 11 ("::") + 56 bin_op + + 57 call 148 ntypeargs=0 (baml.String.starts_with) + 58 pop_jump_if_false -20 (to 38) + + 230 59 load_var2 9 2 + 60 call 731 ntypeargs=0 (testing.TestRegistry.run_testset) + 61 return + + 233 62 load_const 12 ("TestSet not found: ") + 63 load_var 2 (name) + 64 bin_op + + 65 throw +} + +function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing.SerializedTest | testing.SerializedTestSet)[] { + 178 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (items) + + 179 3 load_var 1 (self) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 3 (_4) + 10 load_var 3 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 4 (_5) + 15 load_var 4 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +9 (to 27) + + 180 19 load_var 2 (items) + 20 load_const 6 ("test") + + 179 21 load_var 4 (_5) + 22 load_field 0 (name) + 23 init_instance 0 (testing.SerializedTest .type, .name) + 24 call 4 ntypeargs=0 (baml.Array.push) + 25 pop 1 + 26 jump -16 (to 10) + + 182 27 load_var 1 (self) + 28 load_field 0 (collector) + 29 load_field 2 (testsets) + 30 load_type 7 + 31 load_const 8 ("iter") + 32 virtual_call nargs=1 ntypeargs=0 + 33 store_var 5 (_13) + 34 load_var 5 (_13) + 35 load_type 9 + 36 load_const 10 ("next") + 37 virtual_call nargs=1 ntypeargs=0 + 38 store_var 6 (_14) + 39 load_var 6 (_14) + 40 is_type 5 + 41 pop_jump_if_false +2 (to 43) + 42 jump +38 (to 80) + 43 load_var 6 (_14) + 44 store_var 7 (ts) + + 183 45 load_type 11 + 46 load_type 12 + 47 load_var 1 (self) + 48 load_field 1 (expansions) + 49 load_var 7 (ts) + 50 load_field 0 (name) + 51 call 38 ntypeargs=2 (baml.Map.get) + + 184 52 store_var 8 (_24) + 53 load_var 8 (_24) + 54 narrow_bind 13 8 + 55 pop_jump_if_false +2 (to 57) + 56 jump +9 (to 65) + + 195 57 load_var 2 (items) + 58 load_const 14 ("lazyTestSet") + 59 load_var 7 (ts) + 60 load_field 0 (name) + 61 init_instance 1 (testing.SerializedTest .type, .name) + 62 call 4 ntypeargs=0 (baml.Array.push) + 63 pop 1 + 64 jump -30 (to 34) + + 184 65 load_var 8 (_24) + 66 store_var 9 (sub) + + 188 67 load_var 7 (ts) + 68 load_field 0 (name) + 69 store_var 10 (_27) + + 189 70 load_var 9 (sub) + 71 call 729 ntypeargs=0 (testing.TestRegistry.serialize) + 72 store_var 11 (_28) + + 186 73 load_var2 2 10 + + 187 74 load_var2 11 9 + + 190 75 load_field 2 (loading_time_ms) + 76 init_instance 2 (testing.SerializedTestSet .name, .items, .loadingTimeMs) + 77 call 4 ntypeargs=0 (baml.Array.push) + 78 pop 1 + 79 jump -45 (to 34) + + 199 80 load_var 2 (items) + 81 return +} + +function testing._has_selected_descendant(prefix: string, names: string[]) -> bool { + 416 0 load_var 2 (names) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_4) + 5 load_var 3 (_4) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_5) + 10 load_var 4 (_5) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +8 (to 21) + 14 load_var2 4 1 + + 415 15 load_const 5 ("::") + 16 bin_op + + 17 call 148 ntypeargs=0 (baml.String.starts_with) + + 417 18 pop_jump_if_false -13 (to 5) + + 418 19 load_const 6 (true) + 20 jump +2 (to 22) + + 423 21 load_const 7 (false) + 22 return +} + +function testing._int_to_float(value: int) -> float { + 128 0 load_type 0 + 1 load_var 1 (value) + 2 call 138 ntypeargs=1 (baml.String.from) + 3 call 130 ntypeargs=0 (baml.Float.parse) + 4 jump +5 (to 9) + 5 load_var 2 (e) + 6 throw_if_panic + + 129 7 load_const 1 ("failed to convert int to float") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function testing._name_selected(name: string, names: string[]) -> bool { + 404 0 load_var 2 (names) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +6 (to 19) + 14 load_var2 4 1 + 15 cmp_op == + 16 pop_jump_if_false -11 (to 5) + + 406 17 load_const 5 (true) + 18 jump +2 (to 20) + + 411 19 load_const 6 (false) + 20 return +} + +function testing.aggregate_reports(named_results: testing.NamedChildReport[]) -> testing.TestSetReport { + 427 0 load_const 0 (0) + 1 store_var 2 (passed) + + 428 2 load_const 0 (0) + 3 store_var 3 (failed) + + 429 4 load_const 1 (false) + 5 store_var 4 (has_error) + + 430 6 load_type 2 + 7 alloc_array 0 + 8 store_var 5 (failed_names) + + 431 9 load_type 3 + 10 alloc_array 0 + 11 store_var 6 (results) + + 432 12 load_type 2 + 13 alloc_array 0 + 14 store_var 7 (result_names) + + 433 15 load_var 1 (named_results) + 16 load_type 4 + 17 load_const 5 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 8 (_8) + 20 load_var 8 (_8) + 21 load_type 6 + 22 load_const 7 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 9 (_9) + 25 load_var 9 (_9) + 26 is_type 8 + 27 pop_jump_if_false +2 (to 29) + 28 jump +92 (to 120) + 29 load_var 9 (_9) + 30 store_var 10 (named_result) + + 434 31 load_var 10 (named_result) + 32 load_field 1 (report) + 33 store_var 11 (result) + + 435 34 load_var2 6 11 + 35 call 4 ntypeargs=0 (baml.Array.push) + 36 pop 1 + + 436 37 load_var2 7 10 + 38 load_field 0 (name) + 39 call 4 ntypeargs=0 (baml.Array.push) + 40 pop 1 + + 437 41 load_var 11 (result) + 42 store_var 13 (_19) + 43 load_var 13 (_19) + 44 narrow_bind 9 13 + 45 pop_jump_if_false +2 (to 47) + 46 jump +5 (to 51) + 47 load_var 11 (result) + 48 load_field 0 (outcome) + 49 store_var 12 (outcome) + 50 jump +4 (to 54) + 51 load_var 13 (_19) + 52 load_field 0 (outcome) + 53 store_var 12 (outcome) + + 441 54 load_var 12 (outcome) + 55 load_const 10 ("pass") + 56 call 635 ntypeargs=0 (baml.ops.equals_equals) + 57 pop_jump_if_false +2 (to 59) + 58 jump +57 (to 115) + + 444 59 load_var 3 (failed) + 60 load_const 11 (1) + 61 add_int + 62 store_var 3 (failed) + + 445 63 load_var 11 (result) + 64 store_var 14 (_25) + 65 load_var 14 (_25) + 66 narrow_bind 9 14 + 67 pop_jump_if_false +2 (to 69) + 68 jump +19 (to 87) + 69 load_var 11 (result) + 70 store_var_load_var 15 (report) + + 448 71 load_field 4 (failed_names) + 72 container_len + 73 store_var 16 (_29) + 74 load_var 16 (_29) + 75 load_const 0 (0) + 76 cmp_int_op > + 77 pop_jump_if_false +2 (to 79) + 78 jump +6 (to 84) + + 451 79 load_var 10 (named_result) + 80 load_field 0 (name) + 81 load_type 2 + 82 alloc_array 1 + + 448 83 jump +8 (to 91) + + 449 84 load_var 15 (report) + 85 load_field 4 (failed_names) + + 448 86 jump +5 (to 91) + + 446 87 load_var 10 (named_result) + 88 load_field 0 (name) + 89 load_type 2 + 90 alloc_array 1 + + 455 91 load_type 12 + 92 load_const 13 ("iter") + 93 virtual_call nargs=1 ntypeargs=0 + 94 store_var 17 (_33) + 95 load_var 17 (_33) + 96 load_type 14 + 97 load_const 15 ("next") + 98 virtual_call nargs=1 ntypeargs=0 + 99 store_var 18 (_34) + 100 load_var 18 (_34) + 101 is_type 8 + 102 pop_jump_if_false +2 (to 104) + 103 jump +5 (to 108) + + 456 104 load_var2 5 18 + + 455 105 call 4 ntypeargs=0 (baml.Array.push) + 106 pop 1 + 107 jump -12 (to 95) + + 458 108 load_var 12 (outcome) + 109 load_const 16 ("error") + 110 call 635 ntypeargs=0 (baml.ops.equals_equals) + 111 pop_jump_if_false -91 (to 20) + + 459 112 load_const 17 (true) + 113 store_var 4 (has_error) + + 458 114 jump -94 (to 20) + + 442 115 load_var 2 (passed) + 116 load_const 11 (1) + 117 add_int + 118 store_var 2 (passed) + + 441 119 jump -99 (to 20) + + 465 120 load_var 4 (has_error) + 121 pop_jump_if_false +2 (to 123) + 122 jump +10 (to 132) + + 467 123 load_var 3 (failed) + 124 load_const 0 (0) + 125 cmp_int_op == + 126 pop_jump_if_false +2 (to 128) + 127 jump +3 (to 130) + + 470 128 load_const 18 ("fail") + + 467 129 jump +4 (to 133) + + 468 130 load_const 19 ("pass") + + 467 131 jump +2 (to 133) + + 466 132 load_const 20 ("error") + + 473 133 store_var 19 (_46) + + 474 134 load_var 2 (passed) + 135 store_var 20 (_47) + + 475 136 load_var 3 (failed) + 137 store_var 21 (_48) + + 476 138 load_var 6 (results) + 139 container_len + 140 store_var 22 (_49) + + 472 141 load_var2 19 20 + 142 load_var2 21 22 + + 477 143 load_var2 5 6 + + 479 144 load_var 7 (result_names) + 145 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) + 146 return +} + +function testing.any_pattern_matches(pats: string[], canonical_id: string) -> bool { + 607 0 load_var 1 (pats) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +6 (to 19) + + 608 14 load_var2 2 4 + + 607 15 call 750 ntypeargs=0 (testing.glob_match) + + 608 16 pop_jump_if_false -11 (to 5) + + 609 17 load_const 5 (true) + 18 jump +2 (to 20) + + 612 19 load_const 6 (false) + 20 return +} + +function testing.classify_selected_names(selected_names: string[], hard_failed_names: string[], all_failed_names: string[]) -> testing.LeafIdentities { + 947 0 load_type 0 + 1 alloc_array 0 + 2 load_type 0 + 3 alloc_array 0 + 4 load_type 0 + 5 alloc_array 0 + 6 init_instance 0 (testing.LeafIdentities .passed, .failed, .tolerated) + 7 store_var 4 (out) + + 948 8 load_var 1 (selected_names) + 9 load_type 1 + 10 load_const 2 ("iter") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_8) + 13 load_var 5 (_8) + 14 load_type 3 + 15 load_const 4 ("next") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 6 (_9) + 18 load_var 6 (_9) + 19 is_type 5 + 20 pop_jump_if_false +2 (to 22) + 21 jump +32 (to 53) + 22 load_var 6 (_9) + 23 store_var_load_var 7 (name) + + 949 24 load_var 3 (all_failed_names) + 25 call 766 ntypeargs=0 (testing.failure_matches_selected) + 26 pop_jump_if_false +2 (to 28) + 27 jump +8 (to 35) + + 956 28 load_type 0 + 29 load_var 4 (out) + 30 load_field 0 (passed) + 31 load_var 7 (name) + 32 call 4 ntypeargs=1 (baml.Array.push) + 33 pop 1 + 34 jump -21 (to 13) + + 950 35 load_var2 7 2 + 36 call 766 ntypeargs=0 (testing.failure_matches_selected) + 37 pop_jump_if_false +2 (to 39) + 38 jump +8 (to 46) + + 953 39 load_type 0 + 40 load_var 4 (out) + 41 load_field 2 (tolerated) + 42 load_var 7 (name) + 43 call 4 ntypeargs=1 (baml.Array.push) + 44 pop 1 + 45 jump -32 (to 13) + + 951 46 load_type 0 + 47 load_var 4 (out) + 48 load_field 1 (failed) + 49 load_var 7 (name) + 50 call 4 ntypeargs=1 (baml.Array.push) + 51 pop 1 + 52 jump -39 (to 13) + + 959 53 load_var 4 (out) + 54 return +} + +function testing.collect_all_failed_names(report: testing.TestSetReport, out: string[]) -> void { + 1049 0 load_var 1 (report) + 1 load_field 4 (failed_names) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 3 (_4) + 6 load_var 3 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 4 (_5) + 11 load_var 4 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +11 (to 25) + 15 load_var 4 (_5) + 16 store_var_load_var 5 (name) + + 1050 17 load_var 2 (out) + 18 call 765 ntypeargs=0 (testing.name_in) + 19 unary_op ! + 20 pop_jump_if_false -14 (to 6) + + 1051 21 load_var2 2 5 + 22 call 4 ntypeargs=0 (baml.Array.push) + 23 pop 1 + 24 jump -18 (to 6) + + 1054 25 load_var 1 (report) + 26 load_field 5 (results) + 27 load_type 5 + 28 load_const 6 ("iter") + 29 virtual_call nargs=1 ntypeargs=0 + 30 store_var 6 (_15) + 31 load_var 6 (_15) + 32 load_type 7 + 33 load_const 8 ("next") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 7 (_16) + 36 load_var 7 (_16) + 37 is_type 4 + 38 pop_jump_if_false +2 (to 40) + 39 jump +10 (to 49) + 40 load_var 7 (_16) + 41 store_var_load_var 8 (child) + + 1055 42 is_type 9 + 43 pop_jump_if_false +2 (to 45) + 44 jump -13 (to 31) + 45 load_var2 8 2 + 46 call 768 ntypeargs=0 (testing.collect_all_failed_names) + 47 pop 1 + 48 jump -17 (to 31) + + 1048 49 load_const 10 (null) + 50 return +} + +function testing.collect_leaf_identities(report: testing.TestSetReport, tolerated_by_parent: bool, selected_names: string[], out: testing.LeafIdentities) -> void { + 993 0 load_var 1 (report) + 1 load_field 6 (result_names) + 2 store_var_load_var 5 (_5) + 3 load_const 0 (null) + 4 cmp_op == + 5 pop_jump_if_false +2 (to 7) + 6 jump +156 (to 162) + 7 load_var 5 (_5) + 8 store_var 6 (names) + + 996 9 load_var 6 (names) + 10 container_len + 11 store_var 8 (_10) + 12 load_var 1 (report) + 13 load_field 5 (results) + 14 container_len + 15 store_var 9 (_11) + 16 load_var2 8 9 + 17 cmp_int_op < + 18 pop_jump_if_false +2 (to 20) + 19 jump +6 (to 25) + + 999 20 load_var 1 (report) + 21 load_field 5 (results) + 22 container_len + 23 store_var 7 (limit) + 24 jump +4 (to 28) + + 997 25 load_var 6 (names) + 26 container_len + 27 store_var 7 (limit) + + 1001 28 load_const 1 (0) + 29 store_var 10 (i) + 30 load_var2 10 7 + 31 cmp_int_op < + 32 pop_jump_if_false +2 (to 34) + 33 jump +3 (to 36) + + 995 34 load_const 0 (null) + + 993 35 jump +128 (to 163) + + 1002 36 load_var2 6 10 + 37 load_array_element + 38 store_var 11 (name) + + 1003 39 load_var 1 (report) + 40 load_field 5 (results) + 41 load_var 10 (i) + 42 load_array_element + 43 store_var 12 (_22) + 44 load_var 12 (_22) + 45 store_var 13 (_25) + 46 load_var 13 (_25) + 47 narrow_bind 2 13 + 48 pop_jump_if_false +2 (to 50) + 49 jump +79 (to 128) + 50 load_var 12 (_22) + 51 store_var 14 (nested) + + 1014 52 load_var 2 (tolerated_by_parent) + 53 jump_if_false +3 (to 56) + 54 store_var 15 (nested_tolerated) + 55 jump +7 (to 62) + 56 pop 1 + 57 load_var 14 (nested) + 58 load_field 0 (outcome) + 59 load_const 3 ("pass") + 60 call 635 ntypeargs=0 (baml.ops.equals_equals) + 61 store_var 15 (nested_tolerated) + + 1015 62 load_var 14 (nested) + 63 load_field 5 (results) + 64 container_len + 65 store_var 16 (_42) + 66 load_var 16 (_42) + 67 load_const 1 (0) + 68 cmp_int_op > + 69 pop_jump_if_false +2 (to 71) + 70 jump +53 (to 123) + + 1022 71 load_var 14 (nested) + 72 load_field 2 (failed) + 73 load_const 1 (0) + 74 cmp_int_op > + 75 pop_jump_if_false +82 (to 157) + + 1023 76 load_var 11 (name) + 77 load_const 4 ("::(failed to expand)") + 78 bin_op + + 79 store_var_load_var 17 (sentinel) + + 1024 80 load_var 3 (selected_names) + 81 call 765 ntypeargs=0 (testing.name_in) + 82 pop_jump_if_false +2 (to 84) + 83 jump +21 (to 104) + + 1026 84 load_var 14 (nested) + 85 load_field 4 (failed_names) + 86 container_len + 87 store_var 19 (_54) + 88 load_var 19 (_54) + 89 load_const 1 (0) + 90 cmp_int_op > + 91 pop_jump_if_false +2 (to 93) + 92 jump +6 (to 98) + + 1029 93 load_var 11 (name) + 94 load_const 5 ("::(testset error)") + 95 bin_op + + 96 store_var 18 (identity) + + 1026 97 jump +9 (to 106) + + 1027 98 load_var 14 (nested) + 99 load_field 4 (failed_names) + 100 load_const 1 (0) + 101 load_array_element + 102 store_var 18 (identity) + + 1026 103 jump +3 (to 106) + + 1025 104 load_var 17 (sentinel) + 105 store_var 18 (identity) + + 1031 106 load_var 15 (nested_tolerated) + 107 pop_jump_if_false +2 (to 109) + 108 jump +8 (to 116) + + 1034 109 load_type 6 + 110 load_var 4 (out) + 111 load_field 1 (failed) + 112 load_var 18 (identity) + 113 call 4 ntypeargs=1 (baml.Array.push) + 114 pop 1 + 115 jump +42 (to 157) + + 1032 116 load_type 6 + 117 load_var 4 (out) + 118 load_field 2 (tolerated) + 119 load_var 18 (identity) + 120 call 4 ntypeargs=1 (baml.Array.push) + 121 pop 1 + 122 jump +35 (to 157) + + 1017 123 load_var2 14 15 + + 1018 124 load_var2 3 4 + 125 call 767 ntypeargs=0 (testing.collect_leaf_identities) + 126 pop 1 + 127 jump +30 (to 157) + + 1003 128 load_var 13 (_25) + 129 load_field 0 (outcome) + 130 load_const 7 ("pass") + 131 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 1005 132 pop_jump_if_false +2 (to 134) + 133 jump +18 (to 151) + + 1007 134 load_var 2 (tolerated_by_parent) + 135 pop_jump_if_false +2 (to 137) + 136 jump +8 (to 144) + + 1010 137 load_type 6 + 138 load_var 4 (out) + 139 load_field 1 (failed) + 140 load_var 11 (name) + 141 call 4 ntypeargs=1 (baml.Array.push) + 142 pop 1 + 143 jump +14 (to 157) + + 1008 144 load_type 6 + 145 load_var 4 (out) + 146 load_field 2 (tolerated) + 147 load_var 11 (name) + 148 call 4 ntypeargs=1 (baml.Array.push) + 149 pop 1 + 150 jump +7 (to 157) + + 1006 151 load_type 6 + 152 load_var 4 (out) + 153 load_field 0 (passed) + 154 load_var 11 (name) + 155 call 4 ntypeargs=1 (baml.Array.push) + 156 pop 1 + + 1001 157 load_var 10 (i) + 158 load_const 8 (1) + 159 add_int + 160 store_var 10 (i) + 161 jump -131 (to 30) + + 994 162 load_const 0 (null) + 163 return +} + +function testing.collect_leaf_messages(results: (testing.TestReport | testing.TestSetReport)[], out: string[]) -> void { + 1065 0 load_var 1 (results) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +47 (to 60) + 14 load_var 4 (_4) + 15 store_var 5 (r) + + 1066 16 load_var 5 (r) + 17 store_var 6 (_8) + 18 load_var 6 (_8) + 19 narrow_bind 5 6 + 20 pop_jump_if_false +2 (to 22) + 21 jump +7 (to 28) + 22 load_var 5 (r) + 23 load_field 5 (results) + 24 load_var 2 (out) + 25 call 769 ntypeargs=0 (testing.collect_leaf_messages) + 26 pop 1 + 27 jump -22 (to 5) + 28 load_var 6 (_8) + 29 load_field 1 (runs) + 30 load_type 6 + 31 load_const 7 ("iter") + 32 virtual_call nargs=1 ntypeargs=0 + 33 store_var 7 (_11) + + 1068 34 load_var 7 (_11) + 35 load_type 8 + 36 load_const 9 ("next") + 37 virtual_call nargs=1 ntypeargs=0 + 38 store_var 8 (_12) + 39 load_var 8 (_12) + 40 is_type 4 + 41 pop_jump_if_false +2 (to 43) + 42 jump -37 (to 5) + 43 load_var 8 (_12) + 44 store_var_load_var 9 (run) + + 1069 45 load_field 0 (outcome) + 46 load_const 10 ("pass") + 47 call 635 ntypeargs=0 (baml.ops.equals_equals) + 48 unary_op ! + 49 pop_jump_if_false -15 (to 34) + + 1070 50 load_var 9 (run) + 51 load_field 2 (message) + 52 store_var 10 (_20) + 53 load_var 10 (_20) + 54 narrow_bind 11 10 + 55 pop_jump_if_false -21 (to 34) + + 1071 56 load_var2 2 10 + + 1070 57 call 4 ntypeargs=0 (baml.Array.push) + 58 pop 1 + 59 jump -25 (to 34) + + 1064 60 load_const 12 (null) + 61 return +} + +function testing.collect_leaf_names(registry: testing.TestRegistry) -> string[] { + 744 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (out) + + 745 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 3 (_4) + 10 load_var 3 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 4 (_5) + 15 load_var 4 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +6 (to 24) + + 746 19 load_var2 2 4 + + 745 20 load_field 0 (name) + 21 call 4 ntypeargs=0 (baml.Array.push) + 22 pop 1 + 23 jump -13 (to 10) + + 748 24 load_var 1 (registry) + 25 load_field 0 (collector) + 26 load_field 2 (testsets) + 27 load_type 6 + 28 load_const 7 ("iter") + 29 virtual_call nargs=1 ntypeargs=0 + 30 store_var 5 (_12) + 31 load_var 5 (_12) + 32 load_type 8 + 33 load_const 9 ("next") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 6 (_13) + 36 load_var 6 (_13) + 37 is_type 5 + 38 pop_jump_if_false +2 (to 40) + 39 jump +20 (to 59) + + 749 40 load_var2 1 6 + + 748 41 call 760 ntypeargs=0 (testing.collect_subtree_names) + + 749 42 load_type 10 + 43 load_const 11 ("iter") + 44 virtual_call nargs=1 ntypeargs=0 + 45 store_var 7 (_19) + 46 load_var 7 (_19) + 47 load_type 12 + 48 load_const 13 ("next") + 49 virtual_call nargs=1 ntypeargs=0 + 50 store_var 8 (_20) + 51 load_var 8 (_20) + 52 is_type 5 + 53 pop_jump_if_false +2 (to 55) + 54 jump -23 (to 31) + + 750 55 load_var2 2 8 + + 749 56 call 4 ntypeargs=0 (baml.Array.push) + 57 pop 1 + 58 jump -12 (to 46) + + 753 59 load_var 2 (out) + 60 return +} + +function testing.collect_subtree_names(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> string[] { + 762 0 load_var2 1 2 + 1 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 2 call 759 ntypeargs=0 (testing.collect_leaf_names) + 3 jump +89 (to 92) + 4 load_var 3 (e) + 5 store_var 4 (_5) + 6 load_var 4 (_5) + 7 narrow_bind 0 4 + 8 pop_jump_if_false +2 (to 10) + 9 jump +81 (to 90) + 10 load_var 3 (e) + 11 is_type 1 + 12 pop_jump_if_false +2 (to 14) + 13 jump +70 (to 83) + 14 load_var 3 (e) + 15 is_type 2 + 16 pop_jump_if_false +2 (to 18) + 17 jump +66 (to 83) + 18 load_var 3 (e) + 19 is_type 3 + 20 pop_jump_if_false +2 (to 22) + 21 jump +62 (to 83) + 22 load_var 3 (e) + 23 is_type 4 + 24 pop_jump_if_false +2 (to 26) + 25 jump +58 (to 83) + 26 load_var 3 (e) + 27 is_type 5 + 28 pop_jump_if_false +2 (to 30) + 29 jump +54 (to 83) + 30 load_var 3 (e) + 31 is_type 6 + 32 pop_jump_if_false +2 (to 34) + 33 jump +50 (to 83) + 34 load_var 3 (e) + 35 is_type 7 + 36 pop_jump_if_false +2 (to 38) + 37 jump +46 (to 83) + 38 load_var 3 (e) + 39 is_type 8 + 40 pop_jump_if_false +2 (to 42) + 41 jump +42 (to 83) + 42 load_var 3 (e) + 43 is_type 9 + 44 pop_jump_if_false +2 (to 46) + 45 jump +38 (to 83) + 46 load_var 3 (e) + 47 is_type 10 + 48 pop_jump_if_false +2 (to 50) + 49 jump +34 (to 83) + 50 load_var 3 (e) + 51 is_type 11 + 52 pop_jump_if_false +2 (to 54) + 53 jump +30 (to 83) + 54 load_var 3 (e) + 55 is_type 12 + 56 pop_jump_if_false +2 (to 58) + 57 jump +26 (to 83) + 58 load_var 3 (e) + 59 is_type 13 + 60 pop_jump_if_false +2 (to 62) + 61 jump +22 (to 83) + 62 load_var 3 (e) + 63 is_type 14 + 64 pop_jump_if_false +2 (to 66) + 65 jump +18 (to 83) + 66 load_var 3 (e) + 67 is_type 15 + 68 pop_jump_if_false +2 (to 70) + 69 jump +14 (to 83) + 70 load_var 3 (e) + 71 is_type 16 + 72 pop_jump_if_false +2 (to 74) + 73 jump +10 (to 83) + 74 load_var 3 (e) + 75 throw_if_panic + + 765 76 load_var 2 (ts) + 77 load_field 0 (name) + 78 load_const 17 ("::(failed to expand)") + 79 bin_op + + 80 load_type 18 + 81 alloc_array 1 + + 762 82 jump +10 (to 92) + + 764 83 load_var 2 (ts) + 84 load_field 0 (name) + 85 load_const 19 ("::(failed to expand)") + 86 bin_op + + 87 load_type 18 + 88 alloc_array 1 + + 762 89 jump +3 (to 92) + 90 load_var 4 (_5) + 91 throw + 92 return +} + +function testing.collect_subtree_names_layered(registry: testing.TestRegistry, ts: testing.TestSetRegistration, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 778 0 load_var2 1 2 + 1 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + + 777 2 load_var2 3 4 + 3 load_var2 5 6 + 4 call 757 ntypeargs=0 (testing.select_names_layered) + 5 jump +109 (to 114) + 6 load_var 7 (e) + 7 store_var 8 (_9) + 8 load_var 8 (_9) + 9 narrow_bind 0 8 + 10 pop_jump_if_false +2 (to 12) + 11 jump +101 (to 112) + 12 load_var 7 (e) + 13 is_type 1 + 14 pop_jump_if_false +2 (to 16) + 15 jump +80 (to 95) + 16 load_var 7 (e) + 17 is_type 2 + 18 pop_jump_if_false +2 (to 20) + 19 jump +76 (to 95) + 20 load_var 7 (e) + 21 is_type 3 + 22 pop_jump_if_false +2 (to 24) + 23 jump +72 (to 95) + 24 load_var 7 (e) + 25 is_type 4 + 26 pop_jump_if_false +2 (to 28) + 27 jump +68 (to 95) + 28 load_var 7 (e) + 29 is_type 5 + 30 pop_jump_if_false +2 (to 32) + 31 jump +64 (to 95) + 32 load_var 7 (e) + 33 is_type 6 + 34 pop_jump_if_false +2 (to 36) + 35 jump +60 (to 95) + 36 load_var 7 (e) + 37 is_type 7 + 38 pop_jump_if_false +2 (to 40) + 39 jump +56 (to 95) + 40 load_var 7 (e) + 41 is_type 8 + 42 pop_jump_if_false +2 (to 44) + 43 jump +52 (to 95) + 44 load_var 7 (e) + 45 is_type 9 + 46 pop_jump_if_false +2 (to 48) + 47 jump +48 (to 95) + 48 load_var 7 (e) + 49 is_type 10 + 50 pop_jump_if_false +2 (to 52) + 51 jump +44 (to 95) + 52 load_var 7 (e) + 53 is_type 11 + 54 pop_jump_if_false +2 (to 56) + 55 jump +40 (to 95) + 56 load_var 7 (e) + 57 is_type 12 + 58 pop_jump_if_false +2 (to 60) + 59 jump +36 (to 95) + 60 load_var 7 (e) + 61 is_type 13 + 62 pop_jump_if_false +2 (to 64) + 63 jump +32 (to 95) + 64 load_var 7 (e) + 65 is_type 14 + 66 pop_jump_if_false +2 (to 68) + 67 jump +28 (to 95) + 68 load_var 7 (e) + 69 is_type 15 + 70 pop_jump_if_false +2 (to 72) + 71 jump +24 (to 95) + 72 load_var 7 (e) + 73 is_type 16 + 74 pop_jump_if_false +2 (to 76) + 75 jump +20 (to 95) + 76 load_var 7 (e) + 77 throw_if_panic + + 802 78 load_var 2 (ts) + 79 load_field 0 (name) + 80 load_const 17 ("::(failed to expand)") + 81 bin_op + + 82 store_var_load_var 10 (sentinel) + + 805 83 load_var2 3 4 + 84 load_var2 5 6 + 85 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 803 86 pop_jump_if_false +2 (to 88) + 87 jump +4 (to 91) + + 814 88 load_type 18 + 89 alloc_array 0 + + 803 90 jump +24 (to 114) + + 812 91 load_var 10 (sentinel) + 92 load_type 18 + 93 alloc_array 1 + + 803 94 jump +20 (to 114) + + 786 95 load_var 2 (ts) + 96 load_field 0 (name) + 97 load_const 19 ("::(failed to expand)") + 98 bin_op + + 99 store_var_load_var 9 (sentinel) + + 789 100 load_var2 3 4 + 101 load_var2 5 6 + 102 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 787 103 pop_jump_if_false +2 (to 105) + 104 jump +4 (to 108) + + 798 105 load_type 18 + 106 alloc_array 0 + + 787 107 jump +7 (to 114) + + 796 108 load_var 9 (sentinel) + 109 load_type 18 + 110 alloc_array 1 + + 787 111 jump +3 (to 114) + + 777 112 load_var 8 (_9) + 113 throw + 114 return +} + +function testing.count_leaves(results: (testing.TestReport | testing.TestSetReport)[], tolerated_by_parent: bool) -> testing.LeafCounts { + 838 0 load_const 0 (0) + 1 store_var 3 (passed) + + 839 2 load_const 0 (0) + 3 store_var 4 (failed) + + 840 4 load_const 0 (0) + 5 store_var 5 (tolerated) + + 841 6 load_const 0 (0) + 7 store_var 6 (total) + + 842 8 load_var 1 (results) + 9 load_type 1 + 10 load_const 2 ("iter") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 7 (_7) + 13 load_var 7 (_7) + 14 load_type 3 + 15 load_const 4 ("next") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 8 (_8) + 18 load_var 8 (_8) + 19 is_type 5 + 20 pop_jump_if_false +2 (to 22) + 21 jump +105 (to 126) + 22 load_var 8 (_8) + 23 store_var 9 (r) + + 843 24 load_var 9 (r) + 25 store_var 11 (_13) + 26 load_var 11 (_13) + 27 narrow_bind 6 11 + 28 pop_jump_if_false +2 (to 30) + 29 jump +51 (to 80) + 30 load_var 9 (r) + 31 store_var 12 (tsr) + + 854 32 load_var 2 (tolerated_by_parent) + 33 jump_if_false +3 (to 36) + 34 store_var 13 (ft) + 35 jump +7 (to 42) + 36 pop 1 + 37 load_var 12 (tsr) + 38 load_field 0 (outcome) + 39 load_const 7 ("pass") + 40 call 635 ntypeargs=0 (baml.ops.equals_equals) + 41 store_var 13 (ft) + + 855 42 load_var 12 (tsr) + 43 load_field 5 (results) + 44 container_len + 45 store_var 14 (_21) + 46 load_var 14 (_21) + 47 load_const 0 (0) + 48 cmp_int_op > + 49 pop_jump_if_false +2 (to 51) + 50 jump +24 (to 74) + + 857 51 load_var 13 (ft) + 52 pop_jump_if_false +2 (to 54) + 53 jump +11 (to 64) + + 866 54 load_var 12 (tsr) + 55 load_field 1 (passed) + + 867 56 load_var 12 (tsr) + 57 load_field 2 (failed) + 58 load_const 0 (0) + + 869 59 load_var 12 (tsr) + 60 load_field 3 (total) + 61 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 62 store_var 10 (delta) + + 857 63 jump +46 (to 109) + + 859 64 load_var 12 (tsr) + 65 load_field 1 (passed) + 66 load_const 0 (0) + + 861 67 load_var 12 (tsr) + 68 load_field 2 (failed) + + 862 69 load_var 12 (tsr) + 70 load_field 3 (total) + 71 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 72 store_var 10 (delta) + + 857 73 jump +36 (to 109) + + 856 74 load_var 12 (tsr) + 75 load_field 5 (results) + 76 load_var 13 (ft) + 77 call 762 ntypeargs=0 (testing.count_leaves) + 78 store_var 10 (delta) + 79 jump +30 (to 109) + + 843 80 load_var 11 (_13) + 81 load_field 0 (outcome) + 82 load_const 8 ("pass") + 83 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 845 84 pop_jump_if_false +2 (to 86) + 85 jump +18 (to 103) + + 847 86 load_var 2 (tolerated_by_parent) + 87 pop_jump_if_false +2 (to 89) + 88 jump +8 (to 96) + + 850 89 load_const 0 (0) + 90 load_const 9 (1) + 91 load_const 0 (0) + 92 load_const 9 (1) + 93 init_instance 2 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 94 store_var 10 (delta) + + 847 95 jump +14 (to 109) + + 848 96 load_const 0 (0) + 97 load_const 0 (0) + 98 load_const 9 (1) + 99 load_const 9 (1) + 100 init_instance 3 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 101 store_var 10 (delta) + + 847 102 jump +7 (to 109) + + 846 103 load_const 9 (1) + 104 load_const 0 (0) + 105 load_const 0 (0) + 106 load_const 9 (1) + 107 init_instance 4 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 108 store_var 10 (delta) + + 874 109 load_var2 3 10 + 110 load_field 0 (passed) + 111 add_int + 112 store_var 3 (passed) + + 875 113 load_var2 4 10 + 114 load_field 1 (failed) + 115 add_int + 116 store_var 4 (failed) + + 876 117 load_var2 5 10 + 118 load_field 2 (tolerated) + 119 add_int + 120 store_var 5 (tolerated) + + 877 121 load_var2 6 10 + 122 load_field 3 (total) + 123 add_int + 124 store_var 6 (total) + + 842 125 jump -112 (to 13) + + 879 126 load_var2 3 4 + 127 load_var2 5 6 + 128 init_instance 5 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 129 return +} + +function testing.expansion_error_report(name: string) -> testing.TestSetReport { + 553 0 load_const 0 ("error") + 1 load_const 1 (0) + 2 load_const 2 (1) + 3 load_const 2 (1) + + 564 4 load_var 1 (name) + 5 load_const 3 ("::(testset error)") + 6 bin_op + + 7 load_type 4 + 8 alloc_array 1 + + 565 9 load_type 5 + 10 alloc_array 0 + + 566 11 load_type 4 + 12 alloc_array 0 + 13 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) + 14 return +} + +function testing.failure_matches_selected(selected: string, failed_names: string[]) -> bool { + 972 0 load_var2 1 2 + 1 call 765 ntypeargs=0 (testing.name_in) + 2 pop_jump_if_false +2 (to 4) + 3 jump +40 (to 43) + + 976 4 load_var 1 (selected) + + 975 5 load_const 0 ("::(failed to expand)") + 6 call 149 ntypeargs=0 (baml.String.ends_with) + + 976 7 pop_jump_if_false +34 (to 41) + + 977 8 load_var 1 (selected) + 9 call 139 ntypeargs=0 (baml.String.length) + 10 store_var 4 (_10) + + 975 11 load_const 1 ("::(failed to expand)") + 12 call 139 ntypeargs=0 (baml.String.length) + 13 store_var 5 (_11) + + 977 14 load_var 1 (selected) + 15 load_const 2 (0) + 16 load_var2 4 5 + 17 sub_int + 18 call 153 ntypeargs=0 (baml.String.substring) + 19 store_var 3 (_8) + + 978 20 load_var 2 (failed_names) + 21 load_type 3 + 22 load_const 4 ("iter") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 6 (_12) + 25 load_var 6 (_12) + 26 load_type 5 + 27 load_const 6 ("next") + 28 virtual_call nargs=1 ntypeargs=0 + 29 store_var 7 (_13) + 30 load_var 7 (_13) + 31 is_type 7 + 32 pop_jump_if_false +2 (to 34) + 33 jump +8 (to 41) + 34 load_var2 7 3 + + 977 35 load_const 8 ("::") + 36 bin_op + + 37 call 148 ntypeargs=0 (baml.String.starts_with) + + 979 38 pop_jump_if_false -13 (to 25) + + 980 39 load_const 9 (true) + 40 jump +4 (to 44) + + 984 41 load_const 10 (false) + 42 jump +2 (to 44) + + 973 43 load_const 9 (true) + 44 return +} + +function testing.flatten_with_tolerated(report: testing.TestSetReport, selected_names: string[]) -> testing.FlatTestReport { + 887 0 load_var 1 (report) + 1 load_field 0 (outcome) + 2 load_const 0 ("pass") + 3 call 635 ntypeargs=0 (baml.ops.equals_equals) + 4 store_var 3 (top_tolerated) + + 888 5 load_var 1 (report) + 6 load_field 5 (results) + 7 container_len + 8 store_var 5 (_7) + 9 load_var 5 (_7) + 10 load_const 1 (0) + 11 cmp_int_op > + 12 pop_jump_if_false +2 (to 14) + 13 jump +24 (to 37) + + 890 14 load_var 3 (top_tolerated) + 15 pop_jump_if_false +2 (to 17) + 16 jump +11 (to 27) + + 899 17 load_var 1 (report) + 18 load_field 1 (passed) + + 900 19 load_var 1 (report) + 20 load_field 2 (failed) + 21 load_const 1 (0) + + 902 22 load_var 1 (report) + 23 load_field 3 (total) + 24 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 25 store_var 4 (counts) + + 890 26 jump +16 (to 42) + + 892 27 load_var 1 (report) + 28 load_field 1 (passed) + 29 load_const 1 (0) + + 894 30 load_var 1 (report) + 31 load_field 2 (failed) + + 895 32 load_var 1 (report) + 33 load_field 3 (total) + 34 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 35 store_var 4 (counts) + + 890 36 jump +6 (to 42) + + 889 37 load_var 1 (report) + 38 load_field 5 (results) + 39 load_var 3 (top_tolerated) + 40 call 762 ntypeargs=0 (testing.count_leaves) + 41 store_var 4 (counts) + + 905 42 load_type 2 + 43 alloc_array 0 + 44 store_var 6 (messages) + + 906 45 load_var 1 (report) + 46 load_field 5 (results) + 47 load_var 6 (messages) + 48 call 769 ntypeargs=0 (testing.collect_leaf_messages) + 49 pop 1 + + 907 50 load_type 2 + 51 alloc_array 0 + 52 store_var 7 (all_failed_names) + + 908 53 load_var2 1 7 + 54 call 768 ntypeargs=0 (testing.collect_all_failed_names) + 55 pop 1 + + 909 56 load_type 2 + 57 alloc_array 0 + 58 load_type 2 + 59 alloc_array 0 + 60 load_type 2 + 61 alloc_array 0 + 62 init_instance 2 (testing.LeafIdentities .passed, .failed, .tolerated) + 63 store_var 8 (executed) + + 910 64 load_var2 1 3 + 65 load_var2 2 8 + 66 call 767 ntypeargs=0 (testing.collect_leaf_identities) + 67 pop 1 + + 916 68 load_var 8 (executed) + 69 load_field 0 (passed) + 70 container_len + 71 store_var 10 (_36) + 72 load_var2 10 4 + 73 load_field 0 (passed) + 74 cmp_int_op == + 75 jump_if_false +9 (to 84) + 76 pop 1 + + 917 77 load_var 8 (executed) + 78 load_field 1 (failed) + 79 container_len + 80 store_var 11 (_39) + 81 load_var2 11 4 + 82 load_field 1 (failed) + 83 cmp_int_op == + + 916 84 jump_if_false +9 (to 93) + 85 pop 1 + + 918 86 load_var 8 (executed) + 87 load_field 2 (tolerated) + 88 container_len + 89 store_var 12 (_42) + 90 load_var2 12 4 + 91 load_field 2 (tolerated) + 92 cmp_int_op == + + 915 93 pop_jump_if_false +2 (to 95) + 94 jump +24 (to 118) + + 921 95 load_var 2 (selected_names) + 96 container_len + 97 store_var 13 (_46) + 98 load_var2 13 4 + 99 load_field 3 (total) + 100 cmp_int_op == + 101 pop_jump_if_false +2 (to 103) + 102 jump +10 (to 112) + + 927 103 load_type 2 + 104 alloc_array 0 + 105 load_type 2 + 106 alloc_array 0 + 107 load_type 2 + 108 alloc_array 0 + 109 init_instance 3 (testing.LeafIdentities .passed, .failed, .tolerated) + 110 store_var 9 (identities) + + 921 111 jump +9 (to 120) + + 922 112 load_var2 2 1 + 113 load_field 4 (failed_names) + 114 load_var 7 (all_failed_names) + 115 call 764 ntypeargs=0 (testing.classify_selected_names) + 116 store_var 9 (identities) + 117 jump +3 (to 120) + + 920 118 load_var 8 (executed) + 119 store_var 9 (identities) + + 930 120 load_var 1 (report) + 121 load_field 0 (outcome) + + 931 122 load_var 4 (counts) + 123 load_field 0 (passed) + + 932 124 load_var 4 (counts) + 125 load_field 1 (failed) + + 933 126 load_var 4 (counts) + 127 load_field 2 (tolerated) + + 934 128 load_var 4 (counts) + 129 load_field 3 (total) + + 935 130 load_var 9 (identities) + 131 load_field 0 (passed) + + 936 132 load_var 9 (identities) + 133 load_field 1 (failed) + + 937 134 load_var 9 (identities) + 135 load_field 2 (tolerated) + + 938 136 load_var 6 (messages) + 137 init_instance 4 (testing.FlatTestReport .outcome, .passed, .failed, .tolerated, .total, .passed_names, .failed_names, .tolerated_names, .messages) + 138 return +} + +function testing.glob_match(subject: string, pattern: string) -> bool { + 574 0 load_var 2 (pattern) + 1 load_const 0 ("*") + 2 call 150 ntypeargs=0 (baml.String.split) + 3 store_var 3 (parts) + + 575 4 load_var 3 (parts) + 5 container_len + 6 store_var 4 (n) + + 576 7 load_var 4 (n) + 8 load_const 1 (1) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +85 (to 96) + + 579 12 load_var 3 (parts) + 13 load_const 2 (0) + 14 load_array_element + 15 store_var 5 (first) + + 580 16 load_var2 3 4 + 17 load_const 1 (1) + 18 sub_int + 19 load_array_element + 20 store_var 6 (last) + + 581 21 load_var2 1 5 + 22 call 148 ntypeargs=0 (baml.String.starts_with) + 23 unary_op ! + 24 pop_jump_if_false +2 (to 26) + 25 jump +69 (to 94) + + 584 26 load_var2 1 6 + 27 call 149 ntypeargs=0 (baml.String.ends_with) + 28 unary_op ! + 29 pop_jump_if_false +2 (to 31) + 30 jump +62 (to 92) + + 587 31 load_var 5 (first) + 32 call 139 ntypeargs=0 (baml.String.length) + 33 store_var 7 (start) + + 588 34 load_var 1 (subject) + 35 call 139 ntypeargs=0 (baml.String.length) + 36 store_var 9 (_24) + 37 load_var 6 (last) + 38 call 139 ntypeargs=0 (baml.String.length) + 39 store_var 10 (_25) + 40 load_var2 9 10 + 41 sub_int + 42 store_var 8 (end_limit) + + 589 43 load_var2 7 8 + 44 cmp_int_op > + 45 pop_jump_if_false +2 (to 47) + 46 jump +44 (to 90) + + 592 47 load_var 7 (start) + 48 store_var 11 (pos) + + 593 49 load_const 1 (1) + 50 store_var 12 (i) + 51 load_var2 12 4 + 52 load_const 1 (1) + 53 sub_int + 54 cmp_int_op < + 55 pop_jump_if_false +2 (to 57) + 56 jump +3 (to 59) + + 603 57 load_const 3 (true) + 58 jump +43 (to 101) + + 594 59 load_var2 3 12 + 60 load_array_element + 61 store_var_load_var 13 (part) + + 595 62 load_const 4 ("") + 63 cmp_op != + 64 pop_jump_if_false +21 (to 85) + + 596 65 load_var2 1 11 + 66 load_var 8 (end_limit) + 67 call 153 ntypeargs=0 (baml.String.substring) + 68 load_var 13 (part) + 69 call 155 ntypeargs=0 (baml.String.index_of) + 70 store_var 14 (_45) + 71 load_var 14 (_45) + 72 narrow_bind 2 14 + 73 pop_jump_if_false +2 (to 75) + 74 jump +3 (to 77) + + 599 75 load_const 5 (false) + 76 jump +25 (to 101) + + 597 77 load_var2 11 14 + + 596 78 add_int + 79 store_var 15 (_47) + + 597 80 load_var 13 (part) + 81 call 139 ntypeargs=0 (baml.String.length) + 82 load_var 15 (_47) + 83 add_int + 84 store_var 11 (pos) + + 593 85 load_var 12 (i) + 86 load_const 1 (1) + 87 add_int + 88 store_var 12 (i) + 89 jump -38 (to 51) + + 590 90 load_const 5 (false) + 91 jump +10 (to 101) + + 585 92 load_const 5 (false) + 93 jump +8 (to 101) + + 582 94 load_const 5 (false) + 95 jump +6 (to 101) + + 577 96 load_var2 1 2 + 97 call 155 ntypeargs=0 (baml.String.index_of) + 98 load_const 6 (null) + 99 call 635 ntypeargs=0 (baml.ops.equals_equals) + 100 unary_op ! + 101 return +} + +function testing.leaf_selected(name: string, include: string[], exclude: string[]) -> bool { + 618 0 load_var2 3 1 + 1 call 751 ntypeargs=0 (testing.any_pattern_matches) + 2 pop_jump_if_false +2 (to 4) + 3 jump +14 (to 17) + + 621 4 load_var 2 (include) + 5 container_len + 6 store_var 4 (_6) + 7 load_var 4 (_6) + 8 load_const 0 (0) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +4 (to 15) + + 624 12 load_var2 2 1 + 13 call 751 ntypeargs=0 (testing.any_pattern_matches) + 14 jump +4 (to 18) + + 622 15 load_const 1 (true) + 16 jump +2 (to 18) + + 619 17 load_const 2 (false) + 18 return +} + +function testing.leaf_selected_layered(name: string, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> bool { + 637 0 load_var2 1 2 + 1 load_var 3 (profile_exclude) + 2 call 752 ntypeargs=0 (testing.leaf_selected) + 3 jump_if_false +5 (to 8) + 4 pop 1 + + 638 5 load_var2 1 4 + 6 load_var 5 (cli_exclude) + 7 call 752 ntypeargs=0 (testing.leaf_selected) + 8 return +} + +function testing.name_in(name: string, names: string[]) -> bool { + 963 0 load_var 2 (names) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +6 (to 19) + 14 load_var2 4 1 + 15 cmp_op == + 16 pop_jump_if_false -11 (to 5) + + 965 17 load_const 5 (true) + 18 jump +2 (to 20) + + 968 19 load_const 6 (false) + 20 return +} + +function testing.pattern_may_match_descendant(pattern: string, prefix: string) -> bool { + 666 0 load_var 2 (prefix) + 1 load_const 0 ("::") + 2 bin_op + + 3 store_var 3 (descendant_prefix) + + 667 4 load_var 1 (pattern) + 5 load_const 1 ("*") + 6 call 155 ntypeargs=0 (baml.String.index_of) + 7 store_var 4 (_4) + 8 load_var 4 (_4) + 9 load_const 2 (null) + 10 cmp_op == + 11 pop_jump_if_false +2 (to 13) + 12 jump +14 (to 26) + + 670 13 load_var 1 (pattern) + 14 load_const 3 (0) + + 667 15 load_var 4 (_4) + 16 call 153 ntypeargs=0 (baml.String.substring) + 17 store_var 5 (literal) + + 671 18 load_var2 3 5 + 19 call 148 ntypeargs=0 (baml.String.starts_with) + 20 jump_if_false +2 (to 22) + 21 jump +6 (to 27) + 22 pop 1 + 23 load_var2 5 3 + 24 call 148 ntypeargs=0 (baml.String.starts_with) + 25 jump +2 (to 27) + + 668 26 load_const 4 (true) + 27 return +} + +function testing.run_children_parallel(children: testing.TestSetChild[]) -> testing.TestSetReport { + 0 load_var 5 + 1 make_cell + 2 store_var 5 + + 484 3 load_type 0 + 4 alloc_array 0 + 5 store_var 2 (futures) + + 485 6 load_var 1 (children) + 7 load_type 1 + 8 load_const 2 ("iter") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 3 (_3) + 11 load_var 3 (_3) + 12 load_type 3 + 13 load_const 4 ("next") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 4 (_4) + 16 load_var 4 (_4) + 17 is_type 5 + 18 pop_jump_if_false +2 (to 20) + 19 jump +18 (to 37) + 20 load_const 6 (null) + 21 make_cell + 22 store_var 5 (child) + 23 load_var 4 (_4) + 24 store_deref 5 + + 486 25 load_var 5 (child) + 26 make_closure 1475 1 + 27 load_const 6 (null) + 28 load_const 6 (null) + 29 load_type 7 + 30 load_type 8 + 31 spawn + 32 store_var 6 (_11) + 33 load_var2 2 6 + 34 call 4 ntypeargs=0 (baml.Array.push) + 35 pop 1 + 36 jump -25 (to 11) + + 490 37 load_type 7 + 38 load_type 8 + 39 load_var 2 (futures) + 40 call 484 ntypeargs=2 (baml.future.all_complete) + 41 await + + 491 42 call 745 ntypeargs=0 (testing.aggregate_reports) + 43 return +} + +function testing.run_children_sequential(children: testing.TestSetChild[], fail_fast: bool) -> testing.TestSetReport { + 110 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (named_results) + + 111 3 load_var 1 (children) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_4) + 8 load_var 4 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_5) + 13 load_var 5 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +36 (to 52) + 17 load_var 5 (_5) + 18 store_var_load_var 6 (child) + + 112 19 load_field 1 (run) + 20 call_indirect + 21 store_var 7 (report) + + 113 22 load_var2 3 6 + 23 load_field 0 (name) + 24 load_var 7 (report) + 25 init_instance 0 (testing.NamedChildReport .name, .report) + 26 call 4 ntypeargs=0 (baml.Array.push) + 27 pop 1 + + 114 28 load_var 7 (report) + 29 store_var 9 (_16) + 30 load_var 9 (_16) + 31 narrow_bind 6 9 + 32 pop_jump_if_false +2 (to 34) + 33 jump +5 (to 38) + 34 load_var 7 (report) + 35 load_field 0 (outcome) + 36 store_var 8 (outcome) + 37 jump +4 (to 41) + 38 load_var 9 (_16) + 39 load_field 0 (outcome) + 40 store_var 8 (outcome) + + 118 41 load_var 2 (fail_fast) + 42 jump_if_false +6 (to 48) + 43 pop 1 + 44 load_var 8 (outcome) + 45 load_const 7 ("pass") + 46 call 635 ntypeargs=0 (baml.ops.equals_equals) + 47 unary_op ! + 48 pop_jump_if_false -40 (to 8) + + 119 49 load_var 3 (named_results) + 50 call 745 ntypeargs=0 (testing.aggregate_reports) + 51 jump +3 (to 54) + + 124 52 load_var 3 (named_results) + 53 call 745 ntypeargs=0 (testing.aggregate_reports) + 54 return +} + +function testing.run_test(body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestReport { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 496 3 load_var 1 (body) + 4 make_closure 1487 1 + 5 store_var 3 (base_run) + + 527 6 load_var 2 (runner) + 7 load_const 0 (null) + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +5 (to 15) + + 530 11 load_var2 3 2 + 12 call_indirect + + 531 13 call_indirect + 14 jump +3 (to 17) + + 528 15 load_var 3 (base_run) + 16 call_indirect + 17 return +} + +function testing.run_testset(children: testing.TestSetChild[], runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> testing.TestSetReport { + 538 0 load_var 2 (runner) + 1 load_const 0 (null) + 2 cmp_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +4 (to 8) + + 540 5 load_var2 1 2 + 6 call_indirect + 7 jump +3 (to 10) + + 539 8 load_var 1 (children) + 9 call 746 ntypeargs=0 (testing.run_children_parallel) + 10 return +} + +function testing.select_names(registry: testing.TestRegistry, include: string[], exclude: string[]) -> string[] { + 739 0 load_var 1 (registry) + 1 load_type 0 + 2 alloc_array 0 + 3 load_type 0 + 4 alloc_array 0 + 5 load_var2 2 3 + 6 call 757 ntypeargs=0 (testing.select_names_layered) + 7 return +} + +function testing.select_names_layered(registry: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 700 0 load_type 0 + 1 alloc_array 0 + 2 store_var 6 (out) + + 701 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 7 (_8) + 10 load_var 7 (_8) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 8 (_9) + 15 load_var 8 (_9) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +13 (to 31) + 19 load_var 8 (_9) + 20 store_var_load_var 9 (t) + + 704 21 load_field 0 (name) + 22 load_var2 2 3 + 23 load_var2 4 5 + 24 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 702 25 pop_jump_if_false -15 (to 10) + + 711 26 load_var2 6 9 + 27 load_field 0 (name) + 28 call 4 ntypeargs=0 (baml.Array.push) + 29 pop 1 + 30 jump -20 (to 10) + + 714 31 load_var 1 (registry) + 32 load_field 0 (collector) + 33 load_field 2 (testsets) + 34 load_type 6 + 35 load_const 7 ("iter") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 10 (_18) + 38 load_var 10 (_18) + 39 load_type 8 + 40 load_const 9 ("next") + 41 virtual_call nargs=1 ntypeargs=0 + 42 store_var 11 (_19) + 43 load_var 11 (_19) + 44 is_type 5 + 45 pop_jump_if_false +2 (to 47) + 46 jump +34 (to 80) + 47 load_var 11 (_19) + 48 store_var_load_var 12 (ts) + + 718 49 load_field 0 (name) + 50 load_var2 2 3 + 51 call 756 ntypeargs=0 (testing.subtree_may_be_selected) + 52 jump_if_false +6 (to 58) + 53 pop 1 + + 719 54 load_var 12 (ts) + 55 load_field 0 (name) + 56 load_var2 4 5 + 57 call 756 ntypeargs=0 (testing.subtree_may_be_selected) + + 717 58 pop_jump_if_false -20 (to 38) + + 721 59 load_var2 1 12 + + 723 60 load_var2 2 3 + 61 load_var2 4 5 + 62 call 761 ntypeargs=0 (testing.collect_subtree_names_layered) + + 729 63 load_type 10 + 64 load_const 11 ("iter") + 65 virtual_call nargs=1 ntypeargs=0 + 66 store_var 13 (_30) + 67 load_var 13 (_30) + 68 load_type 12 + 69 load_const 13 ("next") + 70 virtual_call nargs=1 ntypeargs=0 + 71 store_var 14 (_31) + 72 load_var 14 (_31) + 73 is_type 5 + 74 pop_jump_if_false +2 (to 76) + 75 jump -37 (to 38) + + 730 76 load_var2 6 14 + + 729 77 call 4 ntypeargs=0 (baml.Array.push) + 78 pop 1 + 79 jump -12 (to 67) + + 734 80 load_var 6 (out) + 81 return +} + +function testing.subtree_excluded(prefix: string, excludes: string[]) -> bool { + 645 0 load_var 1 (prefix) + 1 load_const 0 ("::") + 2 bin_op + + 3 store_var 3 (descendant_prefix) + + 646 4 load_var 2 (excludes) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +29 (to 46) + 18 load_var 5 (_5) + 19 store_var 6 (pattern) + + 649 20 load_var 6 (pattern) + 21 load_const 6 ("*") + 22 call 155 ntypeargs=0 (baml.String.index_of) + 23 load_const 7 (null) + 24 call 635 ntypeargs=0 (baml.ops.equals_equals) + 25 jump_if_false +7 (to 32) + 26 pop 1 + 27 load_var2 3 6 + 28 call 155 ntypeargs=0 (baml.String.index_of) + 29 load_const 7 (null) + 30 call 635 ntypeargs=0 (baml.ops.equals_equals) + 31 unary_op ! + 32 pop_jump_if_false +2 (to 34) + 33 jump +11 (to 44) + + 654 34 load_var 6 (pattern) + 35 load_const 8 ("*") + 36 call 149 ntypeargs=0 (baml.String.ends_with) + 37 jump_if_false +4 (to 41) + 38 pop 1 + 39 load_var2 3 6 + 40 call 750 ntypeargs=0 (testing.glob_match) + 41 pop_jump_if_false -32 (to 9) + + 655 42 load_const 9 (true) + 43 jump +4 (to 47) + + 650 44 load_const 9 (true) + 45 jump +2 (to 47) + + 658 46 load_const 10 (false) + 47 return +} + +function testing.subtree_may_be_selected(prefix: string, include: string[], exclude: string[]) -> bool { + 677 0 load_var2 1 3 + 1 call 754 ntypeargs=0 (testing.subtree_excluded) + 2 pop_jump_if_false +2 (to 4) + 3 jump +32 (to 35) + + 680 4 load_var 2 (include) + 5 container_len + 6 store_var 4 (_6) + 7 load_var 4 (_6) + 8 load_const 0 (0) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +22 (to 33) + + 683 12 load_var 2 (include) + 13 load_type 1 + 14 load_const 2 ("iter") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 5 (_7) + 17 load_var 5 (_7) + 18 load_type 3 + 19 load_const 4 ("next") + 20 virtual_call nargs=1 ntypeargs=0 + 21 store_var 6 (_8) + 22 load_var 6 (_8) + 23 is_type 5 + 24 pop_jump_if_false +2 (to 26) + 25 jump +6 (to 31) + 26 load_var2 6 1 + 27 call 755 ntypeargs=0 (testing.pattern_may_match_descendant) + + 684 28 pop_jump_if_false -11 (to 17) + + 685 29 load_const 6 (true) + 30 jump +6 (to 36) + + 688 31 load_const 7 (false) + 32 jump +4 (to 36) + + 681 33 load_const 6 (true) + 34 jump +2 (to 36) + + 678 35 load_const 7 (false) + 36 return +} + +function testing.test_child(name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestSetChild { + 0 load_var 2 + 1 make_cell + 2 store_var 2 + 3 load_var 3 + 4 make_cell + 5 store_var 3 + + 364 6 load_var2 1 2 + + 366 7 load_var 3 (runner) + 8 make_closure 1452 2 + 9 init_instance 0 (testing.TestSetChild .name, .run) + 10 return +} + +function testing.testset_child(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestSetChild { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 374 6 load_deref 2 + 7 load_field 0 (name) + + 375 8 load_var2 1 2 + 9 make_closure 1454 2 + 10 init_instance 0 (testing.TestSetChild .name, .run) + 11 return +} + +function testing.testset_child_selected(registry: testing.TestRegistry, ts: testing.TestSetRegistration, names: string[]) -> testing.TestSetChild { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + 6 load_var 3 + 7 make_cell + 8 store_var 3 + + 390 9 load_deref 2 + 10 load_field 0 (name) + + 391 11 load_var2 1 2 + 12 load_var 3 (names) + 13 make_closure 1456 3 + 14 init_instance 0 (testing.TestSetChild .name, .run) + 15 return +} + +function testing.testset_children(registry: testing.TestRegistry) -> testing.TestSetChild[] { + 329 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (children) + + 330 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 3 (_4) + 10 load_var 3 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 4 (_5) + 15 load_var 4 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +14 (to 32) + 19 load_var 4 (_5) + 20 store_var_load_var 5 (t) + + 331 21 load_field 0 (name) + 22 load_var 5 (t) + 23 load_field 1 (body) + 24 load_var 5 (t) + 25 load_field 2 (runner) + 26 call 740 ntypeargs=0 (testing.test_child) + 27 store_var 6 (_10) + 28 load_var2 2 6 + 29 call 4 ntypeargs=0 (baml.Array.push) + 30 pop 1 + 31 jump -21 (to 10) + + 333 32 load_var 1 (registry) + 33 load_field 0 (collector) + 34 load_field 2 (testsets) + 35 load_type 6 + 36 load_const 7 ("iter") + 37 virtual_call nargs=1 ntypeargs=0 + 38 store_var 7 (_15) + 39 load_var 7 (_15) + 40 load_type 8 + 41 load_const 9 ("next") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 8 (_16) + 44 load_var 8 (_16) + 45 is_type 5 + 46 pop_jump_if_false +2 (to 48) + 47 jump +8 (to 55) + + 334 48 load_var2 1 8 + + 333 49 call 741 ntypeargs=0 (testing.testset_child) + 50 store_var 9 (_21) + + 334 51 load_var2 2 9 + 52 call 4 ntypeargs=0 (baml.Array.push) + 53 pop 1 + 54 jump -15 (to 39) + + 336 55 load_var 2 (children) + 56 return +} + +function testing.testset_children_selected(registry: testing.TestRegistry, names: string[]) -> testing.TestSetChild[] { + 340 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (children) + + 341 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_5) + 10 load_var 4 (_5) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 5 (_6) + 15 load_var 5 (_6) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +19 (to 37) + 19 load_var 5 (_6) + 20 store_var_load_var 6 (t) + + 342 21 load_field 0 (name) + 22 load_var 2 (names) + 23 call 743 ntypeargs=0 (testing._name_selected) + 24 pop_jump_if_false -14 (to 10) + + 343 25 load_var 6 (t) + 26 load_field 0 (name) + 27 load_var 6 (t) + 28 load_field 1 (body) + 29 load_var 6 (t) + 30 load_field 2 (runner) + 31 call 740 ntypeargs=0 (testing.test_child) + 32 store_var 7 (_13) + 33 load_var2 3 7 + 34 call 4 ntypeargs=0 (baml.Array.push) + 35 pop 1 + 36 jump -26 (to 10) + + 348 37 load_var 1 (registry) + 38 load_field 0 (collector) + 39 load_field 2 (testsets) + 40 load_type 6 + 41 load_const 7 ("iter") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 8 (_18) + 44 load_var 8 (_18) + 45 load_type 8 + 46 load_const 9 ("next") + 47 virtual_call nargs=1 ntypeargs=0 + 48 store_var 9 (_19) + 49 load_var 9 (_19) + 50 is_type 5 + 51 pop_jump_if_false +2 (to 53) + 52 jump +15 (to 67) + 53 load_var 9 (_19) + 54 store_var_load_var 10 (ts) + + 354 55 load_field 0 (name) + 56 load_var 2 (names) + 57 call 744 ntypeargs=0 (testing._has_selected_descendant) + 58 pop_jump_if_false -14 (to 44) + + 355 59 load_var2 1 10 + 60 load_var 2 (names) + 61 call 742 ntypeargs=0 (testing.testset_child_selected) + 62 store_var 11 (_26) + 63 load_var2 3 11 + 64 call 4 ntypeargs=0 (baml.Array.push) + 65 pop 1 + 66 jump -22 (to 44) + + 360 67 load_var 3 (children) + 68 return +} + +function user.User.promote(self: User, bonus: int) -> Report { + 9 0 load_var 1 (self) + 1 copy 0 + 2 load_field 1 (age) + 3 load_const 0 (1) + 4 bin_op + + 5 store_field 1 (age) + + 10 6 load_var2 1 2 + 7 call 912 ntypeargs=0 (user.score) + 8 store_var 3 (base) + + 11 9 load_var 3 (base) + 10 load_field 0 (score) + 11 load_var 2 (bonus) + 12 add_int + + 14 13 load_var 3 (base) + 14 load_field 1 (label) + + 15 15 load_var 3 (base) + 16 load_field 2 (breakdown) + 17 init_instance 0 (user.Report .score, .label, .breakdown) + 18 return +} + +function user.http_status(code: int) -> string { + 96 0 load_var 1 (code) + 1 dense_tag 0 + 2 jump_table 0 ([to 21, to 18, to 15, to 12, to 9, to 6], default to 3) + + 103 3 load_const 0 ("Unknown") + 4 store_var 2 (label) + + 96 5 jump +18 (to 23) + + 102 6 load_const 1 ("Internal Server Error") + 7 store_var 2 (label) + + 96 8 jump +15 (to 23) + + 101 9 load_const 2 ("Not Found") + 10 store_var 2 (label) + + 96 11 jump +12 (to 23) + + 100 12 load_const 3 ("Bad Request") + 13 store_var 2 (label) + + 96 14 jump +9 (to 23) + + 99 15 load_const 4 ("No Content") + 16 store_var 2 (label) + + 96 17 jump +6 (to 23) + + 98 18 load_const 5 ("Created") + 19 store_var 2 (label) + + 96 20 jump +3 (to 23) + + 97 21 load_const 6 ("OK") + 22 store_var 2 (label) + + 95 23 load_const 7 ("HTTP ") + + 105 24 load_var 2 (label) + 25 bin_op + + 26 return +} + +function user.score(input: User | ErrorInfo, threshold: int) -> Report { + 45 0 load_var 1 (input) + 1 store_var 4 (_4) + 2 load_var 4 (_4) + 3 narrow_bind 0 4 + 4 pop_jump_if_false +2 (to 6) + 5 jump +5 (to 10) + + 47 6 load_var 1 (input) + 7 load_field 1 (message) + 8 store_var 3 (name) + + 45 9 jump +4 (to 13) + 10 load_var 4 (_4) + 11 load_field 0 (name) + 12 store_var 3 (name) + + 50 13 load_var 1 (input) + 14 store_var 6 (_8) + 15 load_var 6 (_8) + 16 narrow_bind 0 6 + 17 pop_jump_if_false +2 (to 19) + 18 jump +6 (to 24) + + 52 19 load_var 1 (input) + 20 load_field 0 (code) + 21 unary_op - + 22 store_var 5 (age) + + 50 23 jump +4 (to 27) + 24 load_var 6 (_8) + 25 load_field 1 (age) + 26 store_var 5 (age) + + 55 27 load_var 1 (input) + 28 store_var 8 (_13) + 29 load_var 8 (_13) + 30 narrow_bind 0 8 + 31 pop_jump_if_false +2 (to 33) + 32 jump +4 (to 36) + + 62 33 load_var 2 (threshold) + 34 store_var 7 (role_mult) + + 55 35 jump +16 (to 51) + 36 load_var 8 (_13) + 37 load_field 2 (role) + 38 discriminant + 39 jump_table 0 ([to 49, to 46, to 43, to 40], default to 102) + + 60 40 load_var 2 (threshold) + 41 store_var 7 (role_mult) + + 56 42 jump +9 (to 51) + + 59 43 load_var 2 (threshold) + 44 store_var 7 (role_mult) + + 56 45 jump +6 (to 51) + + 58 46 load_var 2 (threshold) + 47 store_var 7 (role_mult) + + 56 48 jump +3 (to 51) + + 57 49 load_var 2 (threshold) + 50 store_var 7 (role_mult) + + 65 51 load_var 5 (age) + 52 load_const 1 (2) + 53 mul_int + 54 load_var 7 (role_mult) + 55 add_int + 56 store_var_load_var 9 (base) + + 66 57 load_var 7 (role_mult) + 58 cmp_int_op > + 59 pop_jump_if_false +2 (to 61) + 60 jump +4 (to 64) + + 69 61 load_var 9 (base) + 62 store_var 10 (capped) + + 66 63 jump +3 (to 66) + + 67 64 load_var 7 (role_mult) + 65 store_var 10 (capped) + + 71 66 load_var2 10 7 + 67 add_int + 68 store_var_load_var 11 (total) + + 73 69 load_var 2 (threshold) + 70 cmp_int_op > + 71 load_const 2 (true) + 72 cmp_op == + 73 pop_jump_if_false +2 (to 75) + 74 jump +4 (to 78) + + 75 75 load_const 3 (" [LOW]") + 76 store_var 12 (suffix) + + 73 77 jump +3 (to 80) + + 74 78 load_const 4 (" [HIGH]") + 79 store_var 12 (suffix) + + 79 80 load_var2 9 10 + 81 load_var 11 (total) + 82 load_type 5 + 83 alloc_array 3 + 84 store_var 13 (scores) + + 80 85 load_var 13 (scores) + 86 load_const 6 (0) + 87 load_var 11 (total) + 88 store_array_element + + 81 89 load_var 13 (scores) + 90 load_const 6 (0) + 91 load_array_element + + 77 92 load_var2 3 12 + 93 bin_op + + + 83 94 load_var2 9 7 + 95 load_const 7 ("base") + 96 load_const 8 ("role") + 97 load_type 9 + 98 load_type 5 + 99 alloc_map 2 + 100 init_instance 0 (user.Report .score, .label, .breakdown) + 101 return + 102 unreachable +} diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap new file mode 100644 index 00000000000..1203287cc52 --- /dev/null +++ b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap @@ -0,0 +1,13149 @@ +--- +source: crates/baml_tests/tests/bytecode_format/main.rs +--- +function ai.Agent.Runner.run(self: ai.Agent<#0>, spec: ai.FunctionSpec<#0>) -> ai.RunResult<#0> { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + 6 load_var 6 + 7 make_cell + 8 store_var 6 + 9 load_var 21 + 10 make_cell + 11 store_var 21 + + 198 12 load_deref 1 + 13 load_field 1 (client) + 14 store_var 5 (_4) + 15 load_var 5 (_4) + 16 store_var 4 (selected) + 17 load_var 5 (_4) + 18 load_const 0 (null) + 19 cmp_op == + 20 pop_jump_if_false +4 (to 24) + 21 load_deref 2 + 22 load_field 4 (default_client) + 23 store_var 4 (selected) + + 199 24 load_type 1 + 25 load_deref 2 + 26 call 784 ntypeargs=1 (ai.Journal.new) + 27 store_deref 6 + + 200 28 load_type 1 + 29 load_deref 1 + 30 load_deref 6 + 31 load_const 2 (0) + 32 call 823 ntypeargs=1 (ai.Agent._emit_from) + 33 store_var 7 (seen) + + 201 34 load_const 2 (0) + 35 store_var 8 (steps) + + 202 36 load_const 2 (0) + 37 load_const 2 (0) + 38 load_const 0 (null) + 39 load_const 0 (null) + 40 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 41 store_var 9 (total) + + 209 42 load_type 3 + 43 load_type 4 + 44 alloc_map 0 + 45 store_var 10 (fail_counts) + + 210 46 load_var 8 (steps) + 47 load_deref 1 + 48 load_field 0 (max_steps) + 49 cmp_int_op < + 50 pop_jump_if_false +2 (to 52) + 51 jump +4 (to 55) + + 269 52 load_var 8 (steps) + 53 init_instance 1 (ai.errors.StepBudgetExceeded .steps) + 54 throw + + 212 55 load_type 1 + 56 load_deref 1 + 57 load_var 4 (selected) + 58 load_deref 2 + 59 load_deref 6 + 60 load_var 9 (total) + 61 load_const 5 (2) + 62 call 822 ntypeargs=1 (ai.Agent._attempt_turn) + 63 store_var 11 (turn) + + 213 64 load_var 8 (steps) + 65 load_const 6 (1) + 66 add_int + 67 store_var 8 (steps) + + 214 68 load_type 1 + 69 load_deref 1 + 70 load_deref 6 + 71 load_var 7 (seen) + 72 call 823 ntypeargs=1 (ai.Agent._emit_from) + 73 store_var 7 (seen) + + 215 74 load_var 11 (turn) + 75 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 76 store_var 12 (calls) + + 216 77 load_var 12 (calls) + 78 container_len + 79 store_var 13 (_28) + 80 load_var 13 (_28) + 81 load_const 2 (0) + 82 cmp_int_op > + 83 pop_jump_if_false +2 (to 85) + 84 jump +65 (to 149) + + 251 85 load_var 11 (turn) + 86 call 802 ntypeargs=0 (ai.ModelTurn.terminal_text) + 87 store_var 35 (_96) + 88 load_var 35 (_96) + 89 store_var 34 (candidate) + 90 load_var 35 (_96) + 91 load_const 0 (null) + 92 cmp_op == + 93 pop_jump_if_false +3 (to 96) + 94 load_const 7 ("") + 95 store_var 34 (candidate) + + 252 96 load_type 1 + 97 load_var 34 (candidate) + 98 call 428 ntypeargs=1 (baml.sap.parse) + 99 store_var 36 (value) + 100 jump +11 (to 111) + 101 load_var 37 (e) + 102 throw_if_panic + + 254 103 load_var 4 (selected) + 104 load_type 8 + 105 load_const 9 ("id") + 106 virtual_call nargs=1 ntypeargs=0 + 107 store_var 38 (_103) + 108 load_var2 38 34 + 109 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) + 110 throw + + 257 111 load_type 1 + 112 load_var 36 (value) + 113 call 333 ntypeargs=1 (baml.json.to_json) + 114 jump +12 (to 126) + 115 load_var 39 (e) + 116 throw_if_panic + + 259 117 load_type 10 + 118 load_var 39 (e) + 119 call 138 ntypeargs=1 (baml.String.from) + 120 store_var 40 (_112) + 121 load_var2 39 40 + 122 load_type 3 + 123 alloc_array 1 + 124 init_instance 3 (baml.errors.UnknownError .data, .message) + 125 throw + + 263 126 call 330 ntypeargs=0 (baml.json.stringify) + 127 store_var 41 (_117) + + 262 128 load_deref 6 + + 263 129 load_var 41 (_117) + 130 init_instance 4 (ai.events.FinalProduced .value_json) + 131 load_type 11 + 132 alloc_array 1 + 133 call 785 ntypeargs=0 (ai.Journal.append_all) + 134 pop 1 + + 265 135 load_type 1 + 136 load_deref 1 + 137 load_deref 6 + 138 load_var 7 (seen) + 139 call 823 ntypeargs=1 (ai.Agent._emit_from) + 140 store_var 7 (seen) + + 266 141 load_var 36 (value) + 142 load_deref 6 + 143 load_var 9 (total) + 144 load_type 1 + 145 init_instance 5 (ai.RunResult .value, .journal, .usage) + 146 store_var 3 (_0) + 147 load_var 3 (_0) + 148 return + + 217 149 load_deref 6 + 150 call 783 ntypeargs=0 (ai.Journal.entries) + 151 container_len + 152 store_var 14 (before) + + 219 153 load_type 12 + 154 load_type 13 + 155 load_type 14 + 156 load_var 12 (calls) + 157 load_type 1 + 158 load_var2 1 2 + 159 load_var 6 (j) + 160 make_closure 1710 captures=3 ntypeargs=1 + 161 call 16 ntypeargs=3 (baml.Array.map) + 162 store_var 15 (futures) + + 222 163 load_type 15 + 164 load_type 16 + 165 load_var 15 (futures) + 166 call 485 ntypeargs=2 (baml.future.all) + 167 await + 168 pop 1 + + 223 169 load_type 1 + 170 load_deref 1 + 171 load_deref 6 + 172 load_var 7 (seen) + 173 call 823 ntypeargs=1 (ai.Agent._emit_from) + 174 store_var 7 (seen) + + 227 175 load_deref 6 + 176 call 783 ntypeargs=0 (ai.Journal.entries) + 177 store_var 16 (entries) + + 228 178 load_var 14 (before) + 179 store_var 17 (i) + + 229 180 load_var 17 (i) + 181 store_var 18 (_47) + 182 load_var 16 (entries) + 183 container_len + 184 store_var 19 (_48) + 185 load_var2 18 19 + 186 cmp_int_op < + 187 pop_jump_if_false -141 (to 46) + + 230 188 load_type 11 + 189 load_var2 16 17 + 190 call 3 ntypeargs=1 (baml.Array.at) + 191 store_var 20 (_52) + 192 load_var 20 (_52) + 193 narrow_bind 17 20 + 194 pop_jump_if_false +60 (to 254) + 195 load_var 20 (_52) + 196 store_deref 21 + + 231 197 load_type 12 + 198 load_type 14 + 199 load_var 12 (calls) + 200 load_type 1 + 201 load_var 21 (f) + 202 make_closure 1711 captures=1 ntypeargs=1 + 203 call 19 ntypeargs=2 (baml.Array.find) + + 234 204 store_var 22 (_58) + 205 load_var 22 (_58) + 206 narrow_bind 18 22 + 207 pop_jump_if_false +47 (to 254) + 208 load_var 22 (_58) + 209 store_var 23 (known) + + 235 210 load_type 3 + 211 load_var 23 (known) + 212 load_field 1 (name) + 213 call 138 ntypeargs=1 (baml.String.from) + 214 store_var 25 (_62) + 215 load_type 3 + 216 load_deref 21 + 217 load_field 1 (message) + 218 call 138 ntypeargs=1 (baml.String.from) + 219 store_var 26 (_65) + 220 load_var 25 (_62) + 221 load_const 19 ("|") + 222 bin_op + + 223 load_var 26 (_65) + 224 bin_op + + 225 store_var 24 (key) + + 236 226 load_type 3 + 227 load_type 4 + 228 load_var2 10 24 + 229 call 38 ntypeargs=2 (baml.Map.get) + 230 store_var 29 (_70) + 231 load_var 29 (_70) + 232 store_var 28 (_69) + 233 load_var 29 (_70) + 234 load_const 0 (null) + 235 cmp_op == + 236 pop_jump_if_false +3 (to 239) + 237 load_const 2 (0) + 238 store_var 28 (_69) + 239 load_var 28 (_69) + 240 load_const 6 (1) + 241 add_int + 242 store_var 27 (n) + + 237 243 load_type 3 + 244 load_type 4 + 245 load_var2 10 24 + 246 load_var 27 (n) + 247 call 37 ntypeargs=2 (baml.Map.set) + 248 pop 1 + + 238 249 load_var 27 (n) + 250 load_const 20 (3) + 251 cmp_int_op >= + 252 pop_jump_if_false +2 (to 254) + 253 jump +6 (to 259) + + 248 254 load_var 17 (i) + 255 load_const 6 (1) + 256 add_int + 257 store_var 17 (i) + + 229 258 jump -78 (to 180) + + 240 259 load_var 23 (known) + 260 load_field 0 (id) + 261 store_var 30 (_83) + + 241 262 load_var 23 (known) + 263 load_field 1 (name) + 264 store_var 31 (_84) + + 242 265 load_type 4 + 266 load_var 27 (n) + 267 call 138 ntypeargs=1 (baml.String.from) + 268 store_var 32 (_88) + 269 load_type 3 + 270 load_deref 21 + 271 load_field 1 (message) + 272 call 138 ntypeargs=1 (baml.String.from) + 273 store_var 33 (_91) + + 239 274 load_var2 30 31 + + 242 275 load_const 21 ("the same tool call failed ") + 276 load_var 32 (_88) + 277 bin_op + + 278 load_const 22 (" times; stopping the run: ") + 279 bin_op + + 280 load_var 33 (_91) + 281 bin_op + + 282 load_const 0 (null) + 283 init_instance 6 (ai.errors.ToolFailedError .id, .name, .message, .cause) + 284 throw +} + +function ai.Agent._attempt_turn(self: ai.Agent<#0>, c: ai.Client, spec: ai.FunctionSpec<#0>, j: ai.Journal, total: ai.events.Usage, attempts_left: int) -> ai.ModelTurn { + 124 0 load_var 3 (spec) + 1 load_field 2 (prompt_template) + 2 store_var 8 (_9) + + 126 3 load_type 0 + 4 load_var 3 (spec) + 5 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 6 store_var 9 (_10) + + 127 7 load_type 0 + 8 load_var 3 (spec) + 9 call 792 ntypeargs=1 (ai.FunctionSpec.output_type) + 10 store_var 10 (_12) + + 122 11 load_var2 2 8 + + 123 12 load_var2 4 9 + 13 load_var 10 (_12) + 14 init_instance 0 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) + 15 load_type 1 + 16 load_const 2 ("invoke") + 17 virtual_call nargs=2 ntypeargs=0 + 18 store_var 7 (turn) + + 130 19 load_var 7 (turn) + 20 load_field 2 (usage) + 21 store_var 11 (_15) + 22 load_var 11 (_15) + 23 narrow_bind 3 11 + 24 pop_jump_if_false +63 (to 87) + 25 load_var 11 (_15) + 26 store_var 12 (u) + + 131 27 load_var 5 (total) + 28 copy 0 + 29 load_field 0 (input_tokens) + 30 load_var 12 (u) + 31 load_field 0 (input_tokens) + 32 bin_op + + 33 store_field 0 (input_tokens) + + 132 34 load_var 5 (total) + 35 copy 0 + 36 load_field 1 (output_tokens) + 37 load_var 12 (u) + 38 load_field 1 (output_tokens) + 39 bin_op + + 40 store_field 1 (output_tokens) + + 133 41 load_var 12 (u) + 42 load_field 2 (cached_input_tokens) + 43 store_var 13 (_20) + 44 load_var 13 (_20) + 45 narrow_bind 4 13 + 46 pop_jump_if_false +18 (to 64) + 47 load_var 13 (_20) + 48 store_var 14 (ci) + + 134 49 load_var 5 (total) + 50 load_field 2 (cached_input_tokens) + 51 store_var 16 (_23) + 52 load_var 16 (_23) + 53 store_var 15 (_22) + 54 load_var 16 (_23) + 55 load_const 5 (null) + 56 cmp_op == + 57 pop_jump_if_false +3 (to 60) + 58 load_const 4 (0) + 59 store_var 15 (_22) + 60 load_var2 5 15 + 61 load_var 14 (ci) + 62 bin_op + + 63 store_field 2 (cached_input_tokens) + + 136 64 load_var 12 (u) + 65 load_field 3 (reasoning_tokens) + 66 store_var 17 (_27) + 67 load_var 17 (_27) + 68 narrow_bind 4 17 + 69 pop_jump_if_false +18 (to 87) + 70 load_var 17 (_27) + 71 store_var 18 (rt) + + 137 72 load_var 5 (total) + 73 load_field 3 (reasoning_tokens) + 74 store_var 20 (_30) + 75 load_var 20 (_30) + 76 store_var 19 (_29) + 77 load_var 20 (_30) + 78 load_const 5 (null) + 79 cmp_op == + 80 pop_jump_if_false +3 (to 83) + 81 load_const 4 (0) + 82 store_var 19 (_29) + 83 load_var2 5 19 + 84 load_var 18 (rt) + 85 bin_op + + 86 store_field 3 (reasoning_tokens) + + 141 87 load_var 7 (turn) + 88 load_field 0 (content) + 89 store_var 22 (_35) + 90 load_var 2 (c) + 91 load_type 1 + 92 load_const 6 ("id") + 93 virtual_call nargs=1 ntypeargs=0 + 94 store_var 23 (_36) + 95 load_var2 22 23 + 96 init_instance 1 (ai.events.AssistantMessage .content, .client_id) + 97 load_type 7 + 98 alloc_array 1 + 99 store_var 21 (batch) + + 142 100 load_var 7 (turn) + 101 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 102 load_type 8 + 103 load_const 9 ("iter") + 104 virtual_call nargs=1 ntypeargs=0 + 105 store_var 24 (_38) + 106 load_var 24 (_38) + 107 load_type 10 + 108 load_const 11 ("next") + 109 virtual_call nargs=1 ntypeargs=0 + 110 store_var 25 (_39) + 111 load_var 25 (_39) + 112 is_type 12 + 113 pop_jump_if_false +2 (to 115) + 114 jump +13 (to 127) + 115 load_var 25 (_39) + 116 store_var 26 (u) + + 143 117 load_var2 21 26 + 118 load_field 0 (id) + 119 load_var 26 (u) + 120 load_field 1 (name) + 121 load_var 26 (u) + 122 load_field 2 (args) + 123 init_instance 2 (ai.events.ToolRequested .id, .name, .args) + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + 126 jump -20 (to 106) + + 145 127 load_var 7 (turn) + 128 load_field 2 (usage) + 129 store_var 27 (_49) + 130 load_var 27 (_49) + 131 narrow_bind 3 27 + 132 pop_jump_if_false +6 (to 138) + 133 load_var 27 (_49) + 134 store_var 28 (u) + + 146 135 load_var2 21 28 + 136 call 4 ntypeargs=0 (baml.Array.push) + 137 pop 1 + + 148 138 load_var 7 (turn) + 139 call 802 ntypeargs=0 (ai.ModelTurn.terminal_text) + 140 store_var 30 (_54) + 141 load_var 30 (_54) + 142 store_var 29 (candidate) + 143 load_var 30 (_54) + 144 load_const 5 (null) + 145 cmp_op == + 146 pop_jump_if_false +3 (to 149) + 147 load_const 13 ("") + 148 store_var 29 (candidate) + + 149 149 load_var 7 (turn) + 150 call 803 ntypeargs=0 (ai.ModelTurn.tool_uses) + 151 container_len + 152 store_var 31 (_60) + 153 load_var 31 (_60) + 154 load_const 4 (0) + 155 cmp_int_op > + 156 jump_if_false +2 (to 158) + 157 jump +7 (to 164) + 158 pop 1 + + 150 159 load_var 7 (turn) + 160 load_field 1 (stop_reason) + 161 load_const 14 (ai.content.StopReason.MaxTokens) + 162 alloc_variant 436 (ai.content.StopReason) + 163 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 149 164 jump_if_false +2 (to 166) + 165 jump +7 (to 172) + 166 pop 1 + + 151 167 load_var 7 (turn) + 168 load_field 1 (stop_reason) + 169 load_const 15 (ai.content.StopReason.Refused) + 170 alloc_variant 436 (ai.content.StopReason) + 171 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 149 172 jump_if_false +2 (to 174) + 173 jump +5 (to 178) + 174 pop 1 + + 152 175 load_type 0 + 176 load_var2 1 29 + 177 call 821 ntypeargs=1 (ai.Agent._parses) + + 153 178 pop_jump_if_false +2 (to 180) + 179 jump +33 (to 212) + + 166 180 load_var 6 (attempts_left) + 181 load_const 16 (1) + 182 cmp_int_op > + 183 pop_jump_if_false +2 (to 185) + 184 jump +12 (to 196) + + 175 185 load_var2 4 21 + 186 call 785 ntypeargs=0 (ai.Journal.append_all) + 187 pop 1 + + 176 188 load_var 2 (c) + 189 load_type 1 + 190 load_const 17 ("id") + 191 virtual_call nargs=1 ntypeargs=0 + 192 store_var 34 (_86) + 193 load_var2 34 29 + 194 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) + 195 throw + + 167 196 load_var 21 (batch) + + 168 197 load_const 18 ("The reply did not match the required schema. Answer again with only the corrected value.") + 198 init_instance 4 (ai.events.UserMessage .content) + 199 call 4 ntypeargs=0 (baml.Array.push) + 200 pop 1 + + 172 201 load_var2 4 21 + 202 call 785 ntypeargs=0 (ai.Journal.append_all) + 203 pop 1 + + 173 204 load_type 0 + 205 load_var2 1 2 + 206 load_var2 3 4 + 207 load_var2 5 6 + 208 load_const 16 (1) + 209 sub_int + 210 call 822 ntypeargs=1 (ai.Agent._attempt_turn) + 211 jump +19 (to 230) + + 154 212 load_var2 4 21 + 213 call 785 ntypeargs=0 (ai.Journal.append_all) + 214 pop 1 + + 156 215 load_var 7 (turn) + 216 load_field 1 (stop_reason) + 217 discriminant + 218 load_const 14 (StopReason.MaxTokens) + 219 cmp_int_op == + 220 pop_jump_if_false +2 (to 222) + 221 jump +20 (to 241) + 222 load_var 7 (turn) + 223 load_field 1 (stop_reason) + 224 discriminant + 225 load_const 15 (StopReason.Refused) + 226 cmp_int_op == + 227 pop_jump_if_false +2 (to 229) + 228 jump +3 (to 231) + + 165 229 load_var 7 (turn) + 230 return + + 161 231 load_var 2 (c) + 232 load_type 1 + 233 load_const 19 ("id") + 234 virtual_call nargs=1 ntypeargs=0 + 235 store_var 33 (_75) + 236 load_var 33 (_75) + 237 load_const 20 ("the model declined to answer") + 238 load_const 5 (null) + 239 init_instance 5 (ai.errors.Refused .provider, .reason, .raw_body) + 240 throw + + 158 241 load_var 2 (c) + 242 load_type 1 + 243 load_const 21 ("id") + 244 virtual_call nargs=1 ntypeargs=0 + 245 store_var 32 (_72) + 246 load_var2 32 29 + 247 init_instance 6 (ai.errors.ParseFailed .provider, .raw_output) + 248 throw +} + +function ai.Agent._emit_from(self: ai.Agent<#0>, j: ai.Journal, seen: int) -> int { + 182 0 load_var 2 (j) + 1 call 783 ntypeargs=0 (ai.Journal.entries) + 2 store_var 4 (entries) + + 183 3 load_var 3 (seen) + 4 store_var 5 (i) + + 184 5 load_var 5 (i) + 6 store_var 6 (_7) + 7 load_var 4 (entries) + 8 container_len + 9 store_var 7 (_8) + 10 load_var2 6 7 + 11 cmp_int_op < + 12 pop_jump_if_false +2 (to 14) + 13 jump +4 (to 17) + + 190 14 load_var 4 (entries) + 15 container_len + 16 return + + 185 17 load_type 0 + 18 load_var2 4 5 + 19 call 3 ntypeargs=1 (baml.Array.at) + 20 store_var 8 (_12) + 21 load_var 8 (_12) + 22 narrow_bind 1 8 + 23 pop_jump_if_false +2 (to 25) + 24 jump +28 (to 52) + 25 load_var 8 (_12) + 26 narrow_bind 2 8 + 27 pop_jump_if_false +2 (to 29) + 28 jump +24 (to 52) + 29 load_var 8 (_12) + 30 narrow_bind 3 8 + 31 pop_jump_if_false +2 (to 33) + 32 jump +20 (to 52) + 33 load_var 8 (_12) + 34 narrow_bind 4 8 + 35 pop_jump_if_false +2 (to 37) + 36 jump +16 (to 52) + 37 load_var 8 (_12) + 38 narrow_bind 5 8 + 39 pop_jump_if_false +2 (to 41) + 40 jump +12 (to 52) + 41 load_var 8 (_12) + 42 narrow_bind 6 8 + 43 pop_jump_if_false +2 (to 45) + 44 jump +8 (to 52) + 45 load_var 8 (_12) + 46 narrow_bind 7 8 + 47 pop_jump_if_false +2 (to 49) + 48 jump +4 (to 52) + 49 load_var 8 (_12) + 50 narrow_bind 8 8 + 51 pop_jump_if_false +7 (to 58) + 52 load_var 8 (_12) + 53 store_var_load_var 9 (e) + + 186 54 load_var 1 (self) + 55 load_field 3 (on_event) + 56 call_indirect + 57 pop 1 + + 188 58 load_var 5 (i) + 59 load_const 9 (1) + 60 add_int + 61 store_var 5 (i) + + 184 62 jump -57 (to 5) +} + +function ai.Agent._parses(self: ai.Agent<#0>, candidate: string) -> bool { + 100 0 load_type 0 + 1 load_var 2 (candidate) + 2 call 428 ntypeargs=1 (baml.sap.parse) + 3 pop 1 + 4 jump +5 (to 9) + 5 load_var 3 (e) + 6 throw_if_panic + + 102 7 load_const 1 (false) + 8 jump +2 (to 10) + + 105 9 load_const 2 (true) + 10 return +} + +function ai.Agent._run_one_tool(self: ai.Agent<#0>, tb: ai.tools.Toolbox, call: ai.content.ToolUse, j: ai.Journal) -> null { + 56 0 load_var2 2 3 + 1 load_field 1 (name) + 2 call 800 ntypeargs=0 (ai.tools.Toolbox.get) + 3 store_var 5 (_7) + 4 load_var 5 (_7) + 5 narrow_bind 0 5 + 6 pop_jump_if_false +2 (to 8) + 7 jump +20 (to 27) + + 89 8 load_var 3 (call) + 9 load_field 0 (id) + 10 store_var 21 (_41) + + 90 11 load_type 1 + 12 load_var 3 (call) + 13 load_field 1 (name) + 14 call 138 ntypeargs=1 (baml.String.from) + 15 store_var 22 (_43) + + 86 16 load_var2 4 21 + + 90 17 load_const 2 ("tool is not in the active toolbox: ") + 18 load_var 22 (_43) + 19 bin_op + + 20 init_instance 0 (ai.events.ToolFailed .id, .message) + 21 load_type 3 + 22 alloc_array 1 + 23 call 785 ntypeargs=0 (ai.Journal.append_all) + 24 pop 1 + + 94 25 load_const 4 (null) + + 56 26 jump +88 (to 114) + 27 load_var 5 (_7) + 28 store_var 6 (t) + + 58 29 load_var2 6 3 + 30 load_field 2 (args) + 31 call 795 ntypeargs=0 (ai.tools.Tool.call) + 32 store_var 7 (outcome) + 33 jump +65 (to 98) + 34 load_var 8 (e) + 35 throw_if_panic + + 61 36 load_var 3 (call) + 37 load_field 0 (id) + 38 store_var 9 (_15) + 39 load_type 5 + 40 load_var 8 (e) + 41 call 138 ntypeargs=1 (baml.String.from) + 42 store_var 10 (_16) + + 60 43 load_var2 4 9 + + 61 44 load_var 10 (_16) + 45 init_instance 1 (ai.events.ToolFailed .id, .message) + 46 load_type 3 + 47 alloc_array 1 + 48 call 785 ntypeargs=0 (ai.Journal.append_all) + 49 pop 1 + + 64 50 load_var 6 (t) + 51 load_field 5 (on_error) + 52 store_var 12 (_20) + 53 load_var 12 (_20) + 54 store_var 11 (_19) + 55 load_var 12 (_20) + 56 load_const 4 (null) + 57 cmp_op == + 58 pop_jump_if_false +4 (to 62) + 59 load_var 1 (self) + 60 load_field 2 (tool_errors) + 61 store_var 11 (_19) + 62 load_var 11 (_19) + 63 load_const 6 (ai.tools.ErrorMode.Raise) + 64 alloc_variant 437 (ai.tools.ErrorMode) + 65 call 635 ntypeargs=0 (baml.ops.equals_equals) + 66 pop_jump_if_false +2 (to 68) + 67 jump +4 (to 71) + + 76 68 load_const 4 (null) + 69 store_var 7 (outcome) + + 64 70 jump +28 (to 98) + + 65 71 load_var 8 (e) + 72 store_var 14 (_23) + 73 load_var 14 (_23) + 74 narrow_bind 7 14 + 75 pop_jump_if_false +2 (to 77) + 76 jump +4 (to 80) + + 67 77 load_const 4 (null) + 78 store_var 13 (classified) + + 65 79 jump +5 (to 84) + 80 load_var 14 (_23) + 81 store_var 15 (f) + + 66 82 load_var 15 (f) + 83 store_var 13 (classified) + + 70 84 load_var 3 (call) + 85 load_field 0 (id) + 86 store_var 16 (_26) + + 71 87 load_var 3 (call) + 88 load_field 1 (name) + 89 store_var 17 (_27) + + 72 90 load_type 5 + 91 load_var 8 (e) + 92 call 138 ntypeargs=1 (baml.String.from) + 93 store_var 18 (_28) + + 69 94 load_var2 16 17 + 95 load_var2 18 13 + + 73 96 init_instance 2 (ai.errors.ToolFailedError .id, .name, .message, .cause) + 97 throw + + 80 98 load_var 7 (outcome) + 99 store_var 19 (_31) + 100 load_var 19 (_31) + 101 narrow_bind 6 19 + 102 pop_jump_if_false +11 (to 113) + 103 load_var 19 (_31) + 104 store_var 20 (output) + + 81 105 load_var2 4 3 + 106 load_field 0 (id) + 107 load_var 20 (output) + 108 init_instance 3 (ai.events.ToolCompleted .id, .output) + 109 load_type 3 + 110 alloc_array 1 + 111 call 785 ntypeargs=0 (ai.Journal.append_all) + 112 pop 1 + + 83 113 load_const 4 (null) + 114 return +} + +function ai.Agent.new(max_steps: int, client: ai.Client | null, tool_errors: ai.tools.ErrorMode, on_event: ((ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced) -> null throws never) | null) -> ai.Agent<#0> { + 0 load_var 1 (max_steps) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 30 4 load_const 1 (12) + 5 store_var 1 (max_steps) + 6 load_var 2 (client) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 31 10 load_const 2 (null) + 11 store_var 2 (client) + 12 load_var 3 (tool_errors) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +4 (to 19) + + 32 16 load_const 3 (ai.tools.ErrorMode.Report) + 17 alloc_variant 437 (ai.tools.ErrorMode) + 18 store_var 3 (tool_errors) + 19 load_var 4 (on_event) + 20 load_const 0 () + 21 cmp_op == + 22 pop_jump_if_false +3 (to 25) + + 33 23 load_const 2 (null) + 24 store_var 4 (on_event) + + 39 25 load_var 4 (on_event) + 26 store_var 5 (_9) + 27 load_var 4 (on_event) + 28 load_const 2 (null) + 29 cmp_op == + 30 pop_jump_if_false +4 (to 34) + + 41 31 load_type 4 + 32 make_closure 1692 captures=0 ntypeargs=1 + 33 store_var 5 (_9) + + 35 34 load_var2 1 2 + 35 load_var2 3 5 + 36 load_type 4 + 37 init_instance 0 (ai.Agent .max_steps, .client, .tool_errors, .on_event) + 38 return +} + +function ai.FunctionSpec.arguments(self: ai.FunctionSpec<#0>) -> map { + 73 0 load_var 1 (self) + 1 load_field 1 (args) + 2 return +} + +function ai.FunctionSpec.name(self: ai.FunctionSpec<#0>) -> string { + 69 0 load_var 1 (self) + 1 load_field 0 (spec_name) + 2 return +} + +function ai.FunctionSpec.output_type(self: ai.FunctionSpec<#0>) -> type { + 77 0 load_type 0 + 1 store_var 2 (_0) + 2 load_var 2 (_0) + 3 return +} + +function ai.FunctionSpec.prompt(self: ai.FunctionSpec<#0>, output_format: string) -> ai.Prompt { + 0 load_var 2 (output_format) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 80 4 load_const 1 ("") + 5 store_var 2 (output_format) + + 81 6 load_var2 2 1 + 7 load_field 2 (prompt_template) + 8 call_indirect + 9 return +} + +function ai.FunctionSpec.tools(self: ai.FunctionSpec<#0>) -> ai.tools.Toolbox { + 85 0 load_var 1 (self) + 1 load_field 3 (toolbox) + 2 return +} + +function ai.Journal.append_all(self: ai.Journal, events: (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[]) -> void { + 27 0 load_var 2 (events) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 4 (_3) + 5 load_var 4 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 5 (_4) + 10 load_var 5 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +10 (to 23) + 14 load_var 5 (_4) + 15 store_var 6 (e) + + 28 16 load_type 5 + 17 load_var 1 (self) + 18 load_field 0 (log) + 19 load_var 6 (e) + 20 call 4 ntypeargs=1 (baml.Array.push) + 21 pop 1 + 22 jump -17 (to 5) + + 26 23 load_const 6 (null) + 24 store_var 3 (_0) + 25 load_var 3 (_0) + 26 return +} + +function ai.Journal.entries(self: ai.Journal) -> (ai.events.RunStarted | ai.events.UserMessage | ai.events.AssistantMessage | ai.events.ToolRequested | ai.events.ToolCompleted | ai.events.ToolFailed | ai.events.Usage | ai.events.FinalProduced)[] { + 15 0 load_var 1 (self) + 1 load_field 0 (log) + 2 return +} + +function ai.Journal.new(spec: ai.FunctionSpec<#0>) -> ai.Journal { + 21 0 load_type 0 + 1 load_var 1 (spec) + 2 call 790 ntypeargs=1 (ai.FunctionSpec.name) + 3 store_var 3 (_4) + 4 load_type 0 + 5 load_var 1 (spec) + 6 call 791 ntypeargs=1 (ai.FunctionSpec.arguments) + 7 store_var 4 (_6) + 8 load_var2 3 4 + 9 init_instance 0 (ai.events.RunStarted .spec_name, .arguments) + 10 load_type 1 + 11 alloc_array 1 + 12 init_instance 1 (ai.Journal .log) + 13 store_var 2 (_0) + 14 load_var 2 (_0) + 15 return +} + +function ai.ModelTurn.terminal_text(self: ai.ModelTurn) -> string | null { + 22 0 load_const 0 (null) + 1 store_var 2 (out) + + 23 2 load_var 1 (self) + 3 load_field 0 (content) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_4) + 8 load_var 3 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_5) + 13 load_var 4 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +14 (to 30) + 17 load_var 4 (_5) + 18 store_var 5 (b) + + 24 19 load_var 5 (b) + 20 store_var 6 (_9) + 21 load_var 6 (_9) + 22 narrow_bind 6 6 + 23 pop_jump_if_false -15 (to 8) + 24 load_var 6 (_9) + 25 store_var 7 (t) + + 25 26 load_var 7 (t) + 27 load_field 0 (text) + 28 store_var 2 (out) + + 24 29 jump -21 (to 8) + + 28 30 load_var 2 (out) + 31 return +} + +function ai.ModelTurn.tool_uses(self: ai.ModelTurn) -> ai.content.ToolUse[] { + 33 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 34 3 load_var 1 (self) + 4 load_field 0 (content) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +14 (to 31) + 18 load_var 5 (_5) + 19 store_var 6 (b) + + 35 20 load_var 6 (b) + 21 store_var 7 (_9) + 22 load_var 7 (_9) + 23 narrow_bind 6 7 + 24 pop_jump_if_false -15 (to 9) + 25 load_var 7 (_9) + 26 store_var 8 (u) + + 36 27 load_var2 3 8 + 28 call 4 ntypeargs=0 (baml.Array.push) + 29 pop 1 + 30 jump -21 (to 9) + + 39 31 load_var 3 (out) + 32 store_var 2 (_0) + 33 load_var 2 (_0) + 34 return +} + +function ai.Prompt.baml.ToString.to_string(self: ai.Prompt) -> string { + 35 0 load_var 1 (self) + 1 call 786 ntypeargs=0 (ai.Prompt.text) + 2 return +} + +function ai.Prompt.messages(self: ai.Prompt) -> ai.PromptMessage[] { +} + +function ai.Prompt.text(self: ai.Prompt) -> string { +} + +function ai.clients.Backoff.delay_ms(self: ai.clients.Backoff, attempt: int, f: ai.errors.Failure) -> int { + 27 0 load_var 3 (f) + 1 store_var 4 (_5) + 2 load_var 4 (_5) + 3 narrow_bind 0 4 + 4 pop_jump_if_false +2 (to 6) + 5 jump +3 (to 8) + + 29 6 load_const 1 (null) + + 27 7 jump +5 (to 12) + 8 load_var 4 (_5) + 9 store_var 5 (r) + + 28 10 load_var 5 (r) + 11 load_field 1 (retry_after_ms) + + 31 12 store_var 6 (_7) + 13 load_var 6 (_7) + 14 narrow_bind 2 6 + 15 pop_jump_if_false +2 (to 17) + 16 jump +29 (to 45) + + 34 17 load_var 1 (self) + 18 load_field 0 (initial_ms) + 19 store_var 8 (d) + + 35 20 load_const 3 (1) + 21 store_var 9 (i) + + 36 22 load_var2 9 2 + 23 cmp_int_op < + 24 pop_jump_if_false +2 (to 26) + 25 jump +11 (to 36) + + 40 26 load_var2 8 1 + 27 load_field 2 (max_ms) + 28 cmp_int_op > + 29 pop_jump_if_false +2 (to 31) + 30 jump +3 (to 33) + + 43 31 load_var 8 (d) + + 40 32 jump +16 (to 48) + + 41 33 load_var 1 (self) + 34 load_field 2 (max_ms) + + 40 35 jump +13 (to 48) + + 37 36 load_var2 8 1 + 37 load_field 1 (multiplier) + 38 mul_int + 39 store_var 8 (d) + + 38 40 load_var 9 (i) + 41 load_const 3 (1) + 42 add_int + 43 store_var 9 (i) + + 36 44 jump -22 (to 22) + + 31 45 load_var 6 (_7) + 46 store_var 7 (h) + + 32 47 load_var 7 (h) + 48 return +} + +function ai.clients.Backoff.new(initial_ms: int, multiplier: int, max_ms: int) -> ai.clients.Backoff { + 0 load_var 1 (initial_ms) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 20 4 load_const 1 (250) + 5 store_var 1 (initial_ms) + 6 load_var 2 (multiplier) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + 10 load_const 2 (2) + 11 store_var 2 (multiplier) + 12 load_var 3 (max_ms) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + 16 load_const 3 (10000) + 17 store_var 3 (max_ms) + + 21 18 load_var2 1 2 + 19 load_var 3 (max_ms) + 20 init_instance 0 (ai.clients.Backoff .initial_ms, .multiplier, .max_ms) + 21 return +} + +function ai.clients.Fallback._try(self: ai.clients.Fallback, input: ai.ModelTurnInput, index: int) -> ai.ModelTurn { + 151 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_var 3 (index) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 4 (_7) + 6 load_var 4 (_7) + 7 narrow_bind 0 4 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 168 10 load_const 1 ("Fallback needs at least one member") + 11 init_instance 0 (baml.errors.InvalidArgument .message) + 12 throw + + 151 13 load_var 4 (_7) + 14 store_var 5 (c) + + 153 15 load_var2 5 2 + 16 load_type 0 + 17 load_const 2 ("invoke") + 18 virtual_call nargs=2 ntypeargs=0 + 19 jump +43 (to 62) + 20 load_var 6 (e) + 21 store_var 7 (_10) + 22 load_var 7 (_10) + 23 narrow_bind 3 7 + 24 pop_jump_if_false +2 (to 26) + 25 jump +5 (to 30) + 26 load_var 6 (e) + 27 throw_if_panic + + 164 28 load_var 6 (e) + 29 rethrow + + 153 30 load_var 7 (_10) + 31 store_var 8 (f) + + 156 32 load_var 3 (index) + 33 load_const 4 (1) + 34 add_int + 35 store_var 9 (_14) + 36 load_var 1 (self) + 37 load_field 0 (members) + 38 container_len + 39 store_var 10 (_15) + 40 load_var2 9 10 + 41 cmp_int_op < + 42 jump_if_false +11 (to 53) + 43 pop 1 + + 157 44 load_var 8 (f) + 45 load_type 3 + 46 load_const 5 ("retry_safety") + 47 virtual_call nargs=1 ntypeargs=0 + 48 store_var 11 (_17) + 49 load_var 11 (_17) + 50 load_const 6 (ai.errors.RetrySafety.Safe) + 51 alloc_variant 438 (ai.errors.RetrySafety) + 52 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 155 53 pop_jump_if_false +2 (to 55) + 54 jump +3 (to 57) + + 161 55 load_var 6 (e) + 56 rethrow + + 159 57 load_var2 1 2 + 58 load_var 3 (index) + 59 load_const 4 (1) + 60 add_int + 61 call 816 ntypeargs=0 (ai.clients.Fallback._try) + 62 return +} + +function ai.clients.Fallback.root.Client.id(self: ai.clients.Fallback) -> string { + 177 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_const 1 (0) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 3 (_5) + 6 load_var 3 (_5) + 7 narrow_bind 0 3 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 180 10 load_const 2 ("fallback") + 11 store_var 2 (_0) + + 177 12 jump +8 (to 20) + 13 load_var 3 (_5) + 14 store_var 4 (c) + + 178 15 load_var 4 (c) + 16 load_type 0 + 17 load_const 3 ("id") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 2 (_0) + 20 load_var 2 (_0) + 21 return +} + +function ai.clients.Fallback.root.Client.invoke(self: ai.clients.Fallback, input: ai.ModelTurnInput) -> ai.ModelTurn { + 185 0 load_var2 1 2 + 1 load_const 0 (0) + 2 call 816 ntypeargs=0 (ai.clients.Fallback._try) + 3 jump +6 (to 9) + 4 load_var 3 (e) + 5 throw_if_panic + + 186 6 load_var 3 (e) + 7 call 834 ntypeargs=0 (ai.errors.normalize) + 8 throw + 9 return +} + +function ai.clients.Retry._attempt(self: ai.clients.Retry, input: ai.ModelTurnInput, remaining: int) -> ai.ModelTurn { + 70 0 load_var 1 (self) + 1 load_field 0 (inner) + 2 load_var 2 (input) + 3 load_type 0 + 4 load_const 1 ("invoke") + 5 virtual_call nargs=2 ntypeargs=0 + 6 jump +58 (to 64) + 7 load_var 4 (e) + 8 store_var 5 (_6) + 9 load_var 5 (_6) + 10 narrow_bind 2 5 + 11 pop_jump_if_false +2 (to 13) + 12 jump +5 (to 17) + 13 load_var 4 (e) + 14 throw_if_panic + + 89 15 load_var 4 (e) + 16 rethrow + + 70 17 load_var 5 (_6) + 18 store_var 6 (f) + + 74 19 load_var 3 (remaining) + 20 load_const 3 (1) + 21 cmp_int_op > + 22 jump_if_false +11 (to 33) + 23 pop 1 + + 75 24 load_var 6 (f) + 25 load_type 2 + 26 load_const 4 ("retry_safety") + 27 virtual_call nargs=1 ntypeargs=0 + 28 store_var 7 (_11) + 29 load_var 7 (_11) + 30 load_const 5 (ai.errors.RetrySafety.Safe) + 31 alloc_variant 438 (ai.errors.RetrySafety) + 32 call 635 ntypeargs=0 (baml.ops.equals_equals) + + 74 33 jump_if_false +5 (to 38) + 34 pop 1 + + 76 35 load_var2 6 1 + 36 load_field 2 (retry_if) + 37 call_indirect + + 73 38 pop_jump_if_false +2 (to 40) + 39 jump +3 (to 42) + + 86 40 load_var 4 (e) + 41 rethrow + + 78 42 load_var 1 (self) + 43 load_field 1 (max_attempts) + 44 load_var 3 (remaining) + 45 sub_int + 46 load_const 3 (1) + 47 add_int + 48 store_var 8 (attempt) + + 80 49 load_var 1 (self) + 50 load_field 3 (backoff) + 51 load_var2 8 6 + 52 call 808 ntypeargs=0 (ai.clients.Backoff.delay_ms) + 53 call 504 ntypeargs=0 (baml.time.Duration.from_milliseconds) + + 79 54 sys_op 258 (baml.sys.sleep) + 55 pop 1 + 56 jump +3 (to 59) + 57 load_var 9 (se) + 58 throw_if_panic + + 84 59 load_var2 1 2 + 60 load_var 3 (remaining) + 61 load_const 3 (1) + 62 sub_int + 63 call 810 ntypeargs=0 (ai.clients.Retry._attempt) + 64 return +} + +function ai.clients.Retry.new(inner: ai.Client, max_attempts: int, retry_if: ((ai.errors.Failure) -> bool throws never) | null, backoff: ai.clients.Backoff | null) -> ai.clients.Retry { + 0 load_var 2 (max_attempts) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 57 4 load_const 1 (3) + 5 store_var 2 (max_attempts) + 6 load_var 3 (retry_if) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 58 10 load_const 2 (null) + 11 store_var 3 (retry_if) + 12 load_var 4 (backoff) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 59 16 load_const 2 (null) + 17 store_var 4 (backoff) + + 64 18 load_var 3 (retry_if) + 19 store_var 5 (_8) + 20 load_var 3 (retry_if) + 21 load_const 2 (null) + 22 cmp_op == + 23 pop_jump_if_false +3 (to 26) + 24 load_const 3 (ai.clients.default_retry_judgment) + 25 store_var 5 (_8) + + 65 26 load_var 4 (backoff) + 27 store_var 6 (_10) + 28 load_var 4 (backoff) + 29 load_const 2 (null) + 30 cmp_op == + 31 pop_jump_if_false +6 (to 37) + 32 load_const 0 () + 33 load_const 0 () + 34 load_const 0 () + 35 call 807 ntypeargs=0 (ai.clients.Backoff.new) + 36 store_var 6 (_10) + + 61 37 load_var2 1 2 + 38 load_var2 5 6 + 39 init_instance 0 (ai.clients.Retry .inner, .max_attempts, .retry_if, .backoff) + 40 return +} + +function ai.clients.Retry.root.Client.id(self: ai.clients.Retry) -> string { + 95 0 load_var 1 (self) + 1 load_field 0 (inner) + 2 load_type 0 + 3 load_const 1 ("id") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 2 (_0) + 6 load_var 2 (_0) + 7 return +} + +function ai.clients.Retry.root.Client.invoke(self: ai.clients.Retry, input: ai.ModelTurnInput) -> ai.ModelTurn { + 99 0 load_var2 1 2 + 1 load_var 1 (self) + 2 load_field 1 (max_attempts) + 3 call 810 ntypeargs=0 (ai.clients.Retry._attempt) + 4 jump +6 (to 10) + 5 load_var 3 (e) + 6 throw_if_panic + + 100 7 load_var 3 (e) + 8 call 834 ntypeargs=0 (ai.errors.normalize) + 9 throw + 10 return +} + +function ai.clients.RoundRobin.new(members: ai.Client[]) -> ai.clients.RoundRobin { + 115 0 load_var 1 (members) + 1 container_len + 2 store_var 3 (_3) + 3 load_var 3 (_3) + 4 load_const 0 (0) + 5 cmp_int_op == + 6 pop_jump_if_false +2 (to 8) + 7 jump +7 (to 14) + + 118 8 load_var 1 (members) + 9 load_const 0 (0) + 10 init_instance 0 (ai.clients.RoundRobin .members, .counter) + 11 store_var 2 (_0) + 12 load_var 2 (_0) + 13 return + + 116 14 load_const 1 ("RoundRobin needs at least one member") + 15 init_instance 1 (baml.errors.InvalidArgument .message) + 16 throw +} + +function ai.clients.RoundRobin.root.Client.id(self: ai.clients.RoundRobin) -> string { + 123 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (members) + 3 load_const 1 (0) + 4 call 3 ntypeargs=1 (baml.Array.at) + 5 store_var 3 (_5) + 6 load_var 3 (_5) + 7 narrow_bind 0 3 + 8 pop_jump_if_false +2 (to 10) + 9 jump +4 (to 13) + + 126 10 load_const 2 ("round-robin") + 11 store_var 2 (_0) + + 123 12 jump +8 (to 20) + 13 load_var 3 (_5) + 14 store_var 4 (c) + + 124 15 load_var 4 (c) + 16 load_type 0 + 17 load_const 3 ("id") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 2 (_0) + 20 load_var 2 (_0) + 21 return +} + +function ai.clients.RoundRobin.root.Client.invoke(self: ai.clients.RoundRobin, input: ai.ModelTurnInput) -> ai.ModelTurn { + 132 0 load_var 1 (self) + 1 load_field 1 (counter) + 2 store_var 6 (_5) + 3 load_var 1 (self) + 4 load_field 0 (members) + 5 container_len + 6 store_var 7 (_6) + 7 load_var2 6 7 + 8 mod_int + 9 store_var 5 (index) + + 133 10 load_var2 1 1 + 11 load_field 1 (counter) + 12 load_const 0 (1) + 13 bin_op + + 14 store_field 1 (counter) + + 134 15 load_type 1 + 16 load_var 1 (self) + 17 load_field 0 (members) + 18 load_var 5 (index) + 19 call 3 ntypeargs=1 (baml.Array.at) + 20 store_var 8 (_13) + 21 load_var 8 (_13) + 22 narrow_bind 1 8 + 23 pop_jump_if_false +2 (to 25) + 24 jump +4 (to 28) + + 137 25 load_const 2 ("RoundRobin needs at least one member") + 26 init_instance 0 (baml.errors.InvalidArgument .message) + 27 throw + + 134 28 load_var 8 (_13) + 29 store_var 9 (c) + + 135 30 load_var2 9 2 + 31 load_type 1 + 32 load_const 3 ("invoke") + 33 virtual_call nargs=2 ntypeargs=0 + 34 store_var 3 (_0) + 35 jump +6 (to 41) + + 131 36 load_var 4 (e) + 37 throw_if_panic + + 141 38 load_var 4 (e) + 39 call 834 ntypeargs=0 (ai.errors.normalize) + 40 throw + 41 load_var 3 (_0) + 42 return +} + +function ai.clients.default_retry_judgment(f: ai.errors.Failure) -> bool { + 7 0 load_var 1 (f) + 1 store_var 2 (_2) + 2 load_var 2 (_2) + 3 narrow_bind 0 2 + 4 pop_jump_if_false +2 (to 6) + 5 jump +19 (to 24) + 6 load_var 1 (f) + 7 store_var 3 (_3) + 8 load_var 3 (_3) + 9 narrow_bind 1 3 + 10 pop_jump_if_false +2 (to 12) + 11 jump +11 (to 22) + 12 load_var 1 (f) + 13 store_var 4 (_4) + 14 load_var 4 (_4) + 15 narrow_bind 2 4 + 16 pop_jump_if_false +2 (to 18) + 17 jump +3 (to 20) + + 11 18 load_const 3 (true) + + 7 19 jump +6 (to 25) + + 10 20 load_const 4 (false) + + 7 21 jump +4 (to 25) + + 9 22 load_const 4 (false) + + 7 23 jump +2 (to 25) + + 8 24 load_const 4 (false) + 25 return +} + +function ai.errors.InvalidRequest.Failure.retry_safety(self: ai.errors.InvalidRequest) -> ai.errors.RetrySafety { + 54 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.NetworkFailure.Failure.retry_safety(self: ai.errors.NetworkFailure) -> ai.errors.RetrySafety { + 42 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.ParseFailed.Failure.retry_safety(self: ai.errors.ParseFailed) -> ai.errors.RetrySafety { + 75 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.RateLimited.Failure.retry_safety(self: ai.errors.RateLimited) -> ai.errors.RetrySafety { + 31 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.Refused.Failure.retry_safety(self: ai.errors.Refused) -> ai.errors.RetrySafety { + 65 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.StepBudgetExceeded.Failure.retry_safety(self: ai.errors.StepBudgetExceeded) -> ai.errors.RetrySafety { + 88 0 load_const 0 (ai.errors.RetrySafety.Unsafe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.StreamingUnsupported.Failure.retry_safety(self: ai.errors.StreamingUnsupported) -> ai.errors.RetrySafety { + 117 0 load_const 0 (ai.errors.RetrySafety.Safe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.ToolFailedError.Failure.retry_safety(self: ai.errors.ToolFailedError) -> ai.errors.RetrySafety { + 104 0 load_const 0 (ai.errors.RetrySafety.Unsafe) + 1 alloc_variant 438 (ai.errors.RetrySafety) + 2 store_var 2 (_0) + 3 load_var 2 (_0) + 4 return +} + +function ai.errors.classify_http(provider: string, status_code: int, body: string) -> ai.errors.Failure { + 125 0 load_var 2 (status_code) + 1 load_const 0 (429) + 2 cmp_int_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +34 (to 38) + + 127 5 load_var 2 (status_code) + 6 load_const 1 (408) + 7 cmp_int_op == + 8 jump_if_false +2 (to 10) + 9 jump +5 (to 14) + 10 pop 1 + 11 load_var 2 (status_code) + 12 load_const 2 (500) + 13 cmp_int_op >= + 14 pop_jump_if_false +2 (to 16) + 15 jump +12 (to 27) + + 133 16 load_type 3 + 17 load_var 2 (status_code) + 18 call 138 ntypeargs=1 (baml.String.from) + 19 store_var 5 (_11) + + 130 20 load_var2 1 2 + + 133 21 load_const 4 ("http ") + 22 load_var 5 (_11) + 23 bin_op + + 24 load_var 3 (body) + 25 init_instance 0 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + + 127 26 jump +16 (to 42) + + 128 27 load_type 3 + 28 load_var 2 (status_code) + 29 call 138 ntypeargs=1 (baml.String.from) + 30 store_var 4 (_8) + 31 load_var 1 (provider) + 32 load_const 5 ("http ") + 33 load_var 4 (_8) + 34 bin_op + + 35 load_var 3 (body) + 36 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + + 127 37 jump +5 (to 42) + + 126 38 load_var 1 (provider) + 39 load_const 6 (null) + 40 load_var 3 (body) + 41 init_instance 2 (ai.errors.RateLimited .provider, .retry_after_ms, .raw_body) + 42 return +} + +function ai.errors.normalize(error: unknown) -> ai.errors.Failure | baml.errors.UnknownError { + 18 0 load_var 1 (error) + 1 store_var 2 (_2) + 2 load_var 2 (_2) + 3 narrow_bind 0 2 + 4 pop_jump_if_false +2 (to 6) + 5 jump +20 (to 25) + 6 load_var 1 (error) + 7 store_var 4 (_4) + 8 load_var 4 (_4) + 9 narrow_bind 1 4 + 10 pop_jump_if_false +2 (to 12) + 11 jump +10 (to 21) + + 21 12 load_type 2 + 13 load_var 1 (error) + 14 call 138 ntypeargs=1 (baml.String.from) + 15 store_var 6 (_7) + 16 load_var2 1 6 + 17 load_type 3 + 18 alloc_array 1 + 19 init_instance 0 (baml.errors.UnknownError .data, .message) + + 18 20 jump +8 (to 28) + 21 load_var 4 (_4) + 22 store_var 5 (unknown_error) + + 20 23 load_var 5 (unknown_error) + + 18 24 jump +4 (to 28) + 25 load_var 2 (_2) + 26 store_var 3 (failure) + + 19 27 load_var 3 (failure) + 28 return +} + +function ai.internal._schema_for_signature(handler: baml.AnyFunction) -> map { + 6 0 load_var 1 (handler) + 1 call 718 ntypeargs=0 (reflect.signature) + 2 store_var 3 (sig) + + 7 3 load_type 0 + 4 load_type 1 + 5 alloc_map 0 + 6 store_var 4 (props) + + 8 7 load_type 0 + 8 alloc_array 0 + 9 store_var 5 (required) + + 9 10 load_var 3 (sig) + 11 load_field 1 (args) + 12 load_type 2 + 13 load_const 3 ("iter") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 6 (_6) + 16 load_var 6 (_6) + 17 load_type 4 + 18 load_const 5 ("next") + 19 virtual_call nargs=1 ntypeargs=0 + 20 store_var 7 (_7) + 21 load_var 7 (_7) + 22 is_type 6 + 23 pop_jump_if_false +2 (to 25) + 24 jump +21 (to 45) + 25 load_var 7 (_7) + 26 store_var 8 (a) + + 10 27 load_var 8 (a) + 28 load_field 0 (name) + 29 store_var 9 (_12) + 30 load_var 8 (a) + 31 load_field 1 (type) + 32 sys_op 343 (baml.json.schema) + 33 store_var 10 (_13) + 34 load_type 0 + 35 load_type 1 + 36 load_var2 4 9 + 37 load_var 10 (_13) + 38 call 37 ntypeargs=2 (baml.Map.set) + 39 pop 1 + + 11 40 load_var2 5 8 + 41 load_field 0 (name) + 42 call 4 ntypeargs=0 (baml.Array.push) + 43 pop 1 + 44 jump -28 (to 16) + + 13 45 load_const 7 ("object") + 46 load_var2 4 5 + 47 load_const 8 (false) + 48 load_const 9 ("type") + 49 load_const 10 ("properties") + 50 load_const 11 ("required") + 51 load_const 12 ("additionalProperties") + 52 load_type 0 + 53 load_type 1 + 54 alloc_map 4 + 55 store_var 2 (_0) + 56 load_var 2 (_0) + 57 return +} + +function ai.internal.assemble_prompt(parts: string[], values: unknown[]) -> ai.Prompt { +} + +function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, params: map) -> baml.json.json { + 100 0 load_var 1 (self) + 1 load_field 2 (next_id) + 2 store_var 4 (id) + + 101 3 load_var 1 (self) + 4 copy 0 + 5 load_field 2 (next_id) + 6 load_const 0 (1) + 7 bin_op + + 8 store_field 2 (next_id) + + 102 9 load_var2 4 2 + 10 load_var 3 (params) + 11 call 904 ntypeargs=0 (ai.mcp.rpc_line) + 12 store_var 5 (_6) + 13 load_var2 1 5 + 14 call 906 ntypeargs=0 (ai.mcp.McpConnection._send) + 15 pop 1 + + 103 16 load_const 1 (true) + 17 pop_jump_if_false +2 (to 19) + 18 jump +19 (to 37) + + 146 19 load_type 2 + 20 load_var 1 (self) + 21 load_field 0 (server_name) + 22 call 138 ntypeargs=1 (baml.String.from) + 23 store_var 23 (_66) + + 147 24 load_type 2 + 25 load_var 2 (method) + 26 call 138 ntypeargs=1 (baml.String.from) + 27 store_var 24 (_70) + + 146 28 load_const 3 ("mcp/") + 29 load_var 23 (_66) + 30 bin_op + + + 147 31 load_const 4 ("no response for ") + 32 load_var 24 (_70) + 33 bin_op + + 34 load_const 5 (null) + 35 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 36 throw + + 104 37 load_var 1 (self) + 38 load_field 1 (p) + 39 load_field 0 (stdout) + 40 load_type 6 + 41 load_const 7 ("next") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 6 (next) + 44 jump +25 (to 69) + 45 load_var 7 (e) + 46 throw_if_panic + + 107 47 load_type 2 + 48 load_var 1 (self) + 49 load_field 0 (server_name) + 50 call 138 ntypeargs=1 (baml.String.from) + 51 store_var 8 (_13) + + 108 52 load_type 8 + 53 load_var 7 (e) + 54 call 138 ntypeargs=1 (baml.String.from) + 55 store_var 10 (_18) + 56 load_type 2 + 57 load_var 10 (_18) + 58 call 138 ntypeargs=1 (baml.String.from) + 59 store_var 9 (_17) + + 107 60 load_const 9 ("mcp/") + 61 load_var 8 (_13) + 62 bin_op + + + 108 63 load_const 10 ("reading from the MCP server failed: ") + 64 load_var 9 (_17) + 65 bin_op + + 66 load_const 5 (null) + 67 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 68 throw + + 113 69 load_var 6 (next) + 70 store_var 11 (_21) + 71 load_var 11 (_21) + 72 narrow_bind 0 11 + 73 pop_jump_if_false +2 (to 75) + 74 jump +19 (to 93) + + 137 75 load_type 2 + 76 load_var 1 (self) + 77 load_field 0 (server_name) + 78 call 138 ntypeargs=1 (baml.String.from) + 79 store_var 21 (_58) + + 138 80 load_type 2 + 81 load_var 2 (method) + 82 call 138 ntypeargs=1 (baml.String.from) + 83 store_var 22 (_62) + + 137 84 load_const 11 ("mcp/") + 85 load_var 21 (_58) + 86 bin_op + + + 138 87 load_const 12 ("the MCP server stream ended before answering ") + 88 load_var 22 (_62) + 89 bin_op + + 90 load_const 5 (null) + 91 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 92 throw + + 113 93 load_var 11 (_21) + 94 store_var 12 (line) + + 115 95 load_var 12 (line) + 96 call 144 ntypeargs=0 (baml.String.trim) + 97 store_var 13 (trimmed) + + 116 98 load_var 13 (trimmed) + 99 call 139 ntypeargs=0 (baml.String.length) + 100 load_const 13 (0) + 101 cmp_int_op > + 102 pop_jump_if_false -86 (to 16) + + 118 103 load_var 13 (trimmed) + 104 call 329 ntypeargs=0 (baml.json.parse) + 105 store_var 14 (msg) + 106 jump +5 (to 111) + 107 load_var 15 (e) + 108 throw_if_panic + + 119 109 load_const 5 (null) + 110 store_var 14 (msg) + + 121 111 load_type 14 + 112 load_var 14 (msg) + 113 load_const 15 (".id") + 114 load_const 0 (1) + 115 unary_op - + 116 call 342 ntypeargs=1 (baml.json.path_or) + 117 load_var 4 (id) + 118 cmp_int_op == + 119 pop_jump_if_false -103 (to 16) + + 122 120 load_type 16 + 121 load_var 14 (msg) + 122 load_const 17 (".error") + 123 load_const 5 (null) + 124 call 342 ntypeargs=1 (baml.json.path_or) + 125 store_var 16 (err) + + 123 126 load_var 16 (err) + 127 load_const 5 (null) + 128 call 635 ntypeargs=0 (baml.ops.equals_equals) + 129 unary_op ! + 130 pop_jump_if_false +2 (to 132) + 131 jump +7 (to 138) + + 131 132 load_type 16 + 133 load_var 14 (msg) + 134 load_const 18 (".result") + 135 load_const 5 (null) + 136 call 342 ntypeargs=1 (baml.json.path_or) + 137 return + + 125 138 load_type 2 + 139 load_var 1 (self) + 140 load_field 0 (server_name) + 141 call 138 ntypeargs=1 (baml.String.from) + 142 store_var 17 (_43) + + 126 143 load_type 19 + 144 load_var 16 (err) + 145 load_const 20 (".code") + 146 load_const 5 (null) + 147 call 342 ntypeargs=1 (baml.json.path_or) + 148 store_var 18 (_46) + + 127 149 load_type 2 + 150 load_var 16 (err) + 151 load_const 21 (".message") + 152 load_const 22 ("MCP error") + 153 call 342 ntypeargs=1 (baml.json.path_or) + 154 store_var 19 (_49) + + 128 155 load_var 16 (err) + 156 call 330 ntypeargs=0 (baml.json.stringify) + 157 store_var 20 (_52) + + 125 158 load_const 23 ("mcp/") + 159 load_var 17 (_43) + 160 bin_op + + 161 load_var2 18 19 + 162 load_var 20 (_52) + 163 init_instance 3 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + 164 throw +} + +function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> null { + 84 0 load_type 0 + 1 load_var 2 (line) + 2 load_const 1 ("\n") + 3 load_type 0 + 4 alloc_array 2 + 5 load_const 2 ("") + 6 call 15 ntypeargs=1 (baml.Array.join) + 7 store_var 4 (framed) + + 85 8 load_var 1 (self) + 9 load_field 1 (p) + 10 load_var 4 (framed) + 11 sys_op 250 (baml.sys.Process.write_stdin) + 12 pop 1 + 13 jump +25 (to 38) + 14 load_var 5 (e) + 15 throw_if_panic + + 88 16 load_type 0 + 17 load_var 1 (self) + 18 load_field 0 (server_name) + 19 call 138 ntypeargs=1 (baml.String.from) + 20 store_var 6 (_12) + + 89 21 load_type 3 + 22 load_var 5 (e) + 23 call 138 ntypeargs=1 (baml.String.from) + 24 store_var 8 (_17) + 25 load_type 0 + 26 load_var 8 (_17) + 27 call 138 ntypeargs=1 (baml.String.from) + 28 store_var 7 (_16) + + 88 29 load_const 4 ("mcp/") + 30 load_var 6 (_12) + 31 bin_op + + + 89 32 load_const 5 ("writing to the MCP server failed: ") + 33 load_var 7 (_16) + 34 bin_op + + 35 load_const 6 (null) + 36 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 37 throw + + 94 38 load_const 6 (null) + 39 store_var 3 (_0) + 40 load_var 3 (_0) + 41 return +} + +function ai.mcp.McpConnection.call_tool(self: ai.mcp.McpConnection, name: string, args: map) -> string { + 183 0 load_var2 2 3 + 1 load_const 0 ("name") + 2 load_const 1 ("arguments") + 3 load_type 2 + 4 load_type 3 + 5 alloc_map 2 + 6 store_var 5 (params) + + 184 7 load_var 1 (self) + 8 load_const 4 ("tools/call") + 9 load_var 5 (params) + 10 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 11 store_var 6 (result) + + 185 12 load_type 2 + 13 alloc_array 0 + 14 store_var 7 (texts) + + 186 15 load_type 5 + 16 load_var 6 (result) + 17 load_const 6 (".content") + 18 load_type 7 + 19 alloc_array 0 + 20 call 342 ntypeargs=1 (baml.json.path_or) + 21 load_type 8 + 22 load_const 9 ("iter") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 8 (_12) + 25 load_var 8 (_12) + 26 load_type 10 + 27 load_const 11 ("next") + 28 virtual_call nargs=1 ntypeargs=0 + 29 store_var 9 (_13) + 30 load_var 9 (_13) + 31 is_type 12 + 32 pop_jump_if_false +2 (to 34) + 33 jump +21 (to 54) + 34 load_var 9 (_13) + 35 store_var 10 (item) + + 187 36 load_type 2 + 37 load_var 10 (item) + 38 load_const 13 (".type") + 39 load_const 14 ("") + 40 call 342 ntypeargs=1 (baml.json.path_or) + 41 load_const 15 ("text") + 42 cmp_op == + 43 pop_jump_if_false -18 (to 25) + + 188 44 load_type 2 + 45 load_var 10 (item) + 46 load_const 16 (".text") + 47 load_const 17 ("") + 48 call 342 ntypeargs=1 (baml.json.path_or) + 49 store_var 11 (_22) + 50 load_var2 7 11 + 51 call 4 ntypeargs=0 (baml.Array.push) + 52 pop 1 + 53 jump -28 (to 25) + + 191 54 load_type 2 + 55 load_var 7 (texts) + 56 load_const 18 ("\n") + 57 call 15 ntypeargs=1 (baml.Array.join) + 58 store_var 12 (joined) + + 192 59 load_type 19 + 60 load_var 6 (result) + 61 load_const 20 (".isError") + 62 load_const 21 (false) + 63 call 342 ntypeargs=1 (baml.json.path_or) + 64 pop_jump_if_false +2 (to 66) + 65 jump +5 (to 70) + + 195 66 load_var 12 (joined) + 67 store_var 4 (_0) + 68 load_var 4 (_0) + 69 return + + 193 70 load_type 2 + 71 load_var 2 (name) + 72 call 138 ntypeargs=1 (baml.String.from) + 73 store_var 13 (_34) + 74 load_type 2 + 75 load_var 12 (joined) + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 14 (_36) + 78 load_const 22 ("mcp tool ") + 79 load_var 13 (_34) + 80 bin_op + + 81 load_const 23 (" failed: ") + 82 bin_op + + 83 load_var 14 (_36) + 84 bin_op + + 85 init_instance 0 (baml.errors.InvalidArgument .message) + 86 throw +} + +function ai.mcp.McpConnection.close(self: ai.mcp.McpConnection) -> null { + 199 0 load_var 1 (self) + 1 load_field 1 (p) + 2 sys_op 254 (baml.sys.Process.close) + 3 return +} + +function ai.mcp.McpConnection.connect(name: string, command: string, args: string[], timeout_ms: int) -> ai.mcp.McpConnection { + 0 load_var 4 (timeout_ms) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 48 4 load_const 1 (30000) + 5 store_var 4 (timeout_ms) + + 50 6 load_var2 2 3 + + 53 7 load_const 2 (null) + 8 load_const 2 (null) + 9 load_var 4 (timeout_ms) + 10 load_const 2 (null) + 11 load_const 3 (true) + 12 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) + 13 sys_op 256 (baml.sys.start_process) + 14 store_var 6 (p) + 15 jump +24 (to 39) + + 50 16 load_var 7 (e) + 17 throw_if_panic + + 63 18 load_type 4 + 19 load_var 1 (name) + 20 call 138 ntypeargs=1 (baml.String.from) + 21 store_var 8 (_11) + + 64 22 load_type 5 + 23 load_var 7 (e) + 24 call 138 ntypeargs=1 (baml.String.from) + 25 store_var 10 (_15) + 26 load_type 4 + 27 load_var 10 (_15) + 28 call 138 ntypeargs=1 (baml.String.from) + 29 store_var 9 (_14) + + 63 30 load_const 6 ("mcp/") + 31 load_var 8 (_11) + 32 bin_op + + + 64 33 load_const 7 ("the MCP server could not start: ") + 34 load_var 9 (_14) + 35 bin_op + + 36 load_const 2 (null) + 37 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 38 throw + + 69 39 load_var2 1 6 + 40 load_const 8 (1) + 41 init_instance 2 (ai.mcp.McpConnection .server_name, .p, .next_id) + 42 store_var 11 (conn) + + 70 43 load_const 9 ("2025-06-18") + + 72 44 load_type 10 + 45 load_type 10 + 46 alloc_map 0 + + 73 47 load_const 11 ("baml-mcp") + 48 load_const 12 ("0.1") + 49 load_const 13 ("name") + 50 load_const 14 ("version") + 51 load_type 4 + 52 load_type 4 + 53 alloc_map 2 + 54 load_const 15 ("protocolVersion") + 55 load_const 16 ("capabilities") + 56 load_const 17 ("clientInfo") + 57 load_type 4 + 58 load_type 18 + 59 alloc_map 3 + 60 store_var 12 (init) + + 75 61 load_var 11 (conn) + 62 load_const 19 ("initialize") + 63 load_var 12 (init) + 64 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 65 pop 1 + + 76 66 load_const 2 (null) + 67 load_const 20 ("notifications/initialized") + 68 load_const 2 (null) + 69 call 904 ntypeargs=0 (ai.mcp.rpc_line) + 70 store_var 13 (_26) + 71 load_var2 11 13 + 72 call 906 ntypeargs=0 (ai.mcp.McpConnection._send) + 73 pop 1 + + 77 74 load_var 11 (conn) + 75 store_var 5 (_0) + 76 load_var 5 (_0) + 77 return +} + +function ai.mcp.McpConnection.tools(self: ai.mcp.McpConnection) -> ai.tools.Tool[] { + 156 0 load_var 1 (self) + 1 load_const 0 ("tools/list") + 2 load_type 1 + 3 load_type 2 + 4 alloc_map 0 + 5 call 907 ntypeargs=0 (ai.mcp.McpConnection._request) + 6 store_var 3 (result) + + 157 7 load_type 3 + 8 alloc_array 0 + 9 store_var 4 (out) + + 158 10 load_type 4 + 11 load_var 3 (result) + 12 load_const 5 (".tools") + 13 load_type 6 + 14 alloc_array 0 + 15 call 342 ntypeargs=1 (baml.json.path_or) + 16 load_type 7 + 17 load_const 8 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 5 (_9) + 20 load_var 5 (_9) + 21 load_type 9 + 22 load_const 10 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 6 (_10) + 25 load_var 6 (_10) + 26 is_type 11 + 27 pop_jump_if_false +2 (to 29) + 28 jump +50 (to 78) + 29 load_var 6 (_10) + 30 store_var 7 (t) + + 159 31 load_type 1 + 32 load_var 7 (t) + 33 load_const 12 (".name") + 34 load_const 13 ("") + 35 call 342 ntypeargs=1 (baml.json.path_or) + 36 store_var 8 (tool_name) + + 161 37 load_type 6 + 38 load_var 7 (t) + 39 load_const 14 (".inputSchema") + 40 load_type 1 + 41 load_type 6 + 42 alloc_map 0 + 43 call 342 ntypeargs=1 (baml.json.path_or) + 44 store_var 11 (_19) + + 160 45 load_type 15 + 46 load_var 11 (_19) + 47 call 336 ntypeargs=1 (baml.json.from_json) + 48 store_var 9 (schema) + 49 jump +9 (to 58) + 50 load_var 10 (e) + 51 throw_if_panic + + 164 52 load_type 1 + 53 load_type 2 + 54 alloc_map 0 + 55 store_var 12 (empty) + + 165 56 load_var 12 (empty) + 57 store_var 9 (schema) + + 171 58 load_type 1 + 59 load_var 7 (t) + 60 load_const 16 (".description") + 61 load_const 17 ("") + 62 call 342 ntypeargs=1 (baml.json.path_or) + 63 store_var 14 (_28) + + 172 64 load_var 9 (schema) + 65 store_var 15 (_31) + + 173 66 load_var2 1 8 + 67 call 903 ntypeargs=0 (ai.mcp._proxy) + 68 store_var 16 (_32) + + 170 69 load_var2 8 14 + 70 load_var2 15 16 + 71 load_const 18 () + 72 call 797 ntypeargs=0 (ai.tools.raw_tool) + 73 store_var 13 (_26) + + 168 74 load_var2 4 13 + 75 call 4 ntypeargs=0 (baml.Array.push) + 76 pop 1 + 77 jump -57 (to 20) + + 177 78 load_var 4 (out) + 79 store_var 2 (_0) + 80 load_var 2 (_0) + 81 return +} + +function ai.mcp._proxy(conn: ai.mcp.McpConnection, name: string) -> (map) -> string throws unknown { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 20 6 load_var2 1 2 + 7 make_closure 2276 2 + 8 store_var 3 (_0) + 9 load_var 3 (_0) + 10 return +} + +function ai.mcp.rpc_line(id: int | null, method: string, params: map | null) -> string { + 27 0 load_const 0 ("2.0") + 1 load_var 2 (method) + 2 load_const 1 ("jsonrpc") + 3 load_const 2 ("method") + 4 load_type 3 + 5 load_type 4 + 6 alloc_map 2 + 7 store_var 4 (m) + + 28 8 load_var 1 (id) + 9 store_var 5 (_5) + 10 load_var 5 (_5) + 11 narrow_bind 5 5 + 12 pop_jump_if_false +10 (to 22) + 13 load_var 5 (_5) + 14 store_var 6 (i) + + 29 15 load_type 3 + 16 load_type 4 + 17 load_var 4 (m) + 18 load_const 6 ("id") + 19 load_var 6 (i) + 20 call 37 ntypeargs=2 (baml.Map.set) + 21 pop 1 + + 31 22 load_var 3 (params) + 23 store_var 7 (_11) + 24 load_var 7 (_11) + 25 narrow_bind 7 7 + 26 pop_jump_if_false +10 (to 36) + 27 load_var 7 (_11) + 28 store_var 8 (p) + + 32 29 load_type 3 + 30 load_type 4 + 31 load_var 4 (m) + 32 load_const 8 ("params") + 33 load_var 8 (p) + 34 call 37 ntypeargs=2 (baml.Map.set) + 35 pop 1 + + 34 36 load_type 7 + 37 load_var 4 (m) + 38 call 333 ntypeargs=1 (baml.json.to_json) + 39 call 330 ntypeargs=0 (baml.json.stringify) + 40 return +} + +function ai.prompt(body: ((string) -> baml.prompt.Role throws never, baml.prompt.Context) -> baml.TaggedString throws never) -> (baml.prompt.Context) -> ai.Prompt throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 49 3 load_var 1 (body) + 4 make_closure 1626 1 + 5 store_var 3 (render) + + 53 6 load_var 3 (render) + 7 store_var 2 (_0) + 8 load_var 2 (_0) + 9 return +} + +function ai.stream.Stream.final(self: ai.stream.Stream<#0, #1>) -> #1 { + 278 0 load_var 1 (self) + 1 load_field 3 (_finished) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +9 (to 13) + + 288 5 load_var 1 (self) + 6 load_field 2 (_text) + 7 load_var 1 (self) + 8 load_field 1 (_cache) + 9 load_type 0 + 10 load_type 1 + 11 sys_op 426 (baml.sap.__parse_final) + 12 return + + 279 13 load_var 1 (self) + 14 load_field 0 (_next_text) + 15 call_indirect + 16 store_var 2 (_4) + 17 load_var 2 (_4) + 18 load_const 2 (null) + 19 cmp_op == + 20 pop_jump_if_false +2 (to 22) + 21 jump +9 (to 30) + 22 load_var 2 (_4) + 23 store_var 3 (s) + + 284 24 load_var2 1 1 + 25 load_field 2 (_text) + 26 load_var 3 (s) + 27 bin_op + + 28 store_field 2 (_text) + + 279 29 jump -29 (to 0) + + 281 30 load_var 1 (self) + 31 load_const 3 (true) + 32 store_field 3 (_finished) + + 279 33 jump -33 (to 0) +} + +function ai.stream.Stream.next(self: ai.stream.Stream<#0, #1>) -> #0 | ai.stream.Done { + 252 0 load_const 0 (true) + 1 pop_jump_if_false +2 (to 3) + 2 jump +4 (to 6) + + 273 3 load_const 1 ("unreachable") + 4 call 260 ntypeargs=0 (baml.sys.panic) + 5 jump +43 (to 48) + + 253 6 load_var 1 (self) + 7 load_field 3 (_finished) + 8 pop_jump_if_false +2 (to 10) + 9 jump +38 (to 47) + + 256 10 load_var 1 (self) + 11 load_field 0 (_next_text) + 12 call_indirect + 13 store_var 2 (_3) + 14 load_var 2 (_3) + 15 load_const 2 (null) + 16 cmp_op == + 17 pop_jump_if_false +2 (to 19) + 18 jump +24 (to 42) + 19 load_var 2 (_3) + 20 store_var 3 (s) + + 262 21 load_var2 1 1 + 22 load_field 2 (_text) + 23 load_var 3 (s) + 24 bin_op + + 25 store_field 2 (_text) + + 263 26 load_var 1 (self) + 27 load_field 2 (_text) + 28 load_var 1 (self) + 29 load_field 1 (_cache) + 30 load_type 3 + 31 load_type 4 + 32 sys_op 427 (baml.sap.__parse_partial) + 33 store_var 4 (parsed) + + 264 34 load_var 4 (parsed) + 35 is_type 5 + 36 pop_jump_if_false +2 (to 38) + 37 jump -37 (to 0) + 38 load_var 4 (parsed) + 39 store_var 5 (p) + + 267 40 load_var 5 (p) + 41 jump +7 (to 48) + + 258 42 load_var 1 (self) + 43 load_const 0 (true) + 44 store_field 3 (_finished) + + 259 45 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 46 jump +2 (to 48) + + 254 47 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 48 return +} + +function ai.stream.TurnStream._finish(self: ai.stream.TurnStream) -> null { + 128 0 load_var 1 (self) + 1 load_const 0 (true) + 2 store_field 10 (_done) + + 129 3 load_var 1 (self) + 4 load_field 0 (_sse) + 5 store_var 2 (_3) + 6 load_var 2 (_3) + 7 narrow_bind 1 2 + 8 pop_jump_if_false +2 (to 10) + 9 jump +3 (to 12) + + 132 10 load_const 2 (null) + + 129 11 jump +5 (to 16) + 12 load_var 2 (_3) + 13 store_var 3 (sse) + + 130 14 load_var 3 (sse) + 15 sys_op 229 (baml.http.SseStream.close) + 16 return +} + +function ai.stream.TurnStream.final_turn(self: ai.stream.TurnStream) -> ai.ModelTurn { + 215 0 load_const 0 (true) + 1 pop_jump_if_false +7 (to 8) + + 216 2 load_var 1 (self) + 3 call 829 ntypeargs=0 (ai.stream.TurnStream.next) + 4 store_var 2 (_3) + 5 load_var 2 (_3) + 6 narrow_bind 1 2 + 7 pop_jump_if_false -7 (to 0) + + 223 8 load_var 1 (self) + 9 load_field 8 (_input_tokens) + 10 load_const 2 (null) + 11 call 635 ntypeargs=0 (baml.ops.equals_equals) + 12 unary_op ! + 13 jump_if_false +2 (to 15) + 14 jump +7 (to 21) + 15 pop 1 + 16 load_var 1 (self) + 17 load_field 9 (_output_tokens) + 18 load_const 2 (null) + 19 call 635 ntypeargs=0 (baml.ops.equals_equals) + 20 unary_op ! + 21 pop_jump_if_false +2 (to 23) + 22 jump +4 (to 26) + + 231 23 load_const 2 (null) + 24 store_var 3 (usage) + + 223 25 jump +28 (to 53) + + 225 26 load_var 1 (self) + 27 load_field 8 (_input_tokens) + 28 store_var 5 (_12) + 29 load_var 5 (_12) + 30 store_var 4 (_11) + 31 load_var 5 (_12) + 32 load_const 2 (null) + 33 cmp_op == + 34 pop_jump_if_false +3 (to 37) + 35 load_const 3 (0) + 36 store_var 4 (_11) + + 226 37 load_var 1 (self) + 38 load_field 9 (_output_tokens) + 39 store_var 7 (_15) + 40 load_var 7 (_15) + 41 store_var 6 (_14) + 42 load_var 7 (_15) + 43 load_const 2 (null) + 44 cmp_op == + 45 pop_jump_if_false +3 (to 48) + 46 load_const 3 (0) + 47 store_var 6 (_14) + + 224 48 load_var2 4 6 + 49 load_const 2 (null) + 50 load_const 2 (null) + 51 init_instance 0 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 52 store_var 3 (usage) + + 235 53 load_var 1 (self) + 54 load_field 7 (_stop_reason) + 55 store_var 9 (_21) + 56 load_var 9 (_21) + 57 store_var 8 (_20) + 58 load_var 9 (_21) + 59 load_const 2 (null) + 60 cmp_op == + 61 pop_jump_if_false +4 (to 65) + 62 load_const 3 (ai.content.StopReason.Complete) + 63 alloc_variant 436 (ai.content.StopReason) + 64 store_var 8 (_20) + + 234 65 load_var 1 (self) + 66 load_field 6 (_text) + 67 init_instance 1 (ai.content.Text .text) + 68 load_type 4 + 69 alloc_array 1 + 70 load_var2 8 3 + + 236 71 init_instance 2 (ai.ModelTurn .content, .stop_reason, .usage) + 72 return +} + +function ai.stream.TurnStream.from_chunks(chunks: string[]) -> ai.stream.TurnStream { + 112 0 load_const 0 (null) + 1 load_const 0 (null) + 2 load_var 1 (chunks) + 3 load_const 1 (0) + + 117 4 load_type 2 + 5 alloc_array 0 + 6 load_const 1 (0) + 7 load_const 3 ("") + 8 load_const 0 (null) + 9 load_const 0 (null) + 10 load_const 0 (null) + 11 load_const 4 (false) + 12 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done) + 13 store_var 2 (_0) + 14 load_var 2 (_0) + 15 return +} + +function ai.stream.TurnStream.from_sse(sse: baml.http.SseStream, decode: (string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] throws unknown) -> ai.stream.TurnStream { + 93 0 load_var2 1 2 + + 96 1 load_type 0 + 2 alloc_array 0 + 3 load_const 1 (0) + + 98 4 load_type 2 + 5 alloc_array 0 + 6 load_const 1 (0) + 7 load_const 3 ("") + 8 load_const 4 (null) + 9 load_const 4 (null) + 10 load_const 4 (null) + 11 load_const 5 (false) + 12 init_instance 0 (ai.stream.TurnStream ._sse, ._decode, ._chunks, ._cursor, ._pending, ._pcursor, ._text, ._stop_reason, ._input_tokens, ._output_tokens, ._done) + 13 store_var 3 (_0) + 14 load_var 3 (_0) + 15 return +} + +function ai.stream.TurnStream.next(self: ai.stream.TurnStream) -> string | ai.stream.Done { + 139 0 load_const 0 (true) + 1 pop_jump_if_false +2 (to 3) + 2 jump +4 (to 6) + + 209 3 load_const 1 ("unreachable") + 4 call 260 ntypeargs=0 (baml.sys.panic) + 5 jump +198 (to 203) + + 140 6 load_var 1 (self) + 7 load_field 10 (_done) + 8 pop_jump_if_false +2 (to 10) + 9 jump +193 (to 202) + + 144 10 load_var 1 (self) + 11 load_field 5 (_pcursor) + 12 store_var 2 (_4) + 13 load_var 1 (self) + 14 load_field 4 (_pending) + 15 container_len + 16 store_var 3 (_5) + 17 load_var2 2 3 + 18 cmp_int_op < + 19 pop_jump_if_false +2 (to 21) + 20 jump +96 (to 116) + + 172 21 load_var 1 (self) + 22 load_field 0 (_sse) + 23 store_var 18 (_33) + 24 load_var 18 (_33) + 25 narrow_bind 2 18 + 26 pop_jump_if_false +2 (to 28) + 27 jump +40 (to 67) + + 195 28 load_type 3 + 29 load_var 1 (self) + 30 load_field 2 (_chunks) + 31 load_var 1 (self) + 32 load_field 3 (_cursor) + 33 call 3 ntypeargs=1 (baml.Array.at) + 34 store_var 27 (_58) + 35 load_var 27 (_58) + 36 narrow_bind 4 27 + 37 pop_jump_if_false +2 (to 39) + 38 jump +6 (to 44) + + 202 39 load_var 1 (self) + 40 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 41 pop 1 + + 203 42 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 43 jump +160 (to 203) + + 195 44 load_var 27 (_58) + 45 store_var 28 (c) + + 197 46 load_var 1 (self) + 47 copy 0 + 48 load_field 3 (_cursor) + 49 load_const 4 (1) + 50 bin_op + + 51 store_field 3 (_cursor) + + 198 52 load_type 3 + 53 load_var 1 (self) + 54 load_field 6 (_text) + 55 call 138 ntypeargs=1 (baml.String.from) + 56 store_var 29 (_60) + 57 load_type 3 + 58 load_var 28 (c) + 59 call 138 ntypeargs=1 (baml.String.from) + 60 store_var 30 (_63) + 61 load_var2 1 29 + 62 load_var 30 (_63) + 63 bin_op + + 64 store_field 6 (_text) + + 199 65 load_var 28 (c) + 66 jump +137 (to 203) + + 172 67 load_var 18 (_33) + 68 store_var 19 (sse) + + 174 69 load_var 19 (sse) + 70 sys_op 228 (baml.http.SseStream.next) + 71 store_var 20 (_35) + 72 load_var 20 (_35) + 73 load_const 5 (null) + 74 cmp_op == + 75 pop_jump_if_false +2 (to 77) + 76 jump +35 (to 111) + 77 load_var 20 (_35) + 78 store_var 21 (batch) + + 180 79 load_var 1 (self) + 80 load_field 1 (_decode) + 81 store_var 22 (_40) + 82 load_var 22 (_40) + 83 narrow_bind 6 22 + 84 pop_jump_if_false -84 (to 0) + 85 load_var 22 (_40) + 86 store_var 23 (decode) + + 181 87 load_var2 21 23 + 88 call_indirect + 89 load_type 7 + 90 load_const 8 ("iter") + 91 virtual_call nargs=1 ntypeargs=0 + 92 store_var 24 (_45) + 93 load_var 24 (_45) + 94 load_type 9 + 95 load_const 10 ("next") + 96 virtual_call nargs=1 ntypeargs=0 + 97 store_var 25 (_46) + 98 load_var 25 (_46) + 99 is_type 11 + 100 pop_jump_if_false +2 (to 102) + 101 jump -101 (to 0) + 102 load_var 25 (_46) + 103 store_var 26 (e) + + 182 104 load_type 12 + 105 load_var 1 (self) + 106 load_field 4 (_pending) + 107 load_var 26 (e) + 108 call 4 ntypeargs=1 (baml.Array.push) + 109 pop 1 + 110 jump -17 (to 93) + + 176 111 load_var 1 (self) + 112 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 113 pop 1 + + 177 114 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 115 jump +88 (to 203) + + 145 116 load_type 12 + 117 load_var 1 (self) + 118 load_field 4 (_pending) + 119 load_var 1 (self) + 120 load_field 5 (_pcursor) + 121 call 3 ntypeargs=1 (baml.Array.at) + 122 store_var 4 (e) + + 146 123 load_var 1 (self) + 124 copy 0 + 125 load_field 5 (_pcursor) + 126 load_const 4 (1) + 127 bin_op + + 128 store_field 5 (_pcursor) + + 147 129 load_var 4 (e) + 130 store_var 5 (_11) + 131 load_var 5 (_11) + 132 narrow_bind 13 5 + 133 pop_jump_if_false +2 (to 135) + 134 jump +49 (to 183) + 135 load_var 4 (e) + 136 store_var 9 (_19) + 137 load_var 9 (_19) + 138 narrow_bind 14 9 + 139 pop_jump_if_false +2 (to 141) + 140 jump +11 (to 151) + 141 load_var 4 (e) + 142 store_var 17 (_30) + 143 load_var 17 (_30) + 144 narrow_bind 15 17 + 145 pop_jump_if_false -145 (to 0) + + 165 146 load_var 1 (self) + 147 call 828 ntypeargs=0 (ai.stream.TurnStream._finish) + 148 pop 1 + + 166 149 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 150 jump +53 (to 203) + + 147 151 load_var 9 (_19) + 152 store_var_load_var 10 (m) + + 153 153 load_field 0 (stop_reason) + 154 store_var 11 (_22) + 155 load_var 11 (_22) + 156 narrow_bind 16 11 + 157 pop_jump_if_false +5 (to 162) + 158 load_var 11 (_22) + 159 store_var 12 (s) + + 154 160 load_var2 1 12 + 161 store_field 7 (_stop_reason) + + 156 162 load_var 10 (m) + 163 load_field 1 (input_tokens) + 164 store_var 13 (_25) + 165 load_var 13 (_25) + 166 narrow_bind 17 13 + 167 pop_jump_if_false +5 (to 172) + 168 load_var 13 (_25) + 169 store_var 14 (i) + + 157 170 load_var2 1 14 + 171 store_field 8 (_input_tokens) + + 159 172 load_var 10 (m) + 173 load_field 2 (output_tokens) + 174 store_var 15 (_28) + 175 load_var 15 (_28) + 176 narrow_bind 17 15 + 177 pop_jump_if_false -177 (to 0) + 178 load_var 15 (_28) + 179 store_var 16 (o) + + 160 180 load_var2 1 16 + 181 store_field 9 (_output_tokens) + + 159 182 jump -182 (to 0) + + 147 183 load_var 5 (_11) + 184 store_var 6 (d) + + 149 185 load_type 3 + 186 load_var 1 (self) + 187 load_field 6 (_text) + 188 call 138 ntypeargs=1 (baml.String.from) + 189 store_var 7 (_13) + 190 load_type 3 + 191 load_var 6 (d) + 192 load_field 0 (text) + 193 call 138 ntypeargs=1 (baml.String.from) + 194 store_var 8 (_16) + 195 load_var2 1 7 + 196 load_var 8 (_16) + 197 bin_op + + 198 store_field 6 (_text) + + 150 199 load_var 6 (d) + 200 load_field 0 (text) + 201 jump +2 (to 203) + + 141 202 alloc_instance 359 ntypeargs=0 (ai.stream.Done) + 203 return +} + +function ai.stream.decode_sse_batch(batch: string) -> ai.stream.SseEvent[] { + 27 0 load_type 0 + 1 load_var 1 (batch) + 2 call 335 ntypeargs=1 (baml.json.from_string) + 3 return +} + +function ai.stream.from_spec(spec: ai.FunctionSpec<#1>, client: ai.stream.StreamingClient | null) -> ai.stream.Stream<#0, #1> { + 0 load_var 14 + 1 make_cell + 2 store_var 14 + 3 load_var 2 (client) + 4 load_const 0 () + 5 cmp_op == + 6 pop_jump_if_false +3 (to 9) + + 304 7 load_const 1 (null) + 8 store_var 2 (client) + + 306 9 load_type 2 + 10 load_var 1 (spec) + 11 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 12 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 13 unary_op ! + 14 pop_jump_if_false +2 (to 16) + 15 jump +79 (to 94) + + 311 16 load_var 2 (client) + 17 store_var 7 (_16) + 18 load_var 7 (_16) + 19 narrow_bind 3 7 + 20 pop_jump_if_false +2 (to 22) + 21 jump +22 (to 43) + + 314 22 load_var 1 (spec) + 23 load_field 4 (default_client) + 24 store_var 9 (_19) + 25 load_var 9 (_19) + 26 narrow_bind 3 9 + 27 pop_jump_if_false +2 (to 29) + 28 jump +10 (to 38) + + 318 29 load_var 1 (spec) + 30 load_field 4 (default_client) + 31 load_type 4 + 32 load_const 5 ("id") + 33 virtual_call nargs=1 ntypeargs=0 + 34 store_var 11 (_22) + + 317 35 load_var 11 (_22) + 36 init_instance 0 (ai.errors.StreamingUnsupported .client_id) + 37 throw + + 314 38 load_var 9 (_19) + 39 store_var 10 (s) + + 315 40 load_var 10 (s) + 41 store_var 6 (selected) + + 314 42 jump +5 (to 47) + + 311 43 load_var 7 (_16) + 44 store_var 8 (s) + + 312 45 load_var 8 (s) + 46 store_var 6 (selected) + + 325 47 load_var 6 (selected) + 48 store_var 13 (c) + + 326 49 load_var 13 (c) + 50 load_type 4 + 51 load_const 6 ("id") + 52 virtual_call nargs=1 ntypeargs=0 + 53 store_var 12 (provider) + + 330 54 load_var 1 (spec) + 55 load_field 2 (prompt_template) + 56 store_var 15 (_28) + + 331 57 load_type 2 + 58 load_var 1 (spec) + 59 call 784 ntypeargs=1 (ai.Journal.new) + 60 store_var 16 (_29) + + 332 61 load_type 2 + 62 load_var 1 (spec) + 63 call 794 ntypeargs=1 (ai.FunctionSpec.tools) + 64 store_var 17 (_31) + + 333 65 load_type 2 + 66 load_var 1 (spec) + 67 call 792 ntypeargs=1 (ai.FunctionSpec.output_type) + 68 store_var 18 (_33) + + 328 69 load_var2 6 15 + + 329 70 load_var2 16 17 + 71 load_var 18 (_33) + 72 init_instance 1 (ai.ModelTurnInput .prompt, .journal, .toolbox, .output_type) + 73 load_type 3 + 74 load_const 7 ("invoke_stream") + 75 virtual_call nargs=2 ntypeargs=0 + 76 store_deref 14 + + 346 77 load_type 8 + 78 load_type 2 + 79 call 425 ntypeargs=2 (baml.sap.__new_parse_cache) + 80 store_var 19 (_36) + + 340 81 load_type 8 + 82 load_type 2 + 83 load_var 14 (turns) + 84 make_closure 1732 captures=1 ntypeargs=2 + 85 load_var 19 (_36) + 86 load_const 9 ("") + 87 load_const 10 (false) + 88 load_type 8 + 89 load_type 2 + 90 init_instance 2 (ai.stream.Stream ._next_text, ._cache, ._text, ._finished) + 91 store_var 3 (_0) + 92 load_var 3 (_0) + 93 return + + 308 94 load_type 2 + 95 load_var 1 (spec) + 96 call 790 ntypeargs=1 (ai.FunctionSpec.name) + 97 store_var 5 (_12) + 98 load_type 11 + 99 load_var 5 (_12) + 100 call 138 ntypeargs=1 (baml.String.from) + 101 store_var 4 (_11) + 102 load_const 12 ("streaming does not run the tool loop yet: ") + 103 load_var 4 (_11) + 104 bin_op + + 105 load_const 13 (" has a non-empty toolbox") + 106 bin_op + + 107 init_instance 3 (baml.errors.InvalidArgument .message) + 108 throw +} + +function ai.tools.Tool.call(self: ai.tools.Tool, args: map) -> string { + 26 0 load_var 1 (self) + 1 load_field 4 (raw_handler) + 2 store_var 3 (_4) + 3 load_var 3 (_4) + 4 narrow_bind 0 3 + 5 pop_jump_if_false +2 (to 7) + 6 jump +65 (to 71) + + 29 7 load_var 1 (self) + 8 load_field 3 (handler) + 9 store_var 5 (_8) + 10 load_var 5 (_8) + 11 narrow_bind 1 5 + 12 pop_jump_if_false +2 (to 14) + 13 jump +13 (to 26) + + 37 14 load_type 2 + 15 load_var 1 (self) + 16 load_field 0 (name) + 17 call 138 ntypeargs=1 (baml.String.from) + 18 store_var 14 (_34) + 19 load_const 3 ("tool ") + 20 load_var 14 (_34) + 21 bin_op + + 22 load_const 4 (" has no handler") + 23 bin_op + + 24 init_instance 0 (baml.errors.InvalidArgument .message) + 25 throw + + 29 26 load_var 5 (_8) + 27 store_var 6 (h) + + 30 28 load_type 5 + 29 load_type 5 + 30 load_var2 6 2 + 31 call 719 ntypeargs=2 (reflect.call_any) + 32 store_var 7 (value) + 33 jump +33 (to 66) + 34 load_var 8 (e) + 35 store_var 9 (_15) + 36 load_var 9 (_15) + 37 narrow_bind 6 9 + 38 pop_jump_if_false +2 (to 40) + 39 jump +3 (to 42) + 40 load_var 8 (e) + 41 rethrow + 42 load_var 9 (_15) + 43 store_var 10 (bad) + + 32 44 load_type 2 + 45 load_var 1 (self) + 46 load_field 0 (name) + 47 call 138 ntypeargs=1 (baml.String.from) + 48 store_var 11 (_21) + 49 load_type 7 + 50 load_var 10 (bad) + 51 call 138 ntypeargs=1 (baml.String.from) + 52 store_var 13 (_25) + 53 load_type 2 + 54 load_var 13 (_25) + 55 call 138 ntypeargs=1 (baml.String.from) + 56 store_var 12 (_24) + 57 load_const 8 ("invalid arguments for ") + 58 load_var 11 (_21) + 59 bin_op + + 60 load_const 9 (": ") + 61 bin_op + + 62 load_var 12 (_24) + 63 bin_op + + 64 init_instance 1 (baml.errors.InvalidArgument .message) + 65 throw + + 35 66 load_type 5 + 67 load_var 7 (value) + 68 call 333 ntypeargs=1 (baml.json.to_json) + 69 call 330 ntypeargs=0 (baml.json.stringify) + 70 jump +5 (to 75) + + 26 71 load_var 3 (_4) + 72 store_var 4 (rh) + + 27 73 load_var2 2 4 + 74 call_indirect + 75 return +} + +function ai.tools.Toolbox.get(self: ai.tools.Toolbox, name: string) -> ai.tools.Tool | null { + 0 load_var 2 + 1 make_cell + 2 store_var 2 + + 112 3 load_type 0 + 4 load_type 1 + 5 load_var 1 (self) + 6 load_field 0 (entries) + 7 load_var 2 (name) + 8 make_closure 1652 1 + 9 call 19 ntypeargs=2 (baml.Array.find) + 10 return +} + +function ai.tools.Toolbox.is_empty(self: ai.tools.Toolbox) -> bool { + 118 0 load_var 1 (self) + 1 load_field 0 (entries) + 2 container_len + 3 store_var 3 (_2) + 4 load_var 3 (_2) + 5 load_const 0 (0) + 6 cmp_int_op == + 7 store_var 2 (_0) + 8 load_var 2 (_0) + 9 return +} + +function ai.tools.Toolbox.list(self: ai.tools.Toolbox) -> ai.tools.Tool[] { + 108 0 load_var 1 (self) + 1 load_field 0 (entries) + 2 return +} + +function ai.tools.Toolbox.new(tools: ai.tools.Tool[]) -> ai.tools.Toolbox { + 97 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (names) + + 98 3 load_var 1 (tools) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_3) + 8 load_var 4 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_4) + 13 load_var 5 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +24 (to 40) + 17 load_var 5 (_4) + 18 store_var 6 (t) + + 99 19 load_type 0 + 20 load_var2 3 6 + 21 load_field 0 (name) + 22 call 23 ntypeargs=1 (baml.Array.includes) + 23 pop_jump_if_false +2 (to 25) + 24 jump +6 (to 30) + + 102 25 load_var2 3 6 + 26 load_field 0 (name) + 27 call 4 ntypeargs=0 (baml.Array.push) + 28 pop 1 + 29 jump -21 (to 8) + + 100 30 load_type 0 + 31 load_var 6 (t) + 32 load_field 0 (name) + 33 call 138 ntypeargs=1 (baml.String.from) + 34 store_var 7 (_13) + 35 load_const 6 ("duplicate tool name: ") + 36 load_var 7 (_13) + 37 bin_op + + 38 init_instance 0 (baml.errors.InvalidArgument .message) + 39 throw + + 104 40 load_var 1 (tools) + 41 init_instance 1 (ai.tools.Toolbox .entries) + 42 store_var 2 (_0) + 43 load_var 2 (_0) + 44 return +} + +function ai.tools.raw_tool(name: string, description: string, input_schema: map, handler: (map) -> string throws unknown, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { + 0 load_var 5 (on_error) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 77 4 load_const 1 (null) + 5 store_var 5 (on_error) + + 79 6 load_var 1 (name) + 7 load_const 2 ("__baml_return_output") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +7 (to 17) + + 82 11 load_var2 1 2 + 12 load_var 3 (input_schema) + 13 load_const 1 (null) + 14 load_var2 4 5 + 15 init_instance 0 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) + 16 return + + 80 17 load_const 3 ("the tool name __baml_return_output is reserved") + 18 init_instance 1 (baml.errors.InvalidArgument .message) + 19 throw +} + +function ai.tools.tool(handler: baml.AnyFunction, name: string | null, description: string | null, on_error: ai.tools.ErrorMode | null) -> ai.tools.Tool { + 0 load_var 2 (name) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 45 4 load_const 1 (null) + 5 store_var 2 (name) + 6 load_var 3 (description) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 46 10 load_const 1 (null) + 11 store_var 3 (description) + 12 load_var 4 (on_error) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 47 16 load_const 1 (null) + 17 store_var 4 (on_error) + + 49 18 load_var 1 (handler) + 19 call 718 ntypeargs=0 (reflect.signature) + 20 store_var 5 (sig) + + 50 21 load_var 2 (name) + 22 store_var 6 (resolved_name) + 23 load_var 2 (name) + 24 load_const 1 (null) + 25 cmp_op == + 26 pop_jump_if_false +4 (to 30) + 27 load_var 5 (sig) + 28 load_field 0 (name) + 29 store_var 6 (resolved_name) + + 51 30 load_var 6 (resolved_name) + 31 store_var 7 (_11) + 32 load_var 7 (_11) + 33 narrow_bind 2 7 + 34 pop_jump_if_false +2 (to 36) + 35 jump +4 (to 39) + + 64 36 load_const 3 ("anonymous tool needs a name") + 37 init_instance 0 (baml.errors.InvalidArgument .message) + 38 throw + + 51 39 load_var 7 (_11) + 40 store_var_load_var 8 (n) + + 52 41 load_const 4 ("__baml_return_output") + 42 cmp_op == + 43 pop_jump_if_false +2 (to 45) + 44 jump +27 (to 71) + + 57 45 load_var 3 (description) + 46 store_var 10 (_18) + 47 load_var 3 (description) + 48 load_const 1 (null) + 49 cmp_op == + 50 pop_jump_if_false +4 (to 54) + 51 load_var 5 (sig) + 52 load_field 5 (docstring) + 53 store_var 10 (_18) + 54 load_var 10 (_18) + 55 store_var 9 (_17) + 56 load_var 10 (_18) + 57 load_const 1 (null) + 58 cmp_op == + 59 pop_jump_if_false +3 (to 62) + 60 load_const 5 ("") + 61 store_var 9 (_17) + + 58 62 load_var 1 (handler) + 63 call 844 ntypeargs=0 (ai.internal._schema_for_signature) + 64 store_var 11 (_21) + + 56 65 load_var2 8 9 + 66 load_var2 11 1 + 67 load_const 1 (null) + 68 load_var 4 (on_error) + 69 init_instance 1 (ai.tools.Tool .name, .description, .input_schema, .handler, .raw_handler, .on_error) + 70 return + + 53 71 load_const 6 ("the tool name __baml_return_output is reserved") + 72 init_instance 2 (baml.errors.InvalidArgument .message) + 73 throw +} + +function ai.wire.render_output_format(t: type) -> string { + 37 0 load_var 1 (t) + 1 sys_op 420 (baml.prompt.render_output_format) + 2 return +} + +function ai.wire.send_as(req: baml.http.Request, provider: string) -> #0 { + 8 0 load_var 1 (req) + 1 load_const 0 () + 2 call 233 ntypeargs=0 (baml.http.send) + 3 store_var 3 (resp) + 4 jump +18 (to 22) + 5 load_var 4 (e) + 6 throw_if_panic + + 12 7 load_type 1 + 8 load_var 4 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 6 (_8) + 11 load_type 2 + 12 load_var 6 (_8) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 5 (_7) + + 10 15 load_var 2 (provider) + + 12 16 load_const 3 ("transport failed before a response arrived: ") + 17 load_var 5 (_7) + 18 bin_op + + 19 load_const 4 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 17 22 load_var 3 (resp) + 23 sys_op 221 (baml.http.Response.text) + 24 store_var 7 (text) + 25 jump +8 (to 33) + 26 load_var 8 (e) + 27 throw_if_panic + + 19 28 load_var 2 (provider) + 29 load_const 5 ("the response body could not be read completely") + 30 load_const 4 (null) + 31 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 32 throw + + 26 33 load_var 3 (resp) + 34 call 223 ntypeargs=0 (baml.http.Response.ok) + 35 unary_op ! + 36 pop_jump_if_false +2 (to 38) + 37 jump +11 (to 48) + + 29 38 load_type 6 + 39 load_var 7 (text) + 40 call 335 ntypeargs=1 (baml.json.from_string) + 41 jump +6 (to 47) + 42 load_var 9 (e) + 43 throw_if_panic + + 30 44 load_var2 2 7 + 45 init_instance 2 (ai.errors.ParseFailed .provider, .raw_output) + 46 throw + 47 return + + 27 48 load_var2 2 3 + 49 load_field 0 (status_code) + 50 load_var 7 (text) + 51 call 843 ntypeargs=0 (ai.errors.classify_http) + 52 throw +} + +function anthropic.AnthropicClient.ai.Client.id(self: anthropic.AnthropicClient) -> string { + 28 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 3 (_2) + 5 load_const 1 ("anthropic/") + 6 load_var 3 (_2) + 7 bin_op + + 8 store_var 2 (_0) + 9 load_var 2 (_0) + 10 return +} + +function anthropic.AnthropicClient.ai.Client.invoke(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 32 0 load_var2 1 2 + 1 call 871 ntypeargs=0 (anthropic.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 33 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function anthropic.AnthropicClient.ai.stream.StreamingClient.invoke_stream(self: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 40 0 load_var2 1 2 + 1 call 873 ntypeargs=0 (anthropic.internal.invoke_stream) + 2 return +} + +function anthropic.AnthropicClient.new(model: string, api_key: string | null, base_url: string | null, max_tokens: int) -> anthropic.AnthropicClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 13 4 load_const 1 ("claude-haiku-4-5") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 14 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 15 16 load_const 2 (null) + 17 store_var 3 (base_url) + 18 load_var 4 (max_tokens) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 16 22 load_const 3 (4096) + 23 store_var 4 (max_tokens) + + 18 24 load_var2 1 2 + 25 load_var2 3 4 + 26 init_instance 0 (anthropic.AnthropicClient .model, .api_key, .base_url, .max_tokens) + 27 return +} + +function anthropic.internal._anthropic_assistant_blocks(content: (ai.content.Text | ai.content.Reasoning | ai.content.ToolUse)[]) -> map[] { + 74 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 75 3 load_var 1 (content) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_3) + 8 load_var 4 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_4) + 13 load_var 5 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +81 (to 97) + 17 load_var 5 (_4) + 18 store_var 6 (b) + + 76 19 load_var 6 (b) + 20 store_var 7 (_8) + 21 load_var 7 (_8) + 22 narrow_bind 6 7 + 23 pop_jump_if_false +2 (to 25) + 24 jump +48 (to 72) + 25 load_var 6 (b) + 26 store_var 10 (_20) + 27 load_var 10 (_20) + 28 narrow_bind 7 10 + 29 pop_jump_if_false +2 (to 31) + 30 jump -22 (to 8) + 31 load_var 6 (b) + 32 store_var 11 (u) + + 88 33 load_type 8 + 34 load_type 9 + 35 alloc_map 0 + 36 store_var 12 (bb) + + 89 37 load_type 8 + 38 load_type 9 + 39 load_var 12 (bb) + 40 load_const 10 ("type") + 41 load_const 11 ("tool_use") + 42 call 37 ntypeargs=2 (baml.Map.set) + 43 pop 1 + + 90 44 load_type 8 + 45 load_type 9 + 46 load_var 12 (bb) + 47 load_const 12 ("id") + 48 load_var 11 (u) + 49 load_field 0 (id) + 50 call 37 ntypeargs=2 (baml.Map.set) + 51 pop 1 + + 91 52 load_type 8 + 53 load_type 9 + 54 load_var 12 (bb) + 55 load_const 13 ("name") + 56 load_var 11 (u) + 57 load_field 1 (name) + 58 call 37 ntypeargs=2 (baml.Map.set) + 59 pop 1 + + 92 60 load_type 8 + 61 load_type 9 + 62 load_var 12 (bb) + 63 load_const 14 ("input") + 64 load_var 11 (u) + 65 load_field 2 (args) + 66 call 37 ntypeargs=2 (baml.Map.set) + 67 pop 1 + + 93 68 load_var2 3 12 + 69 call 4 ntypeargs=0 (baml.Array.push) + 70 pop 1 + 71 jump -63 (to 8) + + 76 72 load_var 7 (_8) + 73 store_var 8 (t) + + 78 74 load_type 8 + 75 load_type 9 + 76 alloc_map 0 + 77 store_var 9 (bb) + + 79 78 load_type 8 + 79 load_type 9 + 80 load_var 9 (bb) + 81 load_const 15 ("type") + 82 load_const 16 ("text") + 83 call 37 ntypeargs=2 (baml.Map.set) + 84 pop 1 + + 80 85 load_type 8 + 86 load_type 9 + 87 load_var 9 (bb) + 88 load_const 17 ("text") + 89 load_var 8 (t) + 90 load_field 0 (text) + 91 call 37 ntypeargs=2 (baml.Map.set) + 92 pop 1 + + 81 93 load_var2 3 9 + 94 call 4 ntypeargs=0 (baml.Array.push) + 95 pop 1 + 96 jump -88 (to 8) + + 98 97 load_var 3 (out) + 98 store_var 2 (_0) + 99 load_var 2 (_0) + 100 return +} + +function anthropic.internal._anthropic_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 348 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 349 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +223 (to 240) + 18 load_var 5 (_5) + 19 store_var_load_var 6 (raw) + + 350 20 load_field 1 (data) + 21 store_var 7 (_10) + 22 load_var 7 (_10) + 23 narrow_bind 6 7 + 24 pop_jump_if_false -15 (to 9) + 25 load_var 7 (_10) + 26 store_var 8 (data) + + 351 27 load_type 7 + 28 load_var 8 (data) + 29 call 335 ntypeargs=1 (baml.json.from_string) + 30 jump +4 (to 34) + 31 load_var 9 (e) + 32 throw_if_panic + + 352 33 load_const 8 (null) + + 354 34 store_var 10 (_16) + 35 load_var 10 (_16) + 36 narrow_bind 9 10 + 37 pop_jump_if_false -28 (to 9) + 38 load_var 10 (_16) + 39 store_var 11 (event) + + 355 40 load_var 11 (event) + 41 load_field 0 (type) + 42 store_var 14 (_20) + 43 load_var 14 (_20) + 44 store_var 13 (_19) + 45 load_var 14 (_20) + 46 load_const 8 (null) + 47 cmp_op == + 48 pop_jump_if_false +4 (to 52) + 49 load_var 6 (raw) + 50 load_field 0 (event) + 51 store_var 13 (_19) + 52 load_var 13 (_19) + 53 store_var 12 (t) + 54 load_var 13 (_19) + 55 load_const 8 (null) + 56 cmp_op == + 57 pop_jump_if_false +3 (to 60) + 58 load_const 10 ("") + 59 store_var 12 (t) + + 356 60 load_var 12 (t) + 61 load_const 11 ("content_block_delta") + 62 cmp_op == + 63 pop_jump_if_false +2 (to 65) + 64 jump +140 (to 204) + + 372 65 load_var 12 (t) + 66 load_const 12 ("message_start") + 67 cmp_op == + 68 pop_jump_if_false +2 (to 70) + 69 jump +74 (to 143) + + 381 70 load_var 12 (t) + 71 load_const 13 ("message_delta") + 72 cmp_op == + 73 pop_jump_if_false +2 (to 75) + 74 jump +10 (to 84) + + 394 75 load_var 12 (t) + 76 load_const 14 ("message_stop") + 77 cmp_op == + 78 pop_jump_if_false -69 (to 9) + + 395 79 load_var 3 (out) + 80 alloc_instance 358 ntypeargs=0 (ai.stream.TurnDone) + 81 call 4 ntypeargs=0 (baml.Array.push) + 82 pop 1 + 83 jump -74 (to 9) + + 382 84 load_var 11 (event) + 85 load_field 1 (delta) + 86 load_const 8 (null) + 87 cmp_op == + 88 pop_jump_if_false +2 (to 90) + 89 jump +6 (to 95) + 90 load_var 11 (event) + 91 load_field 1 (delta) + 92 load_field 2 (2) + 93 store_var 24 (_65) + 94 jump +3 (to 97) + 95 load_const 8 (null) + 96 store_var 24 (_65) + 97 load_var 24 (_65) + 98 load_const 8 (null) + 99 cmp_op == + 100 pop_jump_if_false +2 (to 102) + 101 jump +6 (to 107) + 102 load_var 24 (_65) + 103 store_var_load_var 25 (s) + + 384 104 call 870 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) + 105 store_var 23 (stop) + 106 jump +3 (to 109) + + 383 107 load_const 8 (null) + 108 store_var 23 (stop) + + 388 109 load_var 23 (stop) + 110 store_var 26 (_74) + + 389 111 load_var 11 (event) + 112 load_field 3 (usage) + 113 load_const 8 (null) + 114 cmp_op == + 115 pop_jump_if_false +2 (to 117) + 116 jump +6 (to 122) + 117 load_var 11 (event) + 118 load_field 3 (usage) + 119 load_field 0 (0) + 120 store_var 27 (_75) + 121 jump +3 (to 124) + 122 load_const 8 (null) + 123 store_var 27 (_75) + + 390 124 load_var 11 (event) + 125 load_field 3 (usage) + 126 load_const 8 (null) + 127 cmp_op == + 128 pop_jump_if_false +2 (to 130) + 129 jump +6 (to 135) + 130 load_var 11 (event) + 131 load_field 3 (usage) + 132 load_field 1 (1) + 133 store_var 28 (_79) + 134 jump +3 (to 137) + 135 load_const 8 (null) + 136 store_var 28 (_79) + + 386 137 load_var2 3 26 + + 387 138 load_var2 27 28 + 139 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 140 call 4 ntypeargs=0 (baml.Array.push) + 141 pop 1 + 142 jump -133 (to 9) + + 376 143 load_var 11 (event) + 144 load_field 2 (message) + 145 load_const 8 (null) + 146 cmp_op == + 147 pop_jump_if_false +2 (to 149) + 148 jump +20 (to 168) + 149 load_var 11 (event) + 150 load_field 2 (message) + 151 load_field 0 (0) + 152 load_const 8 (null) + 153 cmp_op == + 154 pop_jump_if_false +2 (to 156) + 155 jump +13 (to 168) + 156 load_var 11 (event) + 157 load_field 2 (message) + 158 load_const 8 (null) + 159 cmp_op == + 160 pop_jump_if_false +2 (to 162) + 161 jump +7 (to 168) + 162 load_var 11 (event) + 163 load_field 2 (message) + 164 load_field 0 (0) + 165 load_field 0 (0) + 166 store_var 21 (_42) + 167 jump +3 (to 170) + 168 load_const 8 (null) + 169 store_var 21 (_42) + + 377 170 load_var 11 (event) + 171 load_field 2 (message) + 172 load_const 8 (null) + 173 cmp_op == + 174 pop_jump_if_false +2 (to 176) + 175 jump +20 (to 195) + 176 load_var 11 (event) + 177 load_field 2 (message) + 178 load_field 0 (0) + 179 load_const 8 (null) + 180 cmp_op == + 181 pop_jump_if_false +2 (to 183) + 182 jump +13 (to 195) + 183 load_var 11 (event) + 184 load_field 2 (message) + 185 load_const 8 (null) + 186 cmp_op == + 187 pop_jump_if_false +2 (to 189) + 188 jump +7 (to 195) + 189 load_var 11 (event) + 190 load_field 2 (message) + 191 load_field 0 (0) + 192 load_field 1 (1) + 193 store_var 22 (_52) + 194 jump +3 (to 197) + 195 load_const 8 (null) + 196 store_var 22 (_52) + + 373 197 load_var 3 (out) + + 374 198 load_const 8 (null) + 199 load_var2 21 22 + 200 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 201 call 4 ntypeargs=0 (baml.Array.push) + 202 pop 1 + 203 jump -194 (to 9) + + 357 204 load_var 11 (event) + 205 load_field 1 (delta) + 206 store_var 15 (_26) + 207 load_var 15 (_26) + 208 narrow_bind 15 15 + 209 pop_jump_if_false -200 (to 9) + 210 load_var 15 (_26) + 211 store_var 16 (d) + + 358 212 load_var 16 (d) + 213 load_field 0 (type) + 214 store_var 18 (_30) + 215 load_var 18 (_30) + 216 store_var 17 (_29) + 217 load_var 18 (_30) + 218 load_const 8 (null) + 219 cmp_op == + 220 pop_jump_if_false +3 (to 223) + 221 load_const 16 ("") + 222 store_var 17 (_29) + 223 load_var 17 (_29) + 224 load_const 17 ("text_delta") + 225 cmp_op == + 226 pop_jump_if_false -217 (to 9) + + 359 227 load_var 16 (d) + 228 load_field 1 (text) + 229 store_var 19 (_33) + 230 load_var 19 (_33) + 231 narrow_bind 6 19 + 232 pop_jump_if_false -223 (to 9) + 233 load_var 19 (_33) + 234 store_var 20 (text) + + 360 235 load_var2 3 20 + 236 init_instance 2 (ai.stream.TextDelta .text) + 237 call 4 ntypeargs=0 (baml.Array.push) + 238 pop 1 + 239 jump -230 (to 9) + + 409 240 load_var 3 (out) + 241 store_var 2 (_0) + 242 load_var 2 (_0) + 243 return +} + +function anthropic.internal._anthropic_lower_journal(j: ai.Journal) -> anthropic.internal.AnthropicMessage[] { + 131 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (msgs) + + 132 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +90 (to 107) + 18 load_var 5 (_5) + 19 store_var 6 (e) + + 133 20 load_var 6 (e) + 21 store_var 7 (_10) + 22 load_var 7 (_10) + 23 narrow_bind 6 7 + 24 pop_jump_if_false +2 (to 26) + 25 jump +51 (to 76) + 26 load_var 6 (e) + 27 store_var 10 (_24) + 28 load_var 10 (_24) + 29 narrow_bind 7 10 + 30 pop_jump_if_false +2 (to 32) + 31 jump +32 (to 63) + 32 load_var 6 (e) + 33 store_var 13 (_30) + 34 load_var 13 (_30) + 35 narrow_bind 8 13 + 36 pop_jump_if_false +2 (to 38) + 37 jump +16 (to 53) + 38 load_var 6 (e) + 39 store_var 15 (_35) + 40 load_var 15 (_35) + 41 narrow_bind 9 15 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 15 (_35) + 44 store_var 16 (f) + + 154 45 load_var2 3 16 + 46 load_field 0 (id) + 47 load_var 16 (f) + 48 load_field 1 (message) + 49 load_const 10 (true) + 50 call 866 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) + 51 pop 1 + 52 jump -43 (to 9) + + 133 53 load_var 13 (_30) + 54 store_var 14 (c) + + 152 55 load_var2 3 14 + 56 load_field 0 (id) + 57 load_var 14 (c) + 58 load_field 1 (output) + 59 load_const 11 (false) + 60 call 866 ntypeargs=0 (anthropic.internal._anthropic_push_tool_result) + 61 pop 1 + 62 jump -53 (to 9) + + 133 63 load_var 10 (_24) + 64 store_var_load_var 11 (m) + + 146 65 load_field 0 (content) + 66 call 865 ntypeargs=0 (anthropic.internal._anthropic_assistant_blocks) + 67 store_var 12 (_28) + + 142 68 load_var 3 (msgs) + + 143 69 load_const 12 ("assistant") + 70 load_const 11 (false) + 71 load_var 12 (_28) + 72 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 73 call 4 ntypeargs=0 (baml.Array.push) + 74 pop 1 + 75 jump -66 (to 9) + + 133 76 load_var 7 (_10) + 77 store_var 8 (m) + + 135 78 load_type 13 + 79 load_type 14 + 80 alloc_map 0 + 81 store_var 9 (block) + + 136 82 load_type 13 + 83 load_type 14 + 84 load_var 9 (block) + 85 load_const 15 ("type") + 86 load_const 16 ("text") + 87 call 37 ntypeargs=2 (baml.Map.set) + 88 pop 1 + + 137 89 load_type 13 + 90 load_type 14 + 91 load_var 9 (block) + 92 load_const 17 ("text") + 93 load_var 8 (m) + 94 load_field 0 (content) + 95 call 37 ntypeargs=2 (baml.Map.set) + 96 pop 1 + + 138 97 load_var 3 (msgs) + 98 load_const 18 ("user") + 99 load_const 11 (false) + 100 load_var 9 (block) + 101 load_type 19 + 102 alloc_array 1 + 103 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 104 call 4 ntypeargs=0 (baml.Array.push) + 105 pop 1 + 106 jump -97 (to 9) + + 158 107 load_var 3 (msgs) + 108 store_var 2 (_0) + 109 load_var 2 (_0) + 110 return +} + +function anthropic.internal._anthropic_lower_prompt(prompt: ai.Prompt) -> anthropic.internal.AnthropicPrompt { + 51 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (system) + + 52 3 load_type 1 + 4 alloc_array 0 + 5 store_var 4 (messages) + + 53 6 load_var 1 (prompt) + 7 call 787 ntypeargs=0 (ai.Prompt.messages) + 8 load_type 2 + 9 load_const 3 ("iter") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 5 (_5) + 12 load_var 5 (_5) + 13 load_type 4 + 14 load_const 5 ("next") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 6 (_6) + 17 load_var 6 (_6) + 18 is_type 6 + 19 pop_jump_if_false +2 (to 21) + 20 jump +52 (to 72) + 21 load_var 6 (_6) + 22 store_var 7 (message) + + 54 23 load_type 7 + 24 load_type 8 + 25 alloc_map 0 + 26 store_var 8 (block) + + 55 27 load_type 7 + 28 load_type 8 + 29 load_var 8 (block) + 30 load_const 9 ("type") + 31 load_const 10 ("text") + 32 call 37 ntypeargs=2 (baml.Map.set) + 33 pop 1 + + 56 34 load_type 7 + 35 load_type 8 + 36 load_var 8 (block) + 37 load_const 11 ("text") + 38 load_var 7 (message) + 39 load_field 1 (content) + 40 call 37 ntypeargs=2 (baml.Map.set) + 41 pop 1 + + 57 42 load_var 7 (message) + 43 load_field 0 (role) + 44 load_const 12 ("system") + 45 cmp_op == + 46 pop_jump_if_false +2 (to 48) + 47 jump +21 (to 68) + + 61 48 load_var 7 (message) + 49 load_field 0 (role) + 50 load_const 13 ("assistant") + 51 cmp_op == + 52 pop_jump_if_false +2 (to 54) + 53 jump +4 (to 57) + + 64 54 load_const 14 ("user") + 55 store_var 9 (role) + + 61 56 jump +3 (to 59) + + 62 57 load_const 15 ("assistant") + 58 store_var 9 (role) + + 66 59 load_var2 4 9 + 60 load_const 16 (false) + 61 load_var 8 (block) + 62 load_type 0 + 63 alloc_array 1 + 64 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 65 call 4 ntypeargs=0 (baml.Array.push) + 66 pop 1 + 67 jump -55 (to 12) + + 58 68 load_var2 3 8 + 69 call 4 ntypeargs=0 (baml.Array.push) + 70 pop 1 + 71 jump -59 (to 12) + + 70 72 load_var2 3 4 + 73 init_instance 1 (anthropic.internal.AnthropicPrompt .system, .messages) + 74 store_var 2 (_0) + 75 load_var 2 (_0) + 76 return +} + +function anthropic.internal._anthropic_push_tool_result(msgs: anthropic.internal.AnthropicMessage[], id: string, content: string, is_error: bool) -> null { + 108 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 5 (block) + + 109 4 load_type 0 + 5 load_type 1 + 6 load_var 5 (block) + 7 load_const 2 ("type") + 8 load_const 3 ("tool_result") + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 110 11 load_type 0 + 12 load_type 1 + 13 load_var 5 (block) + 14 load_const 4 ("tool_use_id") + 15 load_var 2 (id) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 111 18 load_type 0 + 19 load_type 1 + 20 load_var 5 (block) + 21 load_const 5 ("content") + 22 load_var 3 (content) + 23 call 37 ntypeargs=2 (baml.Map.set) + 24 pop 1 + + 112 25 load_type 0 + 26 load_type 1 + 27 load_var 5 (block) + 28 load_const 6 ("is_error") + 29 load_var 4 (is_error) + 30 call 37 ntypeargs=2 (baml.Map.set) + 31 pop 1 + + 114 32 load_var 1 (msgs) + 33 container_len + 34 store_var 6 (_20) + 35 load_type 7 + 36 load_var2 1 6 + 37 load_const 8 (1) + 38 sub_int + 39 call 3 ntypeargs=1 (baml.Array.at) + 40 store_var 7 (_22) + 41 load_var 7 (_22) + 42 narrow_bind 9 7 + 43 pop_jump_if_false +2 (to 45) + 44 jump +12 (to 56) + + 123 45 load_var 1 (msgs) + 46 load_const 10 ("user") + 47 load_const 11 (true) + 48 load_var 5 (block) + 49 load_type 12 + 50 alloc_array 1 + 51 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 52 call 4 ntypeargs=0 (baml.Array.push) + 53 pop 1 + + 124 54 load_const 13 (null) + + 114 55 jump +24 (to 79) + 56 load_var 7 (_22) + 57 store_var_load_var 8 (m) + + 115 58 load_field 1 (tool_results) + 59 pop_jump_if_false +2 (to 61) + 60 jump +12 (to 72) + + 119 61 load_var 1 (msgs) + 62 load_const 14 ("user") + 63 load_const 11 (true) + 64 load_var 5 (block) + 65 load_type 12 + 66 alloc_array 1 + 67 init_instance 1 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 68 call 4 ntypeargs=0 (baml.Array.push) + 69 pop 1 + + 120 70 load_const 13 (null) + + 115 71 jump +8 (to 79) + + 116 72 load_type 12 + 73 load_var 8 (m) + 74 load_field 2 (blocks) + 75 load_var 5 (block) + 76 call 4 ntypeargs=1 (baml.Array.push) + 77 pop 1 + + 117 78 load_const 13 (null) + 79 return +} + +function anthropic.internal._anthropic_render_messages(msgs: anthropic.internal.AnthropicMessage[]) -> map[] { + 162 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 163 3 load_var 1 (msgs) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_3) + 8 load_var 4 (_3) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_4) + 13 load_var 5 (_4) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +27 (to 43) + 17 load_var 5 (_4) + 18 store_var 6 (m) + + 164 19 load_type 6 + 20 load_type 7 + 21 alloc_map 0 + 22 store_var 7 (mm) + + 165 23 load_type 6 + 24 load_type 7 + 25 load_var 7 (mm) + 26 load_const 8 ("role") + 27 load_var 6 (m) + 28 load_field 0 (role) + 29 call 37 ntypeargs=2 (baml.Map.set) + 30 pop 1 + + 166 31 load_type 6 + 32 load_type 7 + 33 load_var 7 (mm) + 34 load_const 9 ("content") + 35 load_var 6 (m) + 36 load_field 2 (blocks) + 37 call 37 ntypeargs=2 (baml.Map.set) + 38 pop 1 + + 167 39 load_var2 3 7 + 40 call 4 ntypeargs=0 (baml.Array.push) + 41 pop 1 + 42 jump -34 (to 8) + + 169 43 load_var 3 (out) + 44 store_var 2 (_0) + 45 load_var 2 (_0) + 46 return +} + +function anthropic.internal._anthropic_request(c: anthropic.AnthropicClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 182 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 5 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 5 (_5) + 7 call_indirect + + 183 8 call 864 ntypeargs=0 (anthropic.internal._anthropic_lower_prompt) + 9 store_var 6 (prompt_parts) + + 184 10 load_var 6 (prompt_parts) + 11 load_field 0 (system) + 12 store_var 7 (system) + + 185 13 load_var 6 (prompt_parts) + 14 load_field 1 (messages) + 15 store_var 8 (lowered) + + 186 16 load_var 2 (input) + 17 load_field 1 (journal) + 18 call 867 ntypeargs=0 (anthropic.internal._anthropic_lower_journal) + 19 load_type 0 + 20 load_const 1 ("iter") + 21 virtual_call nargs=1 ntypeargs=0 + 22 store_var 9 (_14) + 23 load_var 9 (_14) + 24 load_type 2 + 25 load_const 3 ("next") + 26 virtual_call nargs=1 ntypeargs=0 + 27 store_var 10 (_15) + 28 load_var 10 (_15) + 29 is_type 4 + 30 pop_jump_if_false +2 (to 32) + 31 jump +7 (to 38) + 32 load_var 10 (_15) + 33 store_var 11 (message) + + 187 34 load_var2 8 11 + 35 call 4 ntypeargs=0 (baml.Array.push) + 36 pop 1 + 37 jump -14 (to 23) + + 190 38 load_type 5 + 39 load_type 6 + 40 alloc_map 0 + 41 store_var 12 (body) + + 191 42 load_type 5 + 43 load_type 6 + 44 load_var 12 (body) + 45 load_const 7 ("model") + 46 load_var 1 (c) + 47 load_field 0 (model) + 48 call 37 ntypeargs=2 (baml.Map.set) + 49 pop 1 + + 192 50 load_type 5 + 51 load_type 6 + 52 load_var 12 (body) + 53 load_const 8 ("max_tokens") + 54 load_var 1 (c) + 55 load_field 3 (max_tokens) + 56 call 37 ntypeargs=2 (baml.Map.set) + 57 pop 1 + + 198 58 load_type 9 + 59 load_var 8 (lowered) + 60 load_const 10 (0) + 61 call 3 ntypeargs=1 (baml.Array.at) + 62 load_const 11 (null) + 63 cmp_op == + 64 pop_jump_if_false +2 (to 66) + 65 jump +8 (to 73) + 66 load_type 9 + 67 load_var 8 (lowered) + 68 load_const 10 (0) + 69 call 3 ntypeargs=1 (baml.Array.at) + 70 load_field 0 (0) + 71 store_var 14 (_31) + 72 jump +3 (to 75) + 73 load_const 11 (null) + 74 store_var 14 (_31) + 75 load_var 14 (_31) + 76 store_var 13 (first_role) + 77 load_var 14 (_31) + 78 load_const 11 (null) + 79 cmp_op == + 80 pop_jump_if_false +3 (to 83) + 81 load_const 12 ("") + 82 store_var 13 (first_role) + + 199 83 load_var 13 (first_role) + 84 load_const 13 ("user") + 85 cmp_op != + 86 jump_if_false +8 (to 94) + 87 pop 1 + 88 load_var 7 (system) + 89 container_len + 90 store_var 15 (_41) + 91 load_var 15 (_41) + 92 load_const 10 (0) + 93 cmp_int_op > + 94 pop_jump_if_false +2 (to 96) + 95 jump +26 (to 121) + + 204 96 load_var 7 (system) + 97 container_len + 98 store_var 18 (_54) + 99 load_var 18 (_54) + 100 load_const 10 (0) + 101 cmp_int_op > + 102 pop_jump_if_false +8 (to 110) + + 205 103 load_type 5 + 104 load_type 6 + 105 load_var 12 (body) + 106 load_const 14 ("system") + 107 load_var 7 (system) + 108 call 37 ntypeargs=2 (baml.Map.set) + 109 pop 1 + + 210 110 load_var 8 (lowered) + 111 call 868 ntypeargs=0 (anthropic.internal._anthropic_render_messages) + 112 store_var 19 (_60) + 113 load_type 5 + 114 load_type 6 + 115 load_var 12 (body) + 116 load_const 15 ("messages") + 117 load_var 19 (_60) + 118 call 37 ntypeargs=2 (baml.Map.set) + 119 pop 1 + 120 jump +21 (to 141) + + 200 121 load_const 16 ("user") + 122 load_const 17 (false) + 123 load_var 7 (system) + 124 init_instance 0 (anthropic.internal.AnthropicMessage .role, .tool_results, .blocks) + 125 store_var 16 (first) + + 201 126 load_type 9 + 127 load_var 16 (first) + 128 load_type 9 + 129 alloc_array 1 + 130 load_var 8 (lowered) + 131 call 7 ntypeargs=1 (baml.Array.concat) + 132 call 868 ntypeargs=0 (anthropic.internal._anthropic_render_messages) + 133 store_var 17 (_45) + 134 load_type 5 + 135 load_type 6 + 136 load_var 12 (body) + 137 load_const 18 ("messages") + 138 load_var 17 (_45) + 139 call 37 ntypeargs=2 (baml.Map.set) + 140 pop 1 + + 213 141 load_var 2 (input) + 142 load_field 2 (toolbox) + 143 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 144 unary_op ! + 145 pop_jump_if_false +79 (to 224) + + 214 146 load_type 19 + 147 alloc_array 0 + 148 store_var 20 (tools) + + 215 149 load_var 2 (input) + 150 load_field 2 (toolbox) + 151 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 152 load_type 20 + 153 load_const 21 ("iter") + 154 virtual_call nargs=1 ntypeargs=0 + 155 store_var 21 (_70) + 156 load_var 21 (_70) + 157 load_type 22 + 158 load_const 23 ("next") + 159 virtual_call nargs=1 ntypeargs=0 + 160 store_var 22 (_71) + 161 load_var 22 (_71) + 162 is_type 4 + 163 pop_jump_if_false +2 (to 165) + 164 jump +35 (to 199) + 165 load_var 22 (_71) + 166 store_var 23 (t) + + 216 167 load_type 5 + 168 load_type 6 + 169 alloc_map 0 + 170 store_var 24 (tw) + + 217 171 load_type 5 + 172 load_type 6 + 173 load_var 24 (tw) + 174 load_const 24 ("name") + 175 load_var 23 (t) + 176 load_field 0 (name) + 177 call 37 ntypeargs=2 (baml.Map.set) + 178 pop 1 + + 218 179 load_type 5 + 180 load_type 6 + 181 load_var 24 (tw) + 182 load_const 25 ("description") + 183 load_var 23 (t) + 184 load_field 1 (description) + 185 call 37 ntypeargs=2 (baml.Map.set) + 186 pop 1 + + 219 187 load_type 5 + 188 load_type 6 + 189 load_var 24 (tw) + 190 load_const 26 ("input_schema") + 191 load_var 23 (t) + 192 load_field 2 (input_schema) + 193 call 37 ntypeargs=2 (baml.Map.set) + 194 pop 1 + + 220 195 load_var2 20 24 + 196 call 4 ntypeargs=0 (baml.Array.push) + 197 pop 1 + 198 jump -42 (to 156) + + 222 199 load_type 5 + 200 load_type 6 + 201 alloc_map 0 + 202 store_var 25 (tc) + + 223 203 load_type 5 + 204 load_type 6 + 205 load_var 25 (tc) + 206 load_const 27 ("type") + 207 load_const 28 ("auto") + 208 call 37 ntypeargs=2 (baml.Map.set) + 209 pop 1 + + 224 210 load_type 5 + 211 load_type 6 + 212 load_var 12 (body) + 213 load_const 29 ("tools") + 214 load_var 20 (tools) + 215 call 37 ntypeargs=2 (baml.Map.set) + 216 pop 1 + + 225 217 load_type 5 + 218 load_type 6 + 219 load_var 12 (body) + 220 load_const 30 ("tool_choice") + 221 load_var 25 (tc) + 222 call 37 ntypeargs=2 (baml.Map.set) + 223 pop 1 + + 231 224 load_var 3 (stream) + 225 pop_jump_if_false +8 (to 233) + + 232 226 load_type 5 + 227 load_type 6 + 228 load_var 12 (body) + 229 load_const 31 ("stream") + 230 load_const 32 (true) + 231 call 37 ntypeargs=2 (baml.Map.set) + 232 pop 1 + + 238 233 load_var 1 (c) + 234 load_field 2 (base_url) + 235 store_var 27 (_106) + 236 load_var 27 (_106) + 237 store_var 26 (base) + 238 load_var 27 (_106) + 239 load_const 11 (null) + 240 cmp_op == + 241 pop_jump_if_false +3 (to 244) + 242 load_const 33 ("https://api.anthropic.com") + 243 store_var 26 (base) + + 241 244 load_type 5 + 245 load_var 26 (base) + 246 call 138 ntypeargs=1 (baml.String.from) + 247 store_var 28 (_109) + + 243 248 load_var 1 (c) + 249 load_field 1 (api_key) + 250 store_var 30 (_114) + 251 load_var2 30 30 + 252 load_const 11 (null) + 253 cmp_op == + 254 pop_jump_if_false +3 (to 257) + 255 load_const 34 ("ANTHROPIC_API_KEY") + 256 call 211 ntypeargs=0 (baml.env.get_or_panic) + + 242 257 load_const 35 ("2023-06-01") + 258 load_const 36 ("application/json") + 259 load_const 37 ("x-api-key") + 260 load_const 38 ("anthropic-version") + 261 load_const 39 ("content-type") + 262 load_type 5 + 263 load_type 5 + 264 alloc_map 3 + 265 store_var 29 (_112) + + 247 266 load_type 19 + 267 load_var 12 (body) + 268 call 333 ntypeargs=1 (baml.json.to_json) + 269 call 330 ntypeargs=0 (baml.json.stringify) + 270 store_var 31 (_116) + + 239 271 load_const 40 ("POST") + + 241 272 load_var 28 (_109) + 273 load_const 41 ("/v1/messages") + 274 bin_op + + 275 load_var2 29 31 + 276 init_instance 1 (baml.http.Request .method, .url, .headers, .body) + 277 store_var 4 (_0) + 278 load_var 4 (_0) + 279 return +} + +function anthropic.internal._anthropic_stop_reason(s: string) -> ai.content.StopReason { + 253 0 load_var 1 (s) + 1 load_const 0 ("tool_use") + 2 cmp_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +20 (to 24) + + 255 5 load_var 1 (s) + 6 load_const 1 ("max_tokens") + 7 cmp_op == + 8 pop_jump_if_false +2 (to 10) + 9 jump +12 (to 21) + + 257 10 load_var 1 (s) + 11 load_const 2 ("refusal") + 12 cmp_op == + 13 pop_jump_if_false +2 (to 15) + 14 jump +4 (to 18) + + 260 15 load_const 3 (ai.content.StopReason.Complete) + 16 alloc_variant 436 (ai.content.StopReason) + + 257 17 jump +9 (to 26) + + 258 18 load_const 4 (ai.content.StopReason.Refused) + 19 alloc_variant 436 (ai.content.StopReason) + + 257 20 jump +6 (to 26) + + 256 21 load_const 5 (ai.content.StopReason.MaxTokens) + 22 alloc_variant 436 (ai.content.StopReason) + + 255 23 jump +3 (to 26) + + 254 24 load_const 6 (ai.content.StopReason.ToolUse) + 25 alloc_variant 436 (ai.content.StopReason) + 26 return +} + +function anthropic.internal.invoke(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 266 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 869 ntypeargs=0 (anthropic.internal._anthropic_request) + 3 store_var 3 (req) + + 267 4 load_type 1 + 5 load_var 3 (req) + 6 load_const 2 ("anthropic") + 7 call 804 ntypeargs=1 (ai.wire.send_as) + 8 store_var 4 (resp) + + 269 9 load_type 3 + 10 alloc_array 0 + 11 store_var 5 (content) + + 270 12 load_var 4 (resp) + 13 load_field 0 (content) + 14 load_type 4 + 15 load_const 5 ("iter") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 6 (_9) + 18 load_var 6 (_9) + 19 load_type 6 + 20 load_const 7 ("next") + 21 virtual_call nargs=1 ntypeargs=0 + 22 store_var 7 (_10) + 23 load_var 7 (_10) + 24 is_type 8 + 25 pop_jump_if_false +2 (to 27) + 26 jump +94 (to 120) + 27 load_var 7 (_10) + 28 store_var_load_var 8 (b) + + 271 29 load_field 0 (type) + 30 load_const 9 ("text") + 31 cmp_op == + 32 pop_jump_if_false +2 (to 34) + 33 jump +71 (to 104) + + 274 34 load_var 8 (b) + 35 load_field 0 (type) + 36 load_const 10 ("thinking") + 37 cmp_op == + 38 pop_jump_if_false +2 (to 40) + 39 jump +49 (to 88) + + 277 40 load_var 8 (b) + 41 load_field 0 (type) + 42 load_const 11 ("tool_use") + 43 cmp_op == + 44 pop_jump_if_false -26 (to 18) + + 278 45 load_type 12 + 46 load_type 13 + 47 alloc_map 0 + 48 store_var 13 (empty_args) + + 281 49 load_var 8 (b) + 50 load_field 3 (id) + 51 store_var 15 (_34) + 52 load_var 15 (_34) + 53 store_var 14 (_33) + 54 load_var 15 (_34) + 55 load_const 14 (null) + 56 cmp_op == + 57 pop_jump_if_false +3 (to 60) + 58 load_const 15 ("") + 59 store_var 14 (_33) + + 282 60 load_var 8 (b) + 61 load_field 4 (name) + 62 store_var 17 (_37) + 63 load_var 17 (_37) + 64 store_var 16 (_36) + 65 load_var 17 (_37) + 66 load_const 14 (null) + 67 cmp_op == + 68 pop_jump_if_false +3 (to 71) + 69 load_const 16 ("") + 70 store_var 16 (_36) + + 283 71 load_var 8 (b) + 72 load_field 5 (input) + 73 store_var 19 (_40) + 74 load_var 19 (_40) + 75 store_var 18 (_39) + 76 load_var 19 (_40) + 77 load_const 14 (null) + 78 cmp_op == + 79 pop_jump_if_false +3 (to 82) + 80 load_var 13 (empty_args) + 81 store_var 18 (_39) + + 279 82 load_var2 5 14 + + 280 83 load_var2 16 18 + 84 init_instance 0 (ai.content.ToolUse .id, .name, .args) + 85 call 4 ntypeargs=0 (baml.Array.push) + 86 pop 1 + 87 jump -69 (to 18) + + 275 88 load_var 8 (b) + 89 load_field 2 (thinking) + 90 store_var 12 (_26) + 91 load_var 12 (_26) + 92 store_var 11 (_25) + 93 load_var 12 (_26) + 94 load_const 14 (null) + 95 cmp_op == + 96 pop_jump_if_false +3 (to 99) + 97 load_const 17 ("") + 98 store_var 11 (_25) + 99 load_var2 5 11 + 100 init_instance 1 (ai.content.Reasoning .summary) + 101 call 4 ntypeargs=0 (baml.Array.push) + 102 pop 1 + 103 jump -85 (to 18) + + 272 104 load_var 8 (b) + 105 load_field 1 (text) + 106 store_var 10 (_19) + 107 load_var 10 (_19) + 108 store_var 9 (_18) + 109 load_var 10 (_19) + 110 load_const 14 (null) + 111 cmp_op == + 112 pop_jump_if_false +3 (to 115) + 113 load_const 18 ("") + 114 store_var 9 (_18) + 115 load_var2 5 9 + 116 init_instance 2 (ai.content.Text .text) + 117 call 4 ntypeargs=0 (baml.Array.push) + 118 pop 1 + 119 jump -101 (to 18) + + 292 120 load_var 4 (resp) + 121 load_field 1 (stop_reason) + 122 store_var_load_var 21 (_43) + 123 load_const 14 (null) + 124 cmp_op == + 125 pop_jump_if_false +2 (to 127) + 126 jump +6 (to 132) + 127 load_var 21 (_43) + 128 store_var_load_var 22 (s) + + 294 129 call 870 ntypeargs=0 (anthropic.internal._anthropic_stop_reason) + 130 store_var 20 (stop) + 131 jump +4 (to 135) + + 293 132 load_const 19 (ai.content.StopReason.Complete) + 133 alloc_variant 436 (ai.content.StopReason) + 134 store_var 20 (stop) + + 297 135 load_var 4 (resp) + 136 load_field 2 (usage) + 137 store_var 24 (_49) + 138 load_var 24 (_49) + 139 narrow_bind 20 24 + 140 pop_jump_if_false +2 (to 142) + 141 jump +4 (to 145) + + 306 142 load_const 14 (null) + 143 store_var 23 (usage) + + 297 144 jump +10 (to 154) + 145 load_var 24 (_49) + 146 store_var_load_var 25 (u) + + 300 147 load_field 0 (input_tokens) + + 301 148 load_var 25 (u) + 149 load_field 1 (output_tokens) + 150 load_const 14 (null) + 151 load_const 14 (null) + 152 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 153 store_var 23 (usage) + + 309 154 load_var2 5 20 + 155 load_var 23 (usage) + 156 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 157 return +} + +function anthropic.internal.invoke_stream(c: anthropic.AnthropicClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 415 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 869 ntypeargs=0 (anthropic.internal._anthropic_request) + + 416 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 420 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 418 15 load_const 3 ("anthropic") + + 420 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 425 22 load_const 6 (anthropic.internal._anthropic_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function assert.approx_equal(actual: float, expected: float, eps: float) -> null { + 77 0 load_var 3 (eps) + 1 load_const 0 (0.0) + 2 cmp_float_op < + 3 jump_if_false +2 (to 5) + 4 jump +4 (to 8) + 5 pop 1 + 6 load_var 3 (eps) + 7 call 95 ntypeargs=0 (baml.Float.is_nan) + 8 pop_jump_if_false +2 (to 10) + 9 jump +45 (to 54) + + 80 10 load_var2 1 2 + 11 sub_float + 12 call 98 ntypeargs=0 (baml.Float.abs) + 13 store_var 4 (delta) + + 81 14 load_var 4 (delta) + 15 call 95 ntypeargs=0 (baml.Float.is_nan) + 16 jump_if_false +2 (to 18) + 17 jump +4 (to 21) + 18 pop 1 + 19 load_var2 4 3 + 20 cmp_float_op > + 21 pop_jump_if_false +2 (to 23) + 22 jump +3 (to 25) + + 93 23 load_const 1 (null) + + 81 24 jump +32 (to 56) + + 84 25 load_var 4 (delta) + 26 call 779 ntypeargs=0 (assert.format_operand) + 27 store_var 5 (_18) + + 86 28 load_var 3 (eps) + 29 call 779 ntypeargs=0 (assert.format_operand) + 30 store_var 6 (_20) + + 88 31 load_var 1 (actual) + 32 call 779 ntypeargs=0 (assert.format_operand) + 33 store_var 7 (_21) + + 90 34 load_var 2 (expected) + 35 call 779 ntypeargs=0 (assert.format_operand) + 36 store_var 8 (_22) + + 84 37 load_const 2 ("assertion failed: |left - right| = ") + 38 load_var 5 (_18) + 39 bin_op + + 40 load_const 3 (", eps = ") + 41 bin_op + + 42 load_var 6 (_20) + 43 bin_op + + 44 load_const 4 (", left = ") + 45 bin_op + + 46 load_var 7 (_21) + 47 bin_op + + 48 load_const 5 (", right = ") + 49 bin_op + + 50 load_var 8 (_22) + 51 bin_op + + 52 call 260 ntypeargs=0 (baml.sys.panic) + 53 jump +3 (to 56) + + 78 54 load_const 6 ("assertion failed: epsilon must be a non-negative number") + 55 call 260 ntypeargs=0 (baml.sys.panic) + 56 return +} + +function assert.contains(haystack: string, needle: string) -> null { + 100 0 load_var2 1 2 + 1 call 147 ntypeargs=0 (baml.String.includes) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 103 5 load_const 0 (null) + + 100 6 jump +3 (to 9) + + 101 7 load_const 1 ("assertion failed: string does not contain expected substring") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function assert.equal(actual: unknown, expected: unknown) -> null { + 50 0 load_var2 1 2 + 1 call 635 ntypeargs=0 (baml.ops.equals_equals) + 2 unary_op ! + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 58 5 load_const 0 (null) + + 50 6 jump +15 (to 21) + + 53 7 load_var 1 (actual) + 8 call 779 ntypeargs=0 (assert.format_operand) + 9 store_var 3 (_8) + + 55 10 load_var 2 (expected) + 11 call 779 ntypeargs=0 (assert.format_operand) + 12 store_var 4 (_9) + + 53 13 load_const 1 ("assertion failed: left = ") + 14 load_var 3 (_8) + 15 bin_op + + 16 load_const 2 (", right = ") + 17 bin_op + + 18 load_var 4 (_9) + 19 bin_op + + 20 call 260 ntypeargs=0 (baml.sys.panic) + 21 return +} + +function assert.format_operand(value: unknown) -> string { + 32 0 load_type 0 + 1 load_var 1 (value) + 2 call 138 ntypeargs=1 (baml.String.from) + 3 return +} + +function assert.is_true(condition: bool) -> null { + 5 0 load_var 1 (condition) + 1 unary_op ! + 2 pop_jump_if_false +2 (to 4) + 3 jump +3 (to 6) + + 8 4 load_const 0 (null) + + 5 5 jump +3 (to 8) + + 6 6 load_const 1 ("assertion failed: expected true") + 7 call 260 ntypeargs=0 (baml.sys.panic) + 8 return +} + +function assert.not_null(value: unknown | null) -> null { + 14 0 load_var 1 (value) + 1 load_const 0 (null) + 2 call 635 ntypeargs=0 (baml.ops.equals_equals) + 3 pop_jump_if_false +2 (to 5) + 4 jump +3 (to 7) + + 17 5 load_const 0 (null) + + 14 6 jump +3 (to 9) + + 15 7 load_const 1 ("assertion failed: expected non-null value") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function boundary.LocalId.capture(self: boundary.LocalId, inputs: bool | null, output: bool | null, error: bool | null) -> boundary.LocalId { +} + +function boundary.id() -> boundary.LocalId { +} + +function boundary.id.current() -> string { +} + +function claude_code.ClaudeCodeClient.ai.Client.id(self: claude_code.ClaudeCodeClient) -> string { + 40 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 1 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 3 (_2) + 5 load_const 1 ("claude-code/") + 6 load_var 3 (_2) + 7 bin_op + + 8 store_var 2 (_0) + 9 load_var 2 (_0) + 10 return +} + +function claude_code.ClaudeCodeClient.ai.Client.invoke(self: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 44 0 load_var2 1 2 + 1 call 902 ntypeargs=0 (claude_code.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 45 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function claude_code.ClaudeCodeClient.new(model: string, executable: string, cwd: string | null, timeout_ms: int, permission_mode: string, harness_tools: string[], mcp_servers: map | null) -> claude_code.ClaudeCodeClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 18 4 load_const 1 ("haiku") + 5 store_var 1 (model) + 6 load_var 2 (executable) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 19 10 load_const 2 ("claude") + 11 store_var 2 (executable) + 12 load_var 3 (cwd) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 20 16 load_const 3 (null) + 17 store_var 3 (cwd) + 18 load_var 4 (timeout_ms) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 21 22 load_const 4 (240000) + 23 store_var 4 (timeout_ms) + 24 load_var 5 (permission_mode) + 25 load_const 0 () + 26 cmp_op == + 27 pop_jump_if_false +3 (to 30) + + 22 28 load_const 5 ("default") + 29 store_var 5 (permission_mode) + 30 load_var 6 (harness_tools) + 31 load_const 0 () + 32 cmp_op == + 33 pop_jump_if_false +4 (to 37) + + 23 34 load_type 6 + 35 alloc_array 0 + 36 store_var 6 (harness_tools) + 37 load_var 7 (mcp_servers) + 38 load_const 0 () + 39 cmp_op == + 40 pop_jump_if_false +3 (to 43) + + 24 41 load_const 3 (null) + 42 store_var 7 (mcp_servers) + + 26 43 load_type 6 + 44 load_type 7 + 45 alloc_map 0 + 46 store_var 8 (servers) + + 34 47 load_var 7 (mcp_servers) + 48 store_var 9 (_16) + 49 load_var 7 (mcp_servers) + 50 load_const 3 (null) + 51 cmp_op == + 52 pop_jump_if_false +3 (to 55) + 53 load_var 8 (servers) + 54 store_var 9 (_16) + + 27 55 load_var2 2 1 + 56 load_var2 3 4 + 57 load_var2 5 6 + 58 load_var 9 (_16) + 59 init_instance 0 (claude_code.ClaudeCodeClient .executable, .model, .cwd, .timeout_ms, .permission_mode, .harness_tools, .mcp_servers) + 60 return +} + +function claude_code.internal._log_cc_event(raw: baml.json.json) -> null { + 163 0 load_type 0 + 1 load_var 1 (raw) + 2 load_const 1 (".type") + 3 load_const 2 ("?") + 4 call 342 ntypeargs=1 (baml.json.path_or) + 5 store_var 3 (kind) + + 164 6 load_var 3 (kind) + 7 load_const 3 ("system") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +178 (to 188) + + 177 11 load_var 3 (kind) + 12 load_const 4 ("assistant") + 13 cmp_op == + 14 jump_if_false +2 (to 16) + 15 jump +5 (to 20) + 16 pop 1 + 17 load_var 3 (kind) + 18 load_const 5 ("user") + 19 cmp_op == + 20 pop_jump_if_false +2 (to 22) + 21 jump +23 (to 44) + + 195 22 load_var 3 (kind) + 23 load_const 6 ("result") + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +228 (to 254) + + 198 27 load_type 0 + 28 load_var 3 (kind) + 29 call 138 ntypeargs=1 (baml.String.from) + 30 store_var 24 (_83) + 31 load_const 7 ("$baml_log") + 32 load_const 8 ("info") + 33 load_const 9 ("cc event: ") + 34 load_var 24 (_83) + 35 bin_op + + 36 load_const 10 ("level") + 37 load_const 11 ("data") + 38 load_type 0 + 39 load_type 12 + 40 alloc_map 2 + 41 send_event + 42 pop 1 + 43 jump +211 (to 254) + + 178 44 load_type 0 + 45 alloc_array 0 + 46 store_var 10 (parts) + + 179 47 load_type 13 + 48 load_var 1 (raw) + 49 load_const 14 (".message.content") + 50 load_type 15 + 51 alloc_array 0 + 52 call 342 ntypeargs=1 (baml.json.path_or) + + 180 53 load_type 16 + 54 load_const 17 ("iter") + 55 virtual_call nargs=1 ntypeargs=0 + 56 store_var 11 (_35) + 57 load_var 11 (_35) + 58 load_type 18 + 59 load_const 19 ("next") + 60 virtual_call nargs=1 ntypeargs=0 + 61 store_var 12 (_36) + 62 load_var 12 (_36) + 63 is_type 20 + 64 pop_jump_if_false +2 (to 66) + 65 jump +91 (to 156) + 66 load_var 12 (_36) + 67 store_var 13 (b) + + 181 68 load_type 0 + 69 load_var 13 (b) + 70 load_const 21 (".type") + 71 load_const 22 ("?") + 72 call 342 ntypeargs=1 (baml.json.path_or) + 73 store_var 14 (bt) + + 182 74 load_var 14 (bt) + 75 load_const 23 ("text") + 76 cmp_op == + 77 pop_jump_if_false +2 (to 79) + 78 jump +60 (to 138) + 79 load_var 14 (bt) + 80 load_const 24 ("thinking") + 81 cmp_op == + 82 pop_jump_if_false +2 (to 84) + 83 jump +37 (to 120) + 84 load_var 14 (bt) + 85 load_const 25 ("tool_use") + 86 cmp_op == + 87 pop_jump_if_false +2 (to 89) + 88 jump +15 (to 103) + 89 load_var 14 (bt) + 90 load_const 26 ("tool_result") + 91 cmp_op == + 92 pop_jump_if_false +2 (to 94) + 93 jump +5 (to 98) + + 191 94 load_var2 10 14 + 95 call 4 ntypeargs=0 (baml.Array.push) + 96 pop 1 + 97 jump -40 (to 57) + + 190 98 load_var 10 (parts) + 99 load_const 27 ("tool_result") + 100 call 4 ntypeargs=0 (baml.Array.push) + 101 pop 1 + 102 jump -45 (to 57) + + 189 103 load_type 0 + 104 load_var 13 (b) + 105 load_const 28 (".name") + 106 load_const 29 ("?") + 107 call 342 ntypeargs=1 (baml.json.path_or) + 108 store_var 20 (_63) + 109 load_type 0 + 110 load_var 20 (_63) + 111 call 138 ntypeargs=1 (baml.String.from) + 112 store_var 19 (_62) + 113 load_var 10 (parts) + 114 load_const 30 ("tool_use: ") + 115 load_var 19 (_62) + 116 bin_op + + 117 call 4 ntypeargs=0 (baml.Array.push) + 118 pop 1 + 119 jump -62 (to 57) + + 186 120 load_type 0 + 121 load_var 13 (b) + 122 load_const 31 (".thinking") + 123 load_const 32 ("") + 124 call 342 ntypeargs=1 (baml.json.path_or) + 125 call 898 ntypeargs=0 (claude_code.internal._preview) + 126 store_var 18 (_55) + 127 load_type 0 + 128 load_var 18 (_55) + 129 call 138 ntypeargs=1 (baml.String.from) + 130 store_var 17 (_54) + + 185 131 load_var 10 (parts) + + 186 132 load_const 33 ("thinking: ") + 133 load_var 17 (_54) + 134 bin_op + + 135 call 4 ntypeargs=0 (baml.Array.push) + 136 pop 1 + 137 jump -80 (to 57) + + 183 138 load_type 0 + 139 load_var 13 (b) + 140 load_const 34 (".text") + 141 load_const 35 ("") + 142 call 342 ntypeargs=1 (baml.json.path_or) + 143 call 898 ntypeargs=0 (claude_code.internal._preview) + 144 store_var 16 (_47) + 145 load_type 0 + 146 load_var 16 (_47) + 147 call 138 ntypeargs=1 (baml.String.from) + 148 store_var 15 (_46) + 149 load_var 10 (parts) + 150 load_const 36 ("text: ") + 151 load_var 15 (_46) + 152 bin_op + + 153 call 4 ntypeargs=0 (baml.Array.push) + 154 pop 1 + 155 jump -98 (to 57) + + 194 156 load_type 0 + 157 load_var 3 (kind) + 158 call 138 ntypeargs=1 (baml.String.from) + 159 store_var 21 (_73) + 160 load_type 0 + 161 load_var 10 (parts) + 162 load_const 37 (" | ") + 163 call 15 ntypeargs=1 (baml.Array.join) + 164 store_var 23 (_77) + 165 load_type 0 + 166 load_var 23 (_77) + 167 call 138 ntypeargs=1 (baml.String.from) + 168 store_var 22 (_76) + 169 load_const 38 ("$baml_log") + 170 load_const 39 ("info") + 171 load_const 40 ("cc event: ") + 172 load_var 21 (_73) + 173 bin_op + + 174 load_const 41 (" [") + 175 bin_op + + 176 load_var 22 (_76) + 177 bin_op + + 178 load_const 42 ("]") + 179 bin_op + + 180 load_const 43 ("level") + 181 load_const 44 ("data") + 182 load_type 0 + 183 load_type 12 + 184 alloc_map 2 + 185 send_event + 186 pop 1 + 187 jump +67 (to 254) + + 165 188 load_type 0 + 189 load_var 1 (raw) + 190 load_const 45 (".subtype") + 191 load_const 46 ("?") + 192 call 342 ntypeargs=1 (baml.json.path_or) + 193 store_var 4 (subtype) + + 166 194 load_var 4 (subtype) + 195 load_const 47 ("thinking_tokens") + 196 cmp_op == + 197 pop_jump_if_false +2 (to 199) + 198 jump +32 (to 230) + + 174 199 load_type 0 + 200 load_var 4 (subtype) + 201 call 138 ntypeargs=1 (baml.String.from) + 202 store_var 7 (_19) + 203 load_type 0 + 204 load_var 1 (raw) + 205 load_const 48 (".model") + 206 load_const 49 ("?") + 207 call 342 ntypeargs=1 (baml.json.path_or) + 208 store_var 9 (_23) + 209 load_type 0 + 210 load_var 9 (_23) + 211 call 138 ntypeargs=1 (baml.String.from) + 212 store_var 8 (_22) + + 173 213 load_const 50 ("$baml_log") + 214 load_const 51 ("info") + + 174 215 load_const 52 ("cc event: system/") + 216 load_var 7 (_19) + 217 bin_op + + 218 load_const 53 (" model=") + 219 bin_op + + 220 load_var 8 (_22) + 221 bin_op + + 222 load_const 54 ("level") + 223 load_const 55 ("data") + 224 load_type 0 + 225 load_type 12 + 226 alloc_map 2 + + 173 227 send_event + 228 pop 1 + 229 jump +25 (to 254) + + 170 230 load_type 56 + 231 load_var 1 (raw) + 232 load_const 57 (".estimated_tokens") + 233 load_const 58 (0) + 234 call 342 ntypeargs=1 (baml.json.path_or) + 235 store_var 6 (_13) + 236 load_type 56 + 237 load_var 6 (_13) + 238 call 138 ntypeargs=1 (baml.String.from) + 239 store_var 5 (_12) + + 169 240 load_const 59 ("$baml_log") + 241 load_const 60 ("debug") + + 170 242 load_const 61 ("cc event: thinking ~") + 243 load_var 5 (_12) + 244 bin_op + + 245 load_const 62 (" tokens") + 246 bin_op + + 247 load_const 63 ("level") + 248 load_const 64 ("data") + 249 load_type 0 + 250 load_type 12 + 251 alloc_map 2 + + 169 252 send_event + 253 pop 1 + + 200 254 load_const 65 (null) + 255 store_var 2 (_0) + 256 load_var 2 (_0) + 257 return +} + +function claude_code.internal._preview(text: string) -> string { + 154 0 load_var 1 (text) + 1 call 139 ntypeargs=0 (baml.String.length) + 2 load_const 0 (120) + 3 cmp_int_op > + 4 pop_jump_if_false +2 (to 6) + 5 jump +3 (to 8) + + 157 6 load_var 1 (text) + + 154 7 jump +11 (to 18) + + 155 8 load_var 1 (text) + 9 load_const 1 (0) + 10 load_const 0 (120) + 11 call 153 ntypeargs=0 (baml.String.substring) + 12 store_var 2 (_5) + 13 load_type 2 + 14 load_var 2 (_5) + 15 call 138 ntypeargs=1 (baml.String.from) + 16 load_const 3 ("...") + 17 bin_op + + 18 return +} + +function claude_code.internal._read_result(p: baml.sys.Process) -> baml.json.json { + 127 0 load_const 0 (null) + 1 store_var 2 (result) + + 128 2 load_var 1 (p) + 3 load_field 0 (stdout) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 3 (_4) + 8 load_var 3 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 4 (_5) + 13 load_var 4 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +35 (to 51) + 17 load_var 4 (_5) + 18 store_var 5 (line) + + 129 19 load_var 5 (line) + 20 call 144 ntypeargs=0 (baml.String.trim) + 21 store_var 6 (trimmed) + + 130 22 load_var 6 (trimmed) + 23 call 139 ntypeargs=0 (baml.String.length) + 24 load_const 6 (0) + 25 cmp_int_op > + 26 pop_jump_if_false -18 (to 8) + + 131 27 load_var 6 (trimmed) + 28 call 329 ntypeargs=0 (baml.json.parse) + 29 store_var 7 (raw) + 30 jump +7 (to 37) + 31 load_var 8 (e) + 32 throw_if_panic + + 133 33 load_const 7 ("claude-code") + 34 load_var 6 (trimmed) + 35 init_instance 0 (ai.errors.ParseFailed .provider, .raw_output) + 36 throw + + 136 37 load_var 7 (raw) + 38 call 899 ntypeargs=0 (claude_code.internal._log_cc_event) + 39 pop 1 + + 137 40 load_type 8 + 41 load_var 7 (raw) + 42 load_const 9 (".type") + 43 load_const 10 ("") + 44 call 342 ntypeargs=1 (baml.json.path_or) + 45 load_const 11 ("result") + 46 cmp_op == + 47 pop_jump_if_false -39 (to 8) + + 138 48 load_var 7 (raw) + 49 store_var 2 (result) + + 137 50 jump -42 (to 8) + + 144 51 load_var 2 (result) + 52 load_const 0 (null) + 53 call 635 ntypeargs=0 (baml.ops.equals_equals) + 54 pop_jump_if_false +2 (to 56) + 55 jump +3 (to 58) + + 150 56 load_var 2 (result) + 57 return + + 145 58 load_const 12 ("claude-code") + 59 load_const 13 ("the Claude Code CLI stream ended without a result event") + 60 init_instance 1 (ai.errors.ParseFailed .provider, .raw_output) + 61 throw +} + +function claude_code.internal._type_schema(t: string) -> map { + 89 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 3 (m) + + 90 4 load_type 0 + 5 load_type 1 + 6 load_var 3 (m) + 7 load_const 2 ("type") + 8 load_var 1 (t) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 91 11 load_var 3 (m) + 12 store_var 2 (_0) + 13 load_var 2 (_0) + 14 return +} + +function claude_code.internal.allowed_mcp_tools(c: claude_code.ClaudeCodeClient) -> string { + 219 0 load_type 0 + 1 load_type 1 + 2 load_var 1 (c) + 3 load_field 6 (mcp_servers) + 4 call 35 ntypeargs=2 (baml.Map.keys) + 5 store_var 3 (_3) + 6 load_type 0 + 7 load_type 0 + 8 load_type 2 + 9 load_var 3 (_3) + + 220 10 make_closure 2212 0 + 11 call 16 ntypeargs=3 (baml.Array.map) + 12 store_var 2 (_2) + + 219 13 load_type 0 + 14 load_var 2 (_2) + 15 load_const 3 (",") + 16 call 15 ntypeargs=1 (baml.Array.join) + 17 return +} + +function claude_code.internal.envelope_schema(output_type: type) -> map { + 52 0 load_var 1 (output_type) + 1 sys_op 343 (baml.json.schema) + 2 store_var 4 (_3) + 3 load_type 0 + 4 load_var 4 (_3) + 5 call 336 ntypeargs=1 (baml.json.from_json) + 6 store_var 3 (final_root) + + 53 7 load_type 1 + 8 load_type 2 + 9 load_var 3 (final_root) + 10 load_const 3 ("$defs") + 11 call 39 ntypeargs=2 (baml.Map.delete) + 12 store_var 5 (definitions) + + 54 13 load_type 1 + 14 load_type 2 + 15 alloc_map 0 + 16 store_var 6 (call_props) + + 55 17 load_const 4 ("string") + 18 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 19 store_var 7 (_10) + 20 load_type 1 + 21 load_type 2 + 22 load_var 6 (call_props) + 23 load_const 5 ("id") + 24 load_var 7 (_10) + 25 call 37 ntypeargs=2 (baml.Map.set) + 26 pop 1 + + 56 27 load_const 6 ("string") + 28 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 29 store_var 8 (_14) + 30 load_type 1 + 31 load_type 2 + 32 load_var 6 (call_props) + 33 load_const 7 ("name") + 34 load_var 8 (_14) + 35 call 37 ntypeargs=2 (baml.Map.set) + 36 pop 1 + + 57 37 load_const 8 ("object") + 38 call 895 ntypeargs=0 (claude_code.internal._type_schema) + 39 store_var 9 (_18) + 40 load_type 1 + 41 load_type 2 + 42 load_var 6 (call_props) + 43 load_const 9 ("args") + 44 load_var 9 (_18) + 45 call 37 ntypeargs=2 (baml.Map.set) + 46 pop 1 + + 58 47 load_type 1 + 48 load_type 2 + 49 alloc_map 0 + 50 store_var 10 (call_item) + + 59 51 load_type 1 + 52 load_type 2 + 53 load_var 10 (call_item) + 54 load_const 10 ("type") + 55 load_const 11 ("object") + 56 call 37 ntypeargs=2 (baml.Map.set) + 57 pop 1 + + 60 58 load_type 1 + 59 load_type 2 + 60 load_var 10 (call_item) + 61 load_const 12 ("properties") + 62 load_var 6 (call_props) + 63 call 37 ntypeargs=2 (baml.Map.set) + 64 pop 1 + + 61 65 load_type 1 + 66 load_type 2 + 67 load_var 10 (call_item) + 68 load_const 13 ("required") + 69 load_const 14 ("id") + 70 load_const 15 ("name") + 71 load_const 16 ("args") + 72 load_type 1 + 73 alloc_array 3 + 74 call 37 ntypeargs=2 (baml.Map.set) + 75 pop 1 + + 62 76 load_type 1 + 77 load_type 2 + 78 load_var 10 (call_item) + 79 load_const 17 ("additionalProperties") + 80 load_const 18 (false) + 81 call 37 ntypeargs=2 (baml.Map.set) + 82 pop 1 + + 63 83 load_type 1 + 84 load_type 2 + 85 alloc_map 0 + 86 store_var 11 (calls_array) + + 64 87 load_type 1 + 88 load_type 2 + 89 load_var 11 (calls_array) + 90 load_const 19 ("type") + 91 load_const 20 ("array") + 92 call 37 ntypeargs=2 (baml.Map.set) + 93 pop 1 + + 65 94 load_type 1 + 95 load_type 2 + 96 load_var 11 (calls_array) + 97 load_const 21 ("items") + 98 load_var 10 (call_item) + 99 call 37 ntypeargs=2 (baml.Map.set) + 100 pop 1 + + 66 101 load_type 1 + 102 load_type 2 + 103 alloc_map 0 + 104 store_var 12 (calls_props) + + 67 105 load_type 1 + 106 load_type 2 + 107 load_var 12 (calls_props) + 108 load_const 22 ("calls") + 109 load_var 11 (calls_array) + 110 call 37 ntypeargs=2 (baml.Map.set) + 111 pop 1 + + 68 112 load_type 1 + 113 load_type 2 + 114 alloc_map 0 + 115 store_var 13 (calls_schema) + + 69 116 load_type 1 + 117 load_type 2 + 118 load_var 13 (calls_schema) + 119 load_const 23 ("type") + 120 load_const 24 ("object") + 121 call 37 ntypeargs=2 (baml.Map.set) + 122 pop 1 + + 70 123 load_type 1 + 124 load_type 2 + 125 load_var 13 (calls_schema) + 126 load_const 25 ("properties") + 127 load_var 12 (calls_props) + 128 call 37 ntypeargs=2 (baml.Map.set) + 129 pop 1 + + 71 130 load_type 1 + 131 load_type 2 + 132 load_var 13 (calls_schema) + 133 load_const 26 ("required") + 134 load_const 27 ("calls") + 135 load_type 1 + 136 alloc_array 1 + 137 call 37 ntypeargs=2 (baml.Map.set) + 138 pop 1 + + 72 139 load_type 1 + 140 load_type 2 + 141 load_var 13 (calls_schema) + 142 load_const 28 ("additionalProperties") + 143 load_const 18 (false) + 144 call 37 ntypeargs=2 (baml.Map.set) + 145 pop 1 + + 73 146 load_type 1 + 147 load_type 2 + 148 alloc_map 0 + 149 store_var 14 (outcome) + + 74 150 load_type 0 + 151 load_var 3 (final_root) + 152 call 333 ntypeargs=1 (baml.json.to_json) + 153 store_var 15 (_67) + 154 load_type 0 + 155 load_var 13 (calls_schema) + 156 call 333 ntypeargs=1 (baml.json.to_json) + 157 store_var 16 (_70) + 158 load_type 1 + 159 load_type 2 + 160 load_var 14 (outcome) + 161 load_const 29 ("anyOf") + 162 load_var2 15 16 + 163 load_type 30 + 164 alloc_array 2 + 165 call 37 ntypeargs=2 (baml.Map.set) + 166 pop 1 + + 75 167 load_type 1 + 168 load_type 2 + 169 alloc_map 0 + 170 store_var 17 (props) + + 76 171 load_type 1 + 172 load_type 2 + 173 load_var 17 (props) + 174 load_const 31 ("outcome") + 175 load_var 14 (outcome) + 176 call 37 ntypeargs=2 (baml.Map.set) + 177 pop 1 + + 77 178 load_type 1 + 179 load_type 2 + 180 alloc_map 0 + 181 store_var 18 (envelope) + + 78 182 load_type 1 + 183 load_type 2 + 184 load_var 18 (envelope) + 185 load_const 32 ("type") + 186 load_const 33 ("object") + 187 call 37 ntypeargs=2 (baml.Map.set) + 188 pop 1 + + 79 189 load_type 1 + 190 load_type 2 + 191 load_var 18 (envelope) + 192 load_const 34 ("properties") + 193 load_var 17 (props) + 194 call 37 ntypeargs=2 (baml.Map.set) + 195 pop 1 + + 80 196 load_type 1 + 197 load_type 2 + 198 load_var 18 (envelope) + 199 load_const 35 ("required") + 200 load_const 36 ("outcome") + 201 load_type 1 + 202 alloc_array 1 + 203 call 37 ntypeargs=2 (baml.Map.set) + 204 pop 1 + + 81 205 load_type 1 + 206 load_type 2 + 207 load_var 18 (envelope) + 208 load_const 37 ("additionalProperties") + 209 load_const 18 (false) + 210 call 37 ntypeargs=2 (baml.Map.set) + 211 pop 1 + + 82 212 load_var 5 (definitions) + 213 load_const 38 (null) + 214 call 635 ntypeargs=0 (baml.ops.equals_equals) + 215 unary_op ! + 216 pop_jump_if_false +8 (to 224) + + 83 217 load_type 1 + 218 load_type 2 + 219 load_var 18 (envelope) + 220 load_const 39 ("$defs") + 221 load_var 5 (definitions) + 222 call 37 ntypeargs=2 (baml.Map.set) + 223 pop 1 + + 85 224 load_var 18 (envelope) + 225 store_var 2 (_0) + 226 load_var 2 (_0) + 227 return +} + +function claude_code.internal.invoke(c: claude_code.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 233 0 load_const 0 ("") + 1 load_var 2 (input) + 2 load_field 0 (prompt) + 3 call_indirect + 4 call 786 ntypeargs=0 (ai.Prompt.text) + 5 store_var 4 (instructions) + + 234 6 load_var 2 (input) + 7 load_field 2 (toolbox) + 8 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 9 unary_op ! + 10 store_var_load_var 5 (has_tools) + + 235 11 pop_jump_if_false +2 (to 13) + 12 jump +6 (to 18) + + 238 13 load_var 2 (input) + 14 load_field 3 (output_type) + 15 sys_op 343 (baml.json.schema) + 16 store_var 6 (schema) + 17 jump +9 (to 26) + + 236 18 load_var 2 (input) + 19 load_field 3 (output_type) + 20 call 894 ntypeargs=0 (claude_code.internal.envelope_schema) + 21 store_var 7 (_11) + 22 load_type 1 + 23 load_var 7 (_11) + 24 call 333 ntypeargs=1 (baml.json.to_json) + 25 store_var 6 (schema) + + 240 26 load_var 5 (has_tools) + 27 pop_jump_if_false +2 (to 29) + 28 jump +17 (to 45) + + 243 29 load_type 2 + 30 load_var 4 (instructions) + 31 call 138 ntypeargs=1 (baml.String.from) + 32 store_var 14 (_29) + 33 load_var 2 (input) + 34 load_field 1 (journal) + 35 call 893 ntypeargs=0 (claude_code.internal.transcript_text) + 36 store_var 16 (_33) + 37 load_type 2 + 38 load_var 16 (_33) + 39 call 138 ntypeargs=1 (baml.String.from) + 40 store_var 15 (_32) + 41 load_var2 14 15 + 42 bin_op + + 43 store_var 8 (prompt_text) + + 240 44 jump +26 (to 70) + + 241 45 load_type 2 + 46 load_var 4 (instructions) + 47 call 138 ntypeargs=1 (baml.String.from) + 48 store_var 9 (_18) + 49 load_var 2 (input) + 50 load_field 1 (journal) + 51 call 893 ntypeargs=0 (claude_code.internal.transcript_text) + 52 store_var 11 (_22) + 53 load_type 2 + 54 load_var 11 (_22) + 55 call 138 ntypeargs=1 (baml.String.from) + 56 store_var 10 (_21) + 57 load_var 2 (input) + 58 load_field 2 (toolbox) + 59 call 896 ntypeargs=0 (claude_code.internal.tool_protocol) + 60 store_var 13 (_26) + 61 load_type 2 + 62 load_var 13 (_26) + 63 call 138 ntypeargs=1 (baml.String.from) + 64 store_var 12 (_25) + 65 load_var2 9 10 + 66 bin_op + + 67 load_var 12 (_25) + 68 bin_op + + 69 store_var 8 (prompt_text) + + 247 70 load_type 2 + 71 load_var 1 (c) + 72 load_field 1 (model) + 73 call 138 ntypeargs=1 (baml.String.from) + 74 store_var 17 (_41) + 75 load_var 8 (prompt_text) + 76 call 139 ntypeargs=0 (baml.String.length) + 77 store_var 19 (_45) + 78 load_type 3 + 79 load_var 19 (_45) + 80 call 138 ntypeargs=1 (baml.String.from) + 81 store_var 18 (_44) + 82 load_var 2 (input) + 83 load_field 2 (toolbox) + 84 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 85 container_len + 86 store_var 21 (_48) + 87 load_type 3 + 88 load_var 21 (_48) + 89 call 138 ntypeargs=1 (baml.String.from) + 90 store_var 20 (_47) + + 246 91 load_const 4 ("$baml_log") + 92 load_const 5 ("info") + + 247 93 load_const 6 ("claude-code invoke: model=") + 94 load_var 17 (_41) + 95 bin_op + + 96 load_const 7 (" prompt_chars=") + 97 bin_op + + 98 load_var 18 (_44) + 99 bin_op + + 100 load_const 8 (" baml_tools=") + 101 bin_op + + 102 load_var 20 (_47) + 103 bin_op + + 104 load_const 9 ("level") + 105 load_const 10 ("data") + 106 load_type 2 + 107 load_type 11 + 108 alloc_map 2 + + 246 109 send_event + 110 pop 1 + + 249 111 load_type 2 + 112 alloc_array 0 + 113 store_var 22 (args) + + 250 114 load_var 22 (args) + 115 load_const 12 ("-p") + 116 call 4 ntypeargs=0 (baml.Array.push) + 117 pop 1 + + 251 118 load_var 22 (args) + 119 load_const 13 ("--output-format") + 120 call 4 ntypeargs=0 (baml.Array.push) + 121 pop 1 + + 252 122 load_var 22 (args) + 123 load_const 14 ("stream-json") + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + + 253 126 load_var 22 (args) + 127 load_const 15 ("--verbose") + 128 call 4 ntypeargs=0 (baml.Array.push) + 129 pop 1 + + 254 130 load_var 22 (args) + 131 load_const 16 ("--model") + 132 call 4 ntypeargs=0 (baml.Array.push) + 133 pop 1 + + 255 134 load_var2 22 1 + 135 load_field 1 (model) + 136 call 4 ntypeargs=0 (baml.Array.push) + 137 pop 1 + + 256 138 load_var 22 (args) + 139 load_const 17 ("--permission-mode") + 140 call 4 ntypeargs=0 (baml.Array.push) + 141 pop 1 + + 257 142 load_var2 22 1 + 143 load_field 4 (permission_mode) + 144 call 4 ntypeargs=0 (baml.Array.push) + 145 pop 1 + + 258 146 load_var 22 (args) + 147 load_const 18 ("--no-session-persistence") + 148 call 4 ntypeargs=0 (baml.Array.push) + 149 pop 1 + + 259 150 load_var 22 (args) + 151 load_const 19 ("--tools") + 152 call 4 ntypeargs=0 (baml.Array.push) + 153 pop 1 + + 260 154 load_type 2 + 155 load_var 1 (c) + 156 load_field 5 (harness_tools) + 157 load_const 20 (",") + 158 call 15 ntypeargs=1 (baml.Array.join) + 159 store_var 23 (_66) + 160 load_var2 22 23 + 161 call 4 ntypeargs=0 (baml.Array.push) + 162 pop 1 + + 267 163 load_var 1 (c) + 164 call 900 ntypeargs=0 (claude_code.internal.mcp_config_json) + 165 store_var 24 (_70) + 166 load_var 24 (_70) + 167 narrow_bind 21 24 + 168 pop_jump_if_false +27 (to 195) + 169 load_var 24 (_70) + 170 store_var 25 (mcp) + + 268 171 load_var 22 (args) + 172 load_const 22 ("--mcp-config") + 173 call 4 ntypeargs=0 (baml.Array.push) + 174 pop 1 + + 269 175 load_var2 22 25 + 176 call 4 ntypeargs=0 (baml.Array.push) + 177 pop 1 + + 270 178 load_var 22 (args) + 179 load_const 23 ("--strict-mcp-config") + 180 call 4 ntypeargs=0 (baml.Array.push) + 181 pop 1 + + 271 182 load_var 1 (c) + 183 call 901 ntypeargs=0 (claude_code.internal.allowed_mcp_tools) + 184 store_var 27 (_79) + 185 load_type 2 + 186 load_var 27 (_79) + 187 call 138 ntypeargs=1 (baml.String.from) + 188 store_var 26 (_78) + 189 load_var 22 (args) + 190 load_const 24 ("--allowedTools=") + 191 load_var 26 (_78) + 192 bin_op + + 193 call 4 ntypeargs=0 (baml.Array.push) + 194 pop 1 + + 273 195 load_var 22 (args) + 196 load_const 25 ("--json-schema") + 197 call 4 ntypeargs=0 (baml.Array.push) + 198 pop 1 + + 274 199 load_var 6 (schema) + 200 call 330 ntypeargs=0 (baml.json.stringify) + 201 store_var 28 (_83) + 202 load_var2 22 28 + 203 call 4 ntypeargs=0 (baml.Array.push) + 204 pop 1 + + 275 205 load_var2 22 8 + 206 call 4 ntypeargs=0 (baml.Array.push) + 207 pop 1 + + 278 208 load_var 1 (c) + 209 load_field 0 (executable) + + 279 210 load_var2 22 1 + + 280 211 load_field 2 (cwd) + 212 load_const 26 (null) + 213 load_var 1 (c) + 214 load_field 3 (timeout_ms) + 215 load_const 26 (null) + 216 load_const 26 (null) + 217 init_instance 0 (baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open) + 218 sys_op 256 (baml.sys.start_process) + 219 store_var 29 (p) + 220 jump +18 (to 238) + + 277 221 load_var 30 (e) + 222 throw_if_panic + + 285 223 load_type 27 + 224 load_var 30 (e) + 225 call 138 ntypeargs=1 (baml.String.from) + 226 store_var 32 (_97) + 227 load_type 2 + 228 load_var 32 (_97) + 229 call 138 ntypeargs=1 (baml.String.from) + 230 store_var 31 (_96) + + 283 231 load_const 28 ("claude-code") + + 285 232 load_const 29 ("the Claude Code CLI could not start: ") + 233 load_var 31 (_96) + 234 bin_op + + 235 load_const 26 (null) + 236 init_instance 1 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 237 throw + + 294 238 load_var 29 (p) + 239 sys_op 251 (baml.sys.Process.close_stdin) + 240 pop 1 + 241 jump +3 (to 244) + 242 load_var 35 (e) + 243 throw_if_panic + + 299 244 load_var 29 (p) + 245 call 897 ntypeargs=0 (claude_code.internal._read_result) + 246 store_var 36 (result) + + 300 247 load_var 29 (p) + 248 sys_op 252 (baml.sys.Process.wait) + 249 store_var 37 (exit) + 250 jump +18 (to 268) + 251 load_var 38 (e) + 252 throw_if_panic + + 304 253 load_type 30 + 254 load_var 38 (e) + 255 call 138 ntypeargs=1 (baml.String.from) + 256 store_var 40 (_111) + 257 load_type 2 + 258 load_var 40 (_111) + 259 call 138 ntypeargs=1 (baml.String.from) + 260 store_var 39 (_110) + + 302 261 load_const 31 ("claude-code") + + 304 262 load_const 32 ("the Claude Code CLI did not terminate cleanly: ") + 263 load_var 39 (_110) + 264 bin_op + + 265 load_const 26 (null) + 266 init_instance 2 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 267 throw + + 309 268 load_var 37 (exit) + 269 call 245 ntypeargs=0 (baml.sys.ProcessExit.ok) + 270 unary_op ! + 271 pop_jump_if_false +2 (to 273) + 272 jump +254 (to 526) + + 318 273 load_type 33 + 274 load_var 36 (result) + 275 load_const 34 (".is_error") + 276 load_const 35 (false) + 277 call 342 ntypeargs=1 (baml.json.path_or) + 278 pop_jump_if_false +2 (to 280) + 279 jump +234 (to 513) + + 326 280 load_type 2 + 281 load_var 36 (result) + 282 load_const 36 (".subtype") + 283 load_const 37 ("?") + 284 call 342 ntypeargs=1 (baml.json.path_or) + 285 store_var 45 (_136) + 286 load_type 2 + 287 load_var 45 (_136) + 288 call 138 ntypeargs=1 (baml.String.from) + 289 store_var 44 (_135) + 290 load_type 38 + 291 load_var 36 (result) + 292 load_const 39 (".total_cost_usd") + 293 load_const 40 (0.0) + 294 call 342 ntypeargs=1 (baml.json.path_or) + 295 store_var 47 (_141) + 296 load_type 38 + 297 load_var 47 (_141) + 298 call 138 ntypeargs=1 (baml.String.from) + 299 store_var 46 (_140) + 300 load_type 2 + 301 load_var 36 (result) + 302 load_const 41 (".session_id") + 303 load_const 42 ("?") + 304 call 342 ntypeargs=1 (baml.json.path_or) + 305 store_var 49 (_146) + 306 load_type 2 + 307 load_var 49 (_146) + 308 call 138 ntypeargs=1 (baml.String.from) + 309 store_var 48 (_145) + + 325 310 load_const 43 ("$baml_log") + 311 load_const 44 ("info") + + 326 312 load_const 45 ("claude-code result: subtype=") + 313 load_var 44 (_135) + 314 bin_op + + 315 load_const 46 (" cost_usd=") + 316 bin_op + + 317 load_var 46 (_140) + 318 bin_op + + 319 load_const 47 (" session=") + 320 bin_op + + 321 load_var 48 (_145) + 322 bin_op + + 323 load_const 48 ("level") + 324 load_const 49 ("data") + 325 load_type 2 + 326 load_type 11 + 327 alloc_map 2 + + 325 328 send_event + 329 pop 1 + + 328 330 load_type 50 + 331 load_var 36 (result) + 332 load_const 51 (".structured_output") + 333 call 341 ntypeargs=1 (baml.json.path) + 334 store_var 50 (structured) + 335 jump +20 (to 355) + 336 load_var 51 (e) + 337 throw_if_panic + + 330 338 load_type 2 + 339 load_var 36 (result) + 340 load_const 52 (".result") + 341 load_const 53 ("") + 342 call 342 ntypeargs=1 (baml.json.path_or) + 343 call 329 ntypeargs=0 (baml.json.parse) + 344 store_var 50 (structured) + 345 jump +10 (to 355) + 346 load_var 52 (inner) + 347 throw_if_panic + + 334 348 load_var 36 (result) + 349 call 330 ntypeargs=0 (baml.json.stringify) + 350 store_var 53 (_159) + + 332 351 load_const 54 ("claude-code") + 352 load_var 53 (_159) + 353 init_instance 3 (ai.errors.ParseFailed .provider, .raw_output) + 354 throw + + 342 355 load_type 3 + 356 load_var 36 (result) + 357 load_const 55 (".usage.input_tokens") + 358 load_const 56 (0) + 359 call 342 ntypeargs=1 (baml.json.path_or) + 360 store_var 55 (_162) + + 343 361 load_type 3 + 362 load_var 36 (result) + 363 load_const 57 (".usage.output_tokens") + 364 load_const 56 (0) + 365 call 342 ntypeargs=1 (baml.json.path_or) + 366 store_var 56 (_165) + + 344 367 load_type 58 + 368 load_var 36 (result) + 369 load_const 59 (".usage.cache_read_input_tokens") + 370 load_const 26 (null) + 371 call 342 ntypeargs=1 (baml.json.path_or) + 372 store_var 57 (_168) + + 341 373 load_var2 55 56 + 374 load_var 57 (_168) + 375 load_const 26 (null) + 376 init_instance 4 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 377 store_var 54 (usage) + + 348 378 load_type 60 + 379 alloc_array 0 + 380 store_var 58 (content) + + 349 381 load_const 56 (ai.content.StopReason.Complete) + 382 alloc_variant 436 (ai.content.StopReason) + 383 store_var 59 (stop) + + 350 384 load_var 5 (has_tools) + 385 pop_jump_if_false +2 (to 387) + 386 jump +9 (to 395) + + 378 387 load_var 50 (structured) + 388 call 330 ntypeargs=0 (baml.json.stringify) + 389 store_var 77 (_227) + 390 load_var2 58 77 + 391 init_instance 5 (ai.content.Text .text) + 392 call 4 ntypeargs=0 (baml.Array.push) + 393 pop 1 + 394 jump +110 (to 504) + + 351 395 load_type 50 + 396 load_var 36 (result) + 397 load_const 61 (".structured_output.outcome") + 398 load_var 50 (structured) + 399 call 342 ntypeargs=1 (baml.json.path_or) + 400 store_var 60 (outcome) + + 352 401 load_type 62 + 402 load_var 60 (outcome) + 403 load_const 63 (".calls") + 404 load_const 26 (null) + 405 call 342 ntypeargs=1 (baml.json.path_or) + + 353 406 store_var 61 (_181) + 407 load_var 61 (_181) + 408 narrow_bind 64 61 + 409 pop_jump_if_false +2 (to 411) + 410 jump +9 (to 419) + + 375 411 load_var 60 (outcome) + 412 call 330 ntypeargs=0 (baml.json.stringify) + 413 store_var 76 (_223) + 414 load_var2 58 76 + 415 init_instance 6 (ai.content.Text .text) + 416 call 4 ntypeargs=0 (baml.Array.push) + 417 pop 1 + 418 jump +86 (to 504) + + 353 419 load_var 61 (_181) + 420 store_var 62 (call_list) + + 354 421 load_const 56 (0) + 422 store_var 63 (i) + + 355 423 load_var 62 (call_list) + 424 load_type 65 + 425 load_const 66 ("iter") + 426 virtual_call nargs=1 ntypeargs=0 + 427 store_var 64 (_185) + 428 load_var 64 (_185) + 429 load_type 67 + 430 load_const 68 ("next") + 431 virtual_call nargs=1 ntypeargs=0 + 432 store_var 65 (_186) + 433 load_var 65 (_186) + 434 is_type 69 + 435 pop_jump_if_false +2 (to 437) + 436 jump +65 (to 501) + 437 load_var 65 (_186) + 438 store_var 66 (raw_call) + + 359 439 load_var 2 (input) + 440 load_field 1 (journal) + 441 call 783 ntypeargs=0 (ai.Journal.entries) + 442 container_len + 443 store_var 69 (_196) + 444 load_type 3 + 445 load_var 69 (_196) + 446 call 138 ntypeargs=1 (baml.String.from) + 447 store_var 68 (_195) + 448 load_type 3 + 449 load_var 63 (i) + 450 call 138 ntypeargs=1 (baml.String.from) + 451 store_var 70 (_200) + + 356 452 load_type 2 + + 357 453 load_var 66 (raw_call) + 454 load_const 70 (".id") + + 359 455 load_const 71 ("cc_call_") + 456 load_var 68 (_195) + 457 bin_op + + 458 load_const 72 ("_") + 459 bin_op + + 460 load_var 70 (_200) + 461 bin_op + + 462 call 342 ntypeargs=1 (baml.json.path_or) + 463 store_var 67 (id) + + 361 464 load_type 2 + 465 load_var 66 (raw_call) + 466 load_const 73 (".name") + 467 load_const 74 ("") + 468 call 342 ntypeargs=1 (baml.json.path_or) + 469 store_var 71 (name) + + 363 470 load_type 50 + 471 load_var 66 (raw_call) + 472 load_const 75 (".args") + 473 load_type 2 + 474 load_type 50 + 475 alloc_map 0 + 476 call 342 ntypeargs=1 (baml.json.path_or) + 477 store_var 74 (_209) + + 362 478 load_type 1 + 479 load_var 74 (_209) + 480 call 336 ntypeargs=1 (baml.json.from_json) + 481 store_var 72 (call_args) + 482 jump +9 (to 491) + 483 load_var 73 (e) + 484 throw_if_panic + + 366 485 load_type 2 + 486 load_type 11 + 487 alloc_map 0 + 488 store_var 75 (empty) + + 367 489 load_var 75 (empty) + 490 store_var 72 (call_args) + + 370 491 load_var2 58 67 + 492 load_var2 71 72 + 493 init_instance 7 (ai.content.ToolUse .id, .name, .args) + 494 call 4 ntypeargs=0 (baml.Array.push) + 495 pop 1 + + 371 496 load_var 63 (i) + 497 load_const 21 (1) + 498 add_int + 499 store_var 63 (i) + + 355 500 jump -72 (to 428) + + 373 501 load_const 21 (ai.content.StopReason.ToolUse) + 502 alloc_variant 436 (ai.content.StopReason) + 503 store_var 59 (stop) + + 380 504 load_var2 58 59 + 505 load_var 54 (usage) + 506 init_instance 8 (ai.ModelTurn .content, .stop_reason, .usage) + 507 store_var 3 (_0) + + 291 508 load_var 29 (p) + 509 sys_op 254 (baml.sys.Process.close) + 510 pop 1 + 511 load_var 3 (_0) + 512 return + + 321 513 load_type 2 + 514 load_var 36 (result) + 515 load_const 76 (".subtype") + 516 load_const 77 ("error") + 517 call 342 ntypeargs=1 (baml.json.path_or) + 518 store_var 42 (_125) + + 322 519 load_var 36 (result) + 520 call 330 ntypeargs=0 (baml.json.stringify) + 521 store_var 43 (_128) + + 319 522 load_const 78 ("claude-code") + 523 load_var2 42 43 + 524 init_instance 9 (ai.errors.Refused .provider, .reason, .raw_body) + 525 throw + + 313 526 load_type 3 + 527 load_var 37 (exit) + 528 load_field 0 (exit_code) + 529 call 138 ntypeargs=1 (baml.String.from) + 530 store_var 41 (_118) + 531 jump +6 (to 537) + + 291 532 load_var 29 (p) + 533 sys_op 254 (baml.sys.Process.close) + 534 pop 1 + + 227 535 load_var 33 (_100) + 536 rethrow + + 310 537 load_const 79 ("claude-code") + 538 load_const 26 (null) + + 313 539 load_const 80 ("the Claude Code CLI exited with code ") + 540 load_var 41 (_118) + 541 bin_op + + 542 load_const 26 (null) + 543 init_instance 10 (ai.errors.InvalidRequest .provider, .status_code, .detail, .raw_body) + 544 throw +} + +function claude_code.internal.mcp_config_json(c: claude_code.ClaudeCodeClient) -> string | null { + 207 0 load_var 1 (c) + 1 load_field 6 (mcp_servers) + 2 container_len + 3 store_var 2 (_3) + 4 load_var 2 (_3) + 5 load_const 0 (0) + 6 cmp_int_op == + 7 pop_jump_if_false +2 (to 9) + 8 jump +18 (to 26) + + 210 9 load_type 1 + 10 load_type 2 + 11 alloc_map 0 + 12 store_var 3 (wrapper) + + 211 13 load_type 1 + 14 load_type 2 + 15 load_var 3 (wrapper) + 16 load_const 3 ("mcpServers") + 17 load_var 1 (c) + 18 load_field 6 (mcp_servers) + 19 call 37 ntypeargs=2 (baml.Map.set) + 20 pop 1 + + 212 21 load_type 4 + 22 load_var 3 (wrapper) + 23 call 333 ntypeargs=1 (baml.json.to_json) + 24 call 330 ntypeargs=0 (baml.json.stringify) + 25 jump +2 (to 27) + + 208 26 load_const 5 (null) + 27 return +} + +function claude_code.internal.tool_protocol(tb: ai.tools.Toolbox) -> string { + 99 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (catalog) + + 100 3 load_var 1 (tb) + 4 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +40 (to 57) + 18 load_var 5 (_5) + 19 store_var 6 (t) + + 102 20 load_type 0 + 21 load_var 6 (t) + 22 load_field 0 (name) + 23 call 138 ntypeargs=1 (baml.String.from) + 24 store_var 7 (_16) + 25 load_type 0 + 26 load_var 6 (t) + 27 load_field 1 (description) + 28 call 138 ntypeargs=1 (baml.String.from) + 29 store_var 8 (_19) + 30 load_type 6 + 31 load_var 6 (t) + 32 load_field 2 (input_schema) + 33 call 333 ntypeargs=1 (baml.json.to_json) + 34 call 330 ntypeargs=0 (baml.json.stringify) + 35 store_var 10 (_23) + 36 load_type 0 + 37 load_var 10 (_23) + 38 call 138 ntypeargs=1 (baml.String.from) + 39 store_var 9 (_22) + + 101 40 load_var 3 (catalog) + + 102 41 load_const 7 ("{\"name\": \"") + 42 load_var 7 (_16) + 43 bin_op + + 44 load_const 8 ("\", \"description\": \"") + 45 bin_op + + 46 load_var 8 (_19) + 47 bin_op + + 48 load_const 9 ("\", \"parameters\": ") + 49 bin_op + + 50 load_var 9 (_22) + 51 bin_op + + 52 load_const 10 ("}") + 53 bin_op + + 54 call 4 ntypeargs=0 (baml.Array.push) + 55 pop 1 + 56 jump -47 (to 9) + + 121 57 load_type 0 + 58 load_var 3 (catalog) + 59 load_const 11 (", ") + 60 call 15 ntypeargs=1 (baml.Array.join) + 61 store_var 12 (_30) + + 105 62 load_type 0 + 63 load_var 12 (_30) + 64 call 138 ntypeargs=1 (baml.String.from) + 65 store_var 11 (_29) + 66 load_const 12 ("\n\nThe output contract is one object with an outcome field. Set outcome\nto either the final result or a tool request. The tools in the catalog\nbelow are NOT installed in your environment — never attempt to invoke\nthem directly; any such attempt fails. The ONLY way to run one is to\nfinish your reply with outcome set to\n{\"calls\": [{\"id\": \"\", \"name\": \"\", \"args\": {...}}]};\nthe caller executes the calls and re-invokes you with their results in\nthe conversation. If the Conversation so far section shows no tool\nresults yet, your outcome MUST be a calls request — never invent data a\ntool can provide. After tool results appear in the conversation, use\nthem; the Conversation so far section is authoritative. A tool result\nwith is_error=false means that call already ran — never repeat the same\nsuccessful tool call. Request only tools that are still necessary, or\nreturn the final result.\n\nApplication tool catalog (request via outcome.calls only):\n[") + 67 load_var 11 (_29) + 68 bin_op + + 69 load_const 13 ("]") + 70 bin_op + + 71 store_var 2 (_0) + 72 load_var 2 (_0) + 73 return +} + +function claude_code.internal.transcript_text(j: ai.Journal) -> string { + 7 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (lines) + + 8 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 3 (_4) + 9 load_var 3 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 4 (_5) + 14 load_var 4 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +168 (to 185) + 18 load_var 4 (_5) + 19 store_var 5 (e) + + 9 20 load_var 5 (e) + 21 store_var 6 (_9) + 22 load_var 6 (_9) + 23 narrow_bind 6 6 + 24 pop_jump_if_false +2 (to 26) + 25 jump +146 (to 171) + 26 load_var 5 (e) + 27 store_var 9 (_16) + 28 load_var 9 (_16) + 29 narrow_bind 7 9 + 30 pop_jump_if_false +2 (to 32) + 31 jump +58 (to 89) + 32 load_var 5 (e) + 33 store_var 23 (_52) + 34 load_var 23 (_52) + 35 narrow_bind 8 23 + 36 pop_jump_if_false +2 (to 38) + 37 jump +29 (to 66) + 38 load_var 5 (e) + 39 store_var 27 (_64) + 40 load_var 27 (_64) + 41 narrow_bind 9 27 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 27 (_64) + 44 store_var 28 (failed) + + 34 45 load_type 0 + 46 load_var 28 (failed) + 47 load_field 0 (id) + 48 call 138 ntypeargs=1 (baml.String.from) + 49 store_var 29 (_70) + 50 load_type 0 + 51 load_var 28 (failed) + 52 load_field 1 (message) + 53 call 138 ntypeargs=1 (baml.String.from) + 54 store_var 30 (_73) + 55 load_var 2 (lines) + 56 load_const 10 ("tool result id=") + 57 load_var 29 (_70) + 58 bin_op + + 59 load_const 11 (" is_error=true: ") + 60 bin_op + + 61 load_var 30 (_73) + 62 bin_op + + 63 call 4 ntypeargs=0 (baml.Array.push) + 64 pop 1 + 65 jump -56 (to 9) + + 9 66 load_var 23 (_52) + 67 store_var 24 (done) + + 31 68 load_type 0 + 69 load_var 24 (done) + 70 load_field 0 (id) + 71 call 138 ntypeargs=1 (baml.String.from) + 72 store_var 25 (_58) + 73 load_type 0 + 74 load_var 24 (done) + 75 load_field 1 (output) + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 26 (_61) + 78 load_var 2 (lines) + 79 load_const 12 ("tool result id=") + 80 load_var 25 (_58) + 81 bin_op + + 82 load_const 13 (" is_error=false: ") + 83 bin_op + + 84 load_var 26 (_61) + 85 bin_op + + 86 call 4 ntypeargs=0 (baml.Array.push) + 87 pop 1 + 88 jump -79 (to 9) + + 9 89 load_var 9 (_16) + 90 store_var_load_var 10 (a) + + 14 91 load_field 0 (content) + 92 load_type 14 + 93 load_const 15 ("iter") + 94 virtual_call nargs=1 ntypeargs=0 + 95 store_var 11 (_19) + 96 load_var 11 (_19) + 97 load_type 16 + 98 load_const 17 ("next") + 99 virtual_call nargs=1 ntypeargs=0 + 100 store_var 12 (_20) + 101 load_var 12 (_20) + 102 is_type 5 + 103 pop_jump_if_false +2 (to 105) + 104 jump -95 (to 9) + 105 load_var 12 (_20) + 106 store_var 13 (b) + + 15 107 load_var 13 (b) + 108 store_var 14 (_24) + 109 load_var 14 (_24) + 110 narrow_bind 18 14 + 111 pop_jump_if_false +2 (to 113) + 112 jump +45 (to 157) + 113 load_var 13 (b) + 114 store_var 17 (_31) + 115 load_var 17 (_31) + 116 narrow_bind 19 17 + 117 pop_jump_if_false -21 (to 96) + 118 load_var 17 (_31) + 119 store_var 18 (c) + + 21 120 load_type 0 + 121 load_var 18 (c) + 122 load_field 0 (id) + 123 call 138 ntypeargs=1 (baml.String.from) + 124 store_var 19 (_40) + 125 load_type 0 + 126 load_var 18 (c) + 127 load_field 1 (name) + 128 call 138 ntypeargs=1 (baml.String.from) + 129 store_var 20 (_43) + 130 load_type 20 + 131 load_var 18 (c) + 132 load_field 2 (args) + 133 call 333 ntypeargs=1 (baml.json.to_json) + 134 call 330 ntypeargs=0 (baml.json.stringify) + 135 store_var 22 (_47) + 136 load_type 0 + 137 load_var 22 (_47) + 138 call 138 ntypeargs=1 (baml.String.from) + 139 store_var 21 (_46) + + 20 140 load_var 2 (lines) + + 21 141 load_const 21 ("assistant tool_call: {\"id\": \"") + 142 load_var 19 (_40) + 143 bin_op + + 144 load_const 22 ("\", \"name\": \"") + 145 bin_op + + 146 load_var 20 (_43) + 147 bin_op + + 148 load_const 23 ("\", \"args\": ") + 149 bin_op + + 150 load_var 21 (_46) + 151 bin_op + + 152 load_const 24 ("}") + 153 bin_op + + 154 call 4 ntypeargs=0 (baml.Array.push) + 155 pop 1 + 156 jump -60 (to 96) + + 15 157 load_var 14 (_24) + 158 store_var 15 (t) + + 17 159 load_type 0 + 160 load_var 15 (t) + 161 load_field 0 (text) + 162 call 138 ntypeargs=1 (baml.String.from) + 163 store_var 16 (_28) + 164 load_var 2 (lines) + 165 load_const 25 ("assistant: ") + 166 load_var 16 (_28) + 167 bin_op + + 168 call 4 ntypeargs=0 (baml.Array.push) + 169 pop 1 + 170 jump -74 (to 96) + + 9 171 load_var 6 (_9) + 172 store_var 7 (u) + + 11 173 load_type 0 + 174 load_var 7 (u) + 175 load_field 0 (content) + 176 call 138 ntypeargs=1 (baml.String.from) + 177 store_var 8 (_13) + 178 load_var 2 (lines) + 179 load_const 26 ("user: ") + 180 load_var 8 (_13) + 181 bin_op + + 182 call 4 ntypeargs=0 (baml.Array.push) + 183 pop 1 + 184 jump -175 (to 9) + + 41 185 load_var 2 (lines) + 186 container_len + 187 store_var 31 (_77) + 188 load_var 31 (_77) + 189 load_const 27 (0) + 190 cmp_int_op == + 191 pop_jump_if_false +2 (to 193) + 192 jump +14 (to 206) + + 44 193 load_type 0 + 194 load_var 2 (lines) + 195 load_const 28 ("\n") + 196 call 15 ntypeargs=1 (baml.Array.join) + 197 store_var 33 (_79) + 198 load_type 0 + 199 load_var 33 (_79) + 200 call 138 ntypeargs=1 (baml.String.from) + 201 store_var 32 (_78) + 202 load_const 29 ("\n\nConversation so far:\n") + 203 load_var 32 (_78) + 204 bin_op + + + 41 205 jump +2 (to 207) + + 42 206 load_const 30 ("") + 207 return +} + +function google.GoogleClient.ai.Client.id(self: google.GoogleClient) -> string { + 18 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 3 (_2) + 5 load_const 1 ("google/") + 6 load_var 3 (_2) + 7 bin_op + + 8 store_var 2 (_0) + 9 load_var 2 (_0) + 10 return +} + +function google.GoogleClient.ai.Client.invoke(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 22 0 load_var2 1 2 + 1 call 887 ntypeargs=0 (google.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 23 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function google.GoogleClient.ai.stream.StreamingClient.invoke_stream(self: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 30 0 load_var2 1 2 + 1 call 889 ntypeargs=0 (google.internal.invoke_stream) + 2 return +} + +function google.GoogleClient.new(model: string, api_key: string | null, base_url: string | null) -> google.GoogleClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 9 4 load_const 1 ("gemini-2.5-flash") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 10 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 11 16 load_const 2 (null) + 17 store_var 3 (base_url) + + 13 18 load_var2 1 2 + 19 load_var 3 (base_url) + 20 init_instance 0 (google.GoogleClient .model, .api_key, .base_url) + 21 return +} + +function google.internal._gm_content(role: string, parts: map[]) -> map { + 44 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 4 (m) + + 45 4 load_type 0 + 5 load_type 1 + 6 load_var 4 (m) + 7 load_const 2 ("role") + 8 load_var 1 (role) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 46 11 load_type 0 + 12 load_type 1 + 13 load_var 4 (m) + 14 load_const 3 ("parts") + 15 load_var 2 (parts) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 47 18 load_var 4 (m) + 19 store_var 3 (_0) + 20 load_var 3 (_0) + 21 return +} + +function google.internal._gm_function_response(name: string, response: map) -> map { + 62 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 4 (fr) + + 63 4 load_type 0 + 5 load_type 1 + 6 load_var 4 (fr) + 7 load_const 2 ("name") + 8 load_var 1 (name) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 64 11 load_type 0 + 12 load_type 1 + 13 load_var 4 (fr) + 14 load_const 3 ("response") + 15 load_var 2 (response) + 16 call 37 ntypeargs=2 (baml.Map.set) + 17 pop 1 + + 65 18 load_type 0 + 19 load_type 1 + 20 alloc_map 0 + 21 store_var 5 (part) + + 66 22 load_type 0 + 23 load_type 1 + 24 load_var 5 (part) + 25 load_const 4 ("functionResponse") + 26 load_var 4 (fr) + 27 call 37 ntypeargs=2 (baml.Map.set) + 28 pop 1 + + 67 29 load_var 5 (part) + 30 store_var 3 (_0) + 31 load_var 3 (_0) + 32 return +} + +function google.internal._gm_text_part(text: string) -> map { + 52 0 load_type 0 + 1 load_type 1 + 2 alloc_map 0 + 3 store_var 3 (p) + + 53 4 load_type 0 + 5 load_type 1 + 6 load_var 3 (p) + 7 load_const 2 ("text") + 8 load_var 1 (text) + 9 call 37 ntypeargs=2 (baml.Map.set) + 10 pop 1 + + 54 11 load_var 3 (p) + 12 store_var 2 (_0) + 13 load_var 2 (_0) + 14 return +} + +function google.internal._gm_tool_name_for(j: ai.Journal, id: string) -> string { + 109 0 load_const 0 ("") + 1 store_var 3 (name) + + 110 2 load_var 1 (j) + 3 call 783 ntypeargs=0 (ai.Journal.entries) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_5) + 8 load_var 4 (_5) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_6) + 13 load_var 5 (_6) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +41 (to 57) + 17 load_var 5 (_6) + 18 store_var 6 (e) + + 111 19 load_var 6 (e) + 20 store_var 7 (_10) + 21 load_var 7 (_10) + 22 narrow_bind 6 7 + 23 pop_jump_if_false -15 (to 8) + 24 load_var 7 (_10) + 25 store_var_load_var 8 (a) + + 113 26 load_field 0 (content) + 27 load_type 7 + 28 load_const 8 ("iter") + 29 virtual_call nargs=1 ntypeargs=0 + 30 store_var 9 (_13) + 31 load_var 9 (_13) + 32 load_type 9 + 33 load_const 10 ("next") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 10 (_14) + 36 load_var 10 (_14) + 37 is_type 5 + 38 pop_jump_if_false +2 (to 40) + 39 jump -31 (to 8) + 40 load_var 10 (_14) + 41 store_var 11 (b) + + 114 42 load_var 11 (b) + 43 store_var 12 (_18) + 44 load_var 12 (_18) + 45 narrow_bind 11 12 + 46 pop_jump_if_false -15 (to 31) + 47 load_var 12 (_18) + 48 store_var_load_var 13 (u) + + 116 49 load_field 0 (id) + 50 load_var 2 (id) + 51 cmp_op == + 52 pop_jump_if_false -21 (to 31) + + 117 53 load_var 13 (u) + 54 load_field 1 (name) + 55 store_var 3 (name) + + 116 56 jump -25 (to 31) + + 131 57 load_var 3 (name) + 58 return +} + +function google.internal._google_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 367 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 368 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +235 (to 252) + 18 load_var 5 (_5) + 19 store_var_load_var 6 (raw) + + 369 20 load_field 1 (data) + 21 store_var 7 (_10) + 22 load_var 7 (_10) + 23 narrow_bind 6 7 + 24 pop_jump_if_false -15 (to 9) + 25 load_var 7 (_10) + 26 store_var 8 (data) + + 370 27 load_type 7 + 28 load_var 8 (data) + 29 call 335 ntypeargs=1 (baml.json.from_string) + 30 jump +4 (to 34) + 31 load_var 9 (e) + 32 throw_if_panic + + 371 33 load_const 8 (null) + + 373 34 store_var 10 (_16) + 35 load_var 10 (_16) + 36 narrow_bind 9 10 + 37 pop_jump_if_false -28 (to 9) + 38 load_var 10 (_16) + 39 store_var_load_var 11 (resp) + + 374 40 load_field 0 (candidates) + 41 load_const 8 (null) + 42 cmp_op == + 43 pop_jump_if_false +2 (to 45) + 44 jump +8 (to 52) + 45 load_const 10 (0) + 46 load_var 11 (resp) + 47 load_field 0 (candidates) + 48 make_bound_method 3 + 49 call_indirect + 50 store_var 12 (cand) + 51 jump +3 (to 54) + 52 load_const 8 (null) + 53 store_var 12 (cand) + + 375 54 load_var 12 (cand) + 55 load_const 8 (null) + 56 cmp_op == + 57 pop_jump_if_false +2 (to 59) + 58 jump +17 (to 75) + 59 load_var 12 (cand) + 60 load_field 0 (0) + 61 load_const 8 (null) + 62 cmp_op == + 63 pop_jump_if_false +2 (to 65) + 64 jump +11 (to 75) + 65 load_var 12 (cand) + 66 load_const 8 (null) + 67 cmp_op == + 68 pop_jump_if_false +2 (to 70) + 69 jump +6 (to 75) + 70 load_var 12 (cand) + 71 load_field 0 (0) + 72 load_field 0 (0) + 73 store_var 14 (_24) + 74 jump +3 (to 77) + 75 load_const 8 (null) + 76 store_var 14 (_24) + 77 load_var 14 (_24) + 78 store_var 13 (parts) + 79 load_var 14 (_24) + 80 load_const 8 (null) + 81 cmp_op == + 82 pop_jump_if_false +4 (to 86) + 83 load_type 11 + 84 alloc_array 0 + 85 store_var 13 (parts) + + 376 86 load_var 13 (parts) + 87 load_type 12 + 88 load_const 13 ("iter") + 89 virtual_call nargs=1 ntypeargs=0 + 90 store_var 15 (_36) + 91 load_var 15 (_36) + 92 load_type 14 + 93 load_const 15 ("next") + 94 virtual_call nargs=1 ntypeargs=0 + 95 store_var 16 (_37) + 96 load_var 16 (_37) + 97 is_type 5 + 98 pop_jump_if_false +2 (to 100) + 99 jump +29 (to 128) + 100 load_var 16 (_37) + 101 store_var_load_var 17 (p) + + 377 102 load_field 0 (text) + 103 store_var 18 (_42) + 104 load_var 18 (_42) + 105 narrow_bind 6 18 + 106 pop_jump_if_false -15 (to 91) + 107 load_var 18 (_42) + 108 store_var 19 (t) + + 378 109 load_var 17 (p) + 110 load_field 1 (thought) + 111 store_var 21 (_45) + 112 load_var 21 (_45) + 113 store_var 20 (_44) + 114 load_var 21 (_45) + 115 load_const 8 (null) + 116 cmp_op == + 117 pop_jump_if_false +3 (to 120) + 118 load_const 16 (false) + 119 store_var 20 (_44) + 120 load_var 20 (_44) + 121 pop_jump_if_false +2 (to 123) + 122 jump -31 (to 91) + + 381 123 load_var2 3 19 + 124 init_instance 0 (ai.stream.TextDelta .text) + 125 call 4 ntypeargs=0 (baml.Array.push) + 126 pop 1 + 127 jump -36 (to 91) + + 388 128 load_var 12 (cand) + 129 load_const 8 (null) + 130 cmp_op == + 131 pop_jump_if_false +2 (to 133) + 132 jump +5 (to 137) + 133 load_var 12 (cand) + 134 load_field 1 (1) + 135 store_var 23 (_51) + 136 jump +3 (to 139) + 137 load_const 8 (null) + 138 store_var 23 (_51) + 139 load_var 23 (_51) + 140 store_var 22 (finish) + 141 load_var 23 (_51) + 142 load_const 8 (null) + 143 cmp_op == + 144 pop_jump_if_false +3 (to 147) + 145 load_const 17 ("") + 146 store_var 22 (finish) + + 389 147 load_var 11 (resp) + 148 load_field 2 (promptFeedback) + 149 load_const 8 (null) + 150 cmp_op == + 151 pop_jump_if_false +2 (to 153) + 152 jump +5 (to 157) + 153 load_var 11 (resp) + 154 load_field 2 (promptFeedback) + 155 load_field 0 (0) + 156 jump +2 (to 158) + 157 load_const 8 (null) + 158 load_const 8 (null) + 159 call 635 ntypeargs=0 (baml.ops.equals_equals) + 160 unary_op ! + 161 store_var 24 (blocked) + + 390 162 load_var 22 (finish) + 163 load_const 18 ("MAX_TOKENS") + 164 cmp_op == + 165 pop_jump_if_false +2 (to 167) + 166 jump +38 (to 204) + + 393 167 load_var 24 (blocked) + 168 jump_if_false +2 (to 170) + 169 jump +5 (to 174) + 170 pop 1 + + 394 171 load_var 22 (finish) + 172 load_const 19 ("SAFETY") + 173 cmp_op == + + 393 174 jump_if_false +2 (to 176) + 175 jump +5 (to 180) + 176 pop 1 + + 395 177 load_var 22 (finish) + 178 load_const 20 ("RECITATION") + 179 cmp_op == + + 393 180 jump_if_false +2 (to 182) + 181 jump +5 (to 186) + 182 pop 1 + + 396 183 load_var 22 (finish) + 184 load_const 21 ("PROHIBITED_CONTENT") + 185 cmp_op == + + 392 186 pop_jump_if_false +2 (to 188) + 187 jump +13 (to 200) + + 399 188 load_var 22 (finish) + 189 load_const 22 ("") + 190 cmp_op != + 191 pop_jump_if_false +2 (to 193) + 192 jump +4 (to 196) + + 402 193 load_const 8 (null) + 194 store_var 25 (stop) + + 399 195 jump +12 (to 207) + + 400 196 load_const 10 (ai.content.StopReason.Complete) + 197 alloc_variant 436 (ai.content.StopReason) + 198 store_var 25 (stop) + + 399 199 jump +8 (to 207) + + 398 200 load_const 23 (ai.content.StopReason.Refused) + 201 alloc_variant 436 (ai.content.StopReason) + 202 store_var 25 (stop) + + 392 203 jump +4 (to 207) + + 391 204 load_const 24 (ai.content.StopReason.MaxTokens) + 205 alloc_variant 436 (ai.content.StopReason) + 206 store_var 25 (stop) + + 404 207 load_var 11 (resp) + 208 load_field 1 (usageMetadata) + 209 store_var 26 (usage) + + 405 210 load_var 25 (stop) + 211 load_const 8 (null) + 212 call 635 ntypeargs=0 (baml.ops.equals_equals) + 213 unary_op ! + 214 jump_if_false +2 (to 216) + 215 jump +6 (to 221) + 216 pop 1 + 217 load_var 26 (usage) + 218 load_const 8 (null) + 219 call 635 ntypeargs=0 (baml.ops.equals_equals) + 220 unary_op ! + 221 pop_jump_if_false -212 (to 9) + + 408 222 load_var 25 (stop) + 223 store_var 27 (_83) + + 409 224 load_var 26 (usage) + 225 load_const 8 (null) + 226 cmp_op == + 227 pop_jump_if_false +2 (to 229) + 228 jump +5 (to 233) + 229 load_var 26 (usage) + 230 load_field 0 (0) + 231 store_var 28 (_84) + 232 jump +3 (to 235) + 233 load_const 8 (null) + 234 store_var 28 (_84) + + 410 235 load_var 26 (usage) + 236 load_const 8 (null) + 237 cmp_op == + 238 pop_jump_if_false +2 (to 240) + 239 jump +5 (to 244) + 240 load_var 26 (usage) + 241 load_field 1 (1) + 242 store_var 29 (_88) + 243 jump +3 (to 246) + 244 load_const 8 (null) + 245 store_var 29 (_88) + + 406 246 load_var2 3 27 + + 407 247 load_var2 28 29 + 248 init_instance 1 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 249 call 4 ntypeargs=0 (baml.Array.push) + 250 pop 1 + 251 jump -242 (to 9) + + 426 252 load_var 3 (out) + 253 store_var 2 (_0) + 254 load_var 2 (_0) + 255 return +} + +function google.internal._google_request(c: google.GoogleClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 226 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 5 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 5 (_5) + 7 call_indirect + + 227 8 call 881 ntypeargs=0 (google.internal.google_lower_prompt) + 9 store_var 6 (prompt_parts) + + 228 10 load_var 6 (prompt_parts) + 11 load_field 1 (contents) + 12 store_var 7 (contents) + + 229 13 load_var 2 (input) + 14 load_field 1 (journal) + 15 call 883 ntypeargs=0 (google.internal.google_lower_journal) + 16 load_type 0 + 17 load_const 1 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 8 (_13) + 20 load_var 8 (_13) + 21 load_type 2 + 22 load_const 3 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 9 (_14) + 25 load_var 9 (_14) + 26 is_type 4 + 27 pop_jump_if_false +2 (to 29) + 28 jump +7 (to 35) + 29 load_var 9 (_14) + 30 store_var 10 (item) + + 230 31 load_var2 7 10 + 32 call 4 ntypeargs=0 (baml.Array.push) + 33 pop 1 + 34 jump -14 (to 20) + + 232 35 load_type 5 + 36 load_type 6 + 37 alloc_map 0 + 38 store_var 11 (body) + + 237 39 load_var 6 (prompt_parts) + 40 load_field 2 (first_role) + 41 store_var_load_var 12 (first_role) + + 238 42 load_const 7 ("user") + 43 cmp_op != + 44 jump_if_false +9 (to 53) + 45 pop 1 + 46 load_var 6 (prompt_parts) + 47 load_field 0 (system_parts) + 48 container_len + 49 store_var 13 (_25) + 50 load_var 13 (_25) + 51 load_const 8 (0) + 52 cmp_int_op > + 53 pop_jump_if_false +2 (to 55) + 54 jump +29 (to 83) + + 241 55 load_var 6 (prompt_parts) + 56 load_field 0 (system_parts) + 57 container_len + 58 store_var 15 (_33) + 59 load_var 15 (_33) + 60 load_const 8 (0) + 61 cmp_int_op > + 62 pop_jump_if_false +33 (to 95) + + 242 63 load_type 5 + 64 load_type 6 + 65 alloc_map 0 + 66 store_var 16 (system_instruction) + + 243 67 load_type 5 + 68 load_type 6 + 69 load_var 16 (system_instruction) + 70 load_const 9 ("parts") + 71 load_var 6 (prompt_parts) + 72 load_field 0 (system_parts) + 73 call 37 ntypeargs=2 (baml.Map.set) + 74 pop 1 + + 244 75 load_type 5 + 76 load_type 6 + 77 load_var 11 (body) + 78 load_const 10 ("systemInstruction") + 79 load_var 16 (system_instruction) + 80 call 37 ntypeargs=2 (baml.Map.set) + 81 pop 1 + 82 jump +13 (to 95) + + 239 83 load_const 11 ("user") + 84 load_var 6 (prompt_parts) + 85 load_field 0 (system_parts) + 86 call 878 ntypeargs=0 (google.internal._gm_content) + 87 store_var 14 (_28) + 88 load_type 12 + 89 load_var 14 (_28) + 90 load_type 12 + 91 alloc_array 1 + 92 load_var 7 (contents) + 93 call 7 ntypeargs=1 (baml.Array.concat) + 94 store_var 7 (contents) + + 249 95 load_type 5 + 96 load_type 6 + 97 load_var 11 (body) + 98 load_const 13 ("contents") + 99 load_var 7 (contents) + 100 call 37 ntypeargs=2 (baml.Map.set) + 101 pop 1 + + 250 102 load_var 2 (input) + 103 load_field 2 (toolbox) + 104 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 105 unary_op ! + 106 pop_jump_if_false +103 (to 209) + + 251 107 load_type 12 + 108 alloc_array 0 + 109 store_var 17 (decls) + + 252 110 load_var 2 (input) + 111 load_field 2 (toolbox) + 112 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 113 load_type 14 + 114 load_const 15 ("iter") + 115 virtual_call nargs=1 ntypeargs=0 + 116 store_var 18 (_54) + 117 load_var 18 (_54) + 118 load_type 16 + 119 load_const 17 ("next") + 120 virtual_call nargs=1 ntypeargs=0 + 121 store_var 19 (_55) + 122 load_var 19 (_55) + 123 is_type 4 + 124 pop_jump_if_false +2 (to 126) + 125 jump +35 (to 160) + 126 load_var 19 (_55) + 127 store_var 20 (t) + + 253 128 load_type 5 + 129 load_type 6 + 130 alloc_map 0 + 131 store_var 21 (d) + + 254 132 load_type 5 + 133 load_type 6 + 134 load_var 21 (d) + 135 load_const 18 ("name") + 136 load_var 20 (t) + 137 load_field 0 (name) + 138 call 37 ntypeargs=2 (baml.Map.set) + 139 pop 1 + + 255 140 load_type 5 + 141 load_type 6 + 142 load_var 21 (d) + 143 load_const 19 ("description") + 144 load_var 20 (t) + 145 load_field 1 (description) + 146 call 37 ntypeargs=2 (baml.Map.set) + 147 pop 1 + + 256 148 load_type 5 + 149 load_type 6 + 150 load_var 21 (d) + 151 load_const 20 ("parametersJsonSchema") + 152 load_var 20 (t) + 153 load_field 2 (input_schema) + 154 call 37 ntypeargs=2 (baml.Map.set) + 155 pop 1 + + 257 156 load_var2 17 21 + 157 call 4 ntypeargs=0 (baml.Array.push) + 158 pop 1 + 159 jump -42 (to 117) + + 259 160 load_type 5 + 161 load_type 6 + 162 alloc_map 0 + 163 store_var 22 (group) + + 260 164 load_type 5 + 165 load_type 6 + 166 load_var 22 (group) + 167 load_const 21 ("functionDeclarations") + 168 load_var 17 (decls) + 169 call 37 ntypeargs=2 (baml.Map.set) + 170 pop 1 + + 261 171 load_type 5 + 172 load_type 6 + 173 load_var 11 (body) + 174 load_const 22 ("tools") + 175 load_var 22 (group) + 176 load_type 12 + 177 alloc_array 1 + 178 call 37 ntypeargs=2 (baml.Map.set) + 179 pop 1 + + 262 180 load_type 5 + 181 load_type 6 + 182 alloc_map 0 + 183 store_var 23 (fcc) + + 263 184 load_type 5 + 185 load_type 6 + 186 load_var 23 (fcc) + 187 load_const 23 ("mode") + 188 load_const 24 ("AUTO") + 189 call 37 ntypeargs=2 (baml.Map.set) + 190 pop 1 + + 264 191 load_type 5 + 192 load_type 6 + 193 alloc_map 0 + 194 store_var 24 (tc) + + 265 195 load_type 5 + 196 load_type 6 + 197 load_var 24 (tc) + 198 load_const 25 ("functionCallingConfig") + 199 load_var 23 (fcc) + 200 call 37 ntypeargs=2 (baml.Map.set) + 201 pop 1 + + 266 202 load_type 5 + 203 load_type 6 + 204 load_var 11 (body) + 205 load_const 26 ("toolConfig") + 206 load_var 24 (tc) + 207 call 37 ntypeargs=2 (baml.Map.set) + 208 pop 1 + + 271 209 load_var 3 (stream) + 210 pop_jump_if_false +2 (to 212) + 211 jump +4 (to 215) + + 274 212 load_const 27 (":generateContent") + 213 store_var 25 (method) + + 271 214 jump +3 (to 217) + + 272 215 load_const 28 (":streamGenerateContent?alt=sse") + 216 store_var 25 (method) + + 278 217 load_var 1 (c) + 218 load_field 2 (base_url) + 219 store_var 28 (_103) + 220 load_var 28 (_103) + 221 store_var 27 (_102) + 222 load_var 28 (_103) + 223 load_const 29 (null) + 224 cmp_op == + 225 pop_jump_if_false +3 (to 228) + 226 load_const 30 ("https://generativelanguage.googleapis.com/v1beta") + 227 store_var 27 (_102) + 228 load_type 5 + 229 load_var 27 (_102) + 230 call 138 ntypeargs=1 (baml.String.from) + 231 store_var 26 (_101) + 232 load_type 5 + 233 load_var 1 (c) + 234 load_field 0 (model) + 235 call 138 ntypeargs=1 (baml.String.from) + 236 store_var 29 (_106) + 237 load_type 5 + 238 load_var 25 (method) + 239 call 138 ntypeargs=1 (baml.String.from) + 240 store_var 30 (_109) + + 280 241 load_var 1 (c) + 242 load_field 1 (api_key) + 243 store_var 32 (_114) + 244 load_var2 32 32 + 245 load_const 29 (null) + 246 cmp_op == + 247 pop_jump_if_false +3 (to 250) + 248 load_const 31 ("GOOGLE_API_KEY") + 249 call 211 ntypeargs=0 (baml.env.get_or_panic) + + 279 250 load_const 32 ("application/json") + 251 load_const 33 ("x-goog-api-key") + 252 load_const 34 ("content-type") + 253 load_type 5 + 254 load_type 5 + 255 alloc_map 2 + 256 store_var 31 (_112) + + 283 257 load_type 12 + 258 load_var 11 (body) + 259 call 333 ntypeargs=1 (baml.json.to_json) + 260 call 330 ntypeargs=0 (baml.json.stringify) + 261 store_var 33 (_116) + + 276 262 load_const 35 ("POST") + + 278 263 load_var 26 (_101) + 264 load_const 36 ("/models/") + 265 bin_op + + 266 load_var 29 (_106) + 267 bin_op + + 268 load_var 30 (_109) + 269 bin_op + + 270 load_var2 31 33 + 271 init_instance 0 (baml.http.Request .method, .url, .headers, .body) + 272 store_var 4 (_0) + 273 load_var 4 (_0) + 274 return +} + +function google.internal.google_lower_journal(j: ai.Journal) -> map[] { + 139 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (contents) + + 140 3 load_type 0 + 4 alloc_array 0 + 5 store_var 4 (pending) + + 141 6 load_var 1 (j) + 7 call 783 ntypeargs=0 (ai.Journal.entries) + 8 load_type 1 + 9 load_const 2 ("iter") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 5 (_5) + 12 load_var 5 (_5) + 13 load_type 3 + 14 load_const 4 ("next") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 6 (_6) + 17 load_var 6 (_6) + 18 is_type 5 + 19 pop_jump_if_false +2 (to 21) + 20 jump +218 (to 238) + 21 load_var 6 (_6) + 22 store_var 7 (e) + + 142 23 load_var 7 (e) + 24 store_var 8 (_10) + 25 load_var 8 (_10) + 26 narrow_bind 6 8 + 27 pop_jump_if_false +2 (to 29) + 28 jump +177 (to 205) + 29 load_var 7 (e) + 30 store_var 14 (_22) + 31 load_var 14 (_22) + 32 narrow_bind 7 14 + 33 pop_jump_if_false +2 (to 35) + 34 jump +60 (to 94) + 35 load_var 7 (e) + 36 store_var 31 (_64) + 37 load_var 31 (_64) + 38 narrow_bind 8 31 + 39 pop_jump_if_false +2 (to 41) + 40 jump +30 (to 70) + 41 load_var 7 (e) + 42 store_var 35 (_76) + 43 load_var 35 (_76) + 44 narrow_bind 9 35 + 45 pop_jump_if_false -33 (to 12) + 46 load_var 35 (_76) + 47 store_var 36 (f) + + 197 48 load_type 10 + 49 load_type 11 + 50 alloc_map 0 + 51 store_var 37 (response) + + 198 52 load_type 10 + 53 load_type 11 + 54 load_var 37 (response) + 55 load_const 12 ("error") + 56 load_var 36 (f) + 57 load_field 1 (message) + 58 call 37 ntypeargs=2 (baml.Map.set) + 59 pop 1 + + 199 60 load_var2 1 36 + 61 load_field 0 (id) + 62 call 882 ntypeargs=0 (google.internal._gm_tool_name_for) + 63 load_var 37 (response) + 64 call 880 ntypeargs=0 (google.internal._gm_function_response) + 65 store_var 38 (_84) + 66 load_var2 4 38 + 67 call 4 ntypeargs=0 (baml.Array.push) + 68 pop 1 + 69 jump -57 (to 12) + + 142 70 load_var 31 (_64) + 71 store_var 32 (c) + + 191 72 load_type 10 + 73 load_type 11 + 74 alloc_map 0 + 75 store_var 33 (response) + + 192 76 load_type 10 + 77 load_type 11 + 78 load_var 33 (response) + 79 load_const 13 ("result") + 80 load_var 32 (c) + 81 load_field 1 (output) + 82 call 37 ntypeargs=2 (baml.Map.set) + 83 pop 1 + + 193 84 load_var2 1 32 + 85 load_field 0 (id) + 86 call 882 ntypeargs=0 (google.internal._gm_tool_name_for) + 87 load_var 33 (response) + 88 call 880 ntypeargs=0 (google.internal._gm_function_response) + 89 store_var 34 (_72) + 90 load_var2 4 34 + 91 call 4 ntypeargs=0 (baml.Array.push) + 92 pop 1 + 93 jump -81 (to 12) + + 142 94 load_var 14 (_22) + 95 store_var 15 (a) + + 155 96 load_var 4 (pending) + 97 container_len + 98 store_var 16 (_25) + 99 load_var 16 (_25) + 100 load_const 14 (0) + 101 cmp_int_op > + 102 pop_jump_if_false +11 (to 113) + + 156 103 load_const 15 ("user") + 104 load_var 4 (pending) + 105 call 878 ntypeargs=0 (google.internal._gm_content) + 106 store_var 17 (_27) + 107 load_var2 3 17 + 108 call 4 ntypeargs=0 (baml.Array.push) + 109 pop 1 + + 157 110 load_type 0 + 111 alloc_array 0 + 112 store_var 4 (pending) + + 162 113 load_type 0 + 114 alloc_array 0 + 115 store_var 18 (parts) + + 163 116 load_var 15 (a) + 117 load_field 0 (content) + 118 load_type 16 + 119 load_const 17 ("iter") + 120 virtual_call nargs=1 ntypeargs=0 + 121 store_var 19 (_31) + 122 load_var 19 (_31) + 123 load_type 18 + 124 load_const 19 ("next") + 125 virtual_call nargs=1 ntypeargs=0 + 126 store_var 20 (_32) + 127 load_var 20 (_32) + 128 is_type 5 + 129 pop_jump_if_false +2 (to 131) + 130 jump +60 (to 190) + 131 load_var 20 (_32) + 132 store_var 21 (b) + + 164 133 load_var 21 (b) + 134 store_var 22 (_36) + 135 load_var 22 (_36) + 136 narrow_bind 20 22 + 137 pop_jump_if_false +2 (to 139) + 138 jump +43 (to 181) + 139 load_var 21 (b) + 140 store_var 25 (_41) + 141 load_var 25 (_41) + 142 narrow_bind 21 25 + 143 pop_jump_if_false -21 (to 122) + 144 load_var 25 (_41) + 145 store_var 26 (use) + + 170 146 load_type 10 + 147 load_type 11 + 148 alloc_map 0 + 149 store_var 27 (fc) + + 171 150 load_type 10 + 151 load_type 11 + 152 load_var 27 (fc) + 153 load_const 22 ("name") + 154 load_var 26 (use) + 155 load_field 1 (name) + 156 call 37 ntypeargs=2 (baml.Map.set) + 157 pop 1 + + 172 158 load_type 10 + 159 load_type 11 + 160 load_var 27 (fc) + 161 load_const 23 ("args") + 162 load_var 26 (use) + 163 load_field 2 (args) + 164 call 37 ntypeargs=2 (baml.Map.set) + 165 pop 1 + + 173 166 load_type 10 + 167 load_type 11 + 168 alloc_map 0 + 169 store_var 28 (part) + + 174 170 load_type 10 + 171 load_type 11 + 172 load_var 28 (part) + 173 load_const 24 ("functionCall") + 174 load_var 27 (fc) + 175 call 37 ntypeargs=2 (baml.Map.set) + 176 pop 1 + + 175 177 load_var2 18 28 + 178 call 4 ntypeargs=0 (baml.Array.push) + 179 pop 1 + 180 jump -58 (to 122) + + 164 181 load_var 22 (_36) + 182 store_var_load_var 23 (t) + + 166 183 load_field 0 (text) + 184 call 879 ntypeargs=0 (google.internal._gm_text_part) + 185 store_var 24 (_39) + 186 load_var2 18 24 + 187 call 4 ntypeargs=0 (baml.Array.push) + 188 pop 1 + 189 jump -67 (to 122) + + 182 190 load_var 18 (parts) + 191 container_len + 192 store_var 29 (_60) + 193 load_var 29 (_60) + 194 load_const 14 (0) + 195 cmp_int_op > + 196 pop_jump_if_false -184 (to 12) + + 183 197 load_const 25 ("model") + 198 load_var 18 (parts) + 199 call 878 ntypeargs=0 (google.internal._gm_content) + 200 store_var 30 (_62) + 201 load_var2 3 30 + 202 call 4 ntypeargs=0 (baml.Array.push) + 203 pop 1 + 204 jump -192 (to 12) + + 142 205 load_var 8 (_10) + 206 store_var 9 (u) + + 144 207 load_var 4 (pending) + 208 container_len + 209 store_var 10 (_13) + 210 load_var 10 (_13) + 211 load_const 14 (0) + 212 cmp_int_op > + 213 pop_jump_if_false +11 (to 224) + + 145 214 load_const 26 ("user") + 215 load_var 4 (pending) + 216 call 878 ntypeargs=0 (google.internal._gm_content) + 217 store_var 11 (_15) + 218 load_var2 3 11 + 219 call 4 ntypeargs=0 (baml.Array.push) + 220 pop 1 + + 146 221 load_type 0 + 222 alloc_array 0 + 223 store_var 4 (pending) + + 151 224 load_var 9 (u) + 225 load_field 0 (content) + 226 call 879 ntypeargs=0 (google.internal._gm_text_part) + 227 store_var 13 (_20) + 228 load_const 27 ("user") + 229 load_var 13 (_20) + 230 load_type 0 + 231 alloc_array 1 + 232 call 878 ntypeargs=0 (google.internal._gm_content) + 233 store_var 12 (_18) + 234 load_var2 3 12 + 235 call 4 ntypeargs=0 (baml.Array.push) + 236 pop 1 + 237 jump -225 (to 12) + + 205 238 load_var 4 (pending) + 239 container_len + 240 store_var 39 (_89) + 241 load_var 39 (_89) + 242 load_const 14 (0) + 243 cmp_int_op > + 244 pop_jump_if_false +8 (to 252) + + 206 245 load_const 28 ("user") + 246 load_var 4 (pending) + 247 call 878 ntypeargs=0 (google.internal._gm_content) + 248 store_var 40 (_91) + 249 load_var2 3 40 + 250 call 4 ntypeargs=0 (baml.Array.push) + 251 pop 1 + + 211 252 load_var 3 (contents) + 253 store_var 2 (_0) + 254 load_var 2 (_0) + 255 return +} + +function google.internal.google_lower_prompt(prompt: ai.Prompt) -> google.internal.GooglePrompt { + 79 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (system_parts) + + 80 3 load_type 0 + 4 alloc_array 0 + 5 store_var 3 (contents) + + 81 6 load_const 1 ("") + 7 store_var 4 (first_role) + + 82 8 load_var 1 (prompt) + 9 call 787 ntypeargs=0 (ai.Prompt.messages) + 10 load_type 2 + 11 load_const 3 ("iter") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_6) + 14 load_var 5 (_6) + 15 load_type 4 + 16 load_const 5 ("next") + 17 virtual_call nargs=1 ntypeargs=0 + 18 store_var 6 (_7) + 19 load_var 6 (_7) + 20 is_type 6 + 21 pop_jump_if_false +2 (to 23) + 22 jump +42 (to 64) + 23 load_var 6 (_7) + 24 store_var_load_var 7 (message) + + 83 25 load_field 1 (content) + 26 call 879 ntypeargs=0 (google.internal._gm_text_part) + 27 store_var 8 (part) + + 84 28 load_var 7 (message) + 29 load_field 0 (role) + 30 load_const 7 ("system") + 31 cmp_op == + 32 pop_jump_if_false +2 (to 34) + 33 jump +27 (to 60) + + 88 34 load_var 7 (message) + 35 load_field 0 (role) + 36 load_const 8 ("assistant") + 37 cmp_op == + 38 pop_jump_if_false +2 (to 40) + 39 jump +4 (to 43) + + 91 40 load_const 9 ("user") + 41 store_var 9 (role) + + 88 42 jump +3 (to 45) + + 89 43 load_const 10 ("model") + 44 store_var 9 (role) + + 93 45 load_var 4 (first_role) + 46 load_const 11 ("") + 47 cmp_op == + 48 pop_jump_if_false +3 (to 51) + + 94 49 load_var 9 (role) + 50 store_var 4 (first_role) + + 99 51 load_var2 9 8 + 52 load_type 0 + 53 alloc_array 1 + 54 call 878 ntypeargs=0 (google.internal._gm_content) + 55 store_var 10 (_23) + 56 load_var2 3 10 + 57 call 4 ntypeargs=0 (baml.Array.push) + 58 pop 1 + 59 jump -45 (to 14) + + 85 60 load_var2 2 8 + 61 call 4 ntypeargs=0 (baml.Array.push) + 62 pop 1 + 63 jump -49 (to 14) + + 103 64 load_var2 2 3 + 65 load_var 4 (first_role) + 66 init_instance 0 (google.internal.GooglePrompt .system_parts, .contents, .first_role) + 67 return +} + +function google.internal.google_parse(resp: google.internal.GmResponse, seq: int) -> ai.ModelTurn { + 291 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (content) + + 292 3 load_const 1 (false) + 4 store_var 4 (has_call) + + 293 5 load_const 2 (0) + 6 store_var 5 (call_index) + + 294 7 load_var 1 (resp) + 8 load_field 0 (candidates) + 9 load_const 3 (null) + 10 cmp_op == + 11 pop_jump_if_false +2 (to 13) + 12 jump +8 (to 20) + 13 load_const 2 (0) + 14 load_var 1 (resp) + 15 load_field 0 (candidates) + 16 make_bound_method 3 + 17 call_indirect + 18 store_var 6 (cand) + 19 jump +3 (to 22) + 20 load_const 3 (null) + 21 store_var 6 (cand) + + 295 22 load_var 6 (cand) + 23 load_const 3 (null) + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +5 (to 31) + 27 load_var 6 (cand) + 28 load_field 1 (1) + 29 store_var 8 (_12) + 30 jump +3 (to 33) + 31 load_const 3 (null) + 32 store_var 8 (_12) + 33 load_var 8 (_12) + 34 store_var 7 (finish) + 35 load_var 8 (_12) + 36 load_const 3 (null) + 37 cmp_op == + 38 pop_jump_if_false +3 (to 41) + 39 load_const 4 ("") + 40 store_var 7 (finish) + + 296 41 load_var 6 (cand) + 42 load_const 3 (null) + 43 cmp_op == + 44 pop_jump_if_false +2 (to 46) + 45 jump +17 (to 62) + 46 load_var 6 (cand) + 47 load_field 0 (0) + 48 load_const 3 (null) + 49 cmp_op == + 50 pop_jump_if_false +2 (to 52) + 51 jump +11 (to 62) + 52 load_var 6 (cand) + 53 load_const 3 (null) + 54 cmp_op == + 55 pop_jump_if_false +2 (to 57) + 56 jump +6 (to 62) + 57 load_var 6 (cand) + 58 load_field 0 (0) + 59 load_field 0 (0) + 60 store_var 10 (_18) + 61 jump +3 (to 64) + 62 load_const 3 (null) + 63 store_var 10 (_18) + 64 load_var 10 (_18) + 65 store_var 9 (parts) + 66 load_var 10 (_18) + 67 load_const 3 (null) + 68 cmp_op == + 69 pop_jump_if_false +4 (to 73) + 70 load_type 5 + 71 alloc_array 0 + 72 store_var 9 (parts) + + 297 73 load_var 9 (parts) + 74 load_type 6 + 75 load_const 7 ("iter") + 76 virtual_call nargs=1 ntypeargs=0 + 77 store_var 11 (_30) + 78 load_var 11 (_30) + 79 load_type 8 + 80 load_const 9 ("next") + 81 virtual_call nargs=1 ntypeargs=0 + 82 store_var 12 (_31) + 83 load_var 12 (_31) + 84 is_type 10 + 85 pop_jump_if_false +2 (to 87) + 86 jump +86 (to 172) + 87 load_var 12 (_31) + 88 store_var_load_var 13 (p) + + 298 89 load_field 2 (functionCall) + 90 store_var 14 (_36) + 91 load_var 14 (_36) + 92 narrow_bind 11 14 + 93 pop_jump_if_false +2 (to 95) + 94 jump +33 (to 127) + + 310 95 load_var 13 (p) + 96 load_field 0 (text) + 97 store_var 21 (_55) + 98 load_var 21 (_55) + 99 narrow_bind 12 21 + 100 pop_jump_if_false -22 (to 78) + 101 load_var 21 (_55) + 102 store_var 22 (t) + + 311 103 load_var 13 (p) + 104 load_field 1 (thought) + 105 store_var 24 (_58) + 106 load_var 24 (_58) + 107 store_var 23 (_57) + 108 load_var 24 (_58) + 109 load_const 3 (null) + 110 cmp_op == + 111 pop_jump_if_false +3 (to 114) + 112 load_const 1 (false) + 113 store_var 23 (_57) + 114 load_var 23 (_57) + 115 pop_jump_if_false +2 (to 117) + 116 jump +6 (to 122) + + 315 117 load_var2 3 22 + 118 init_instance 0 (ai.content.Text .text) + 119 call 4 ntypeargs=0 (baml.Array.push) + 120 pop 1 + 121 jump -43 (to 78) + + 312 122 load_var2 3 22 + 123 init_instance 1 (ai.content.Reasoning .summary) + 124 call 4 ntypeargs=0 (baml.Array.push) + 125 pop 1 + 126 jump -48 (to 78) + + 298 127 load_var 14 (_36) + 128 store_var 15 (fc) + + 299 129 load_type 13 + 130 load_type 14 + 131 alloc_map 0 + 132 store_var 16 (args) + + 300 133 load_var 15 (fc) + 134 load_field 1 (args) + 135 store_var 17 (_40) + 136 load_var 17 (_40) + 137 narrow_bind 15 17 + 138 pop_jump_if_false +5 (to 143) + 139 load_var 17 (_40) + 140 store_var 18 (a) + + 301 141 load_var 18 (a) + 142 store_var 16 (args) + + 304 143 load_type 16 + 144 load_var 2 (seq) + 145 call 138 ntypeargs=1 (baml.String.from) + 146 store_var 19 (_47) + 147 load_type 16 + 148 load_var 5 (call_index) + 149 call 138 ntypeargs=1 (baml.String.from) + 150 store_var 20 (_49) + + 303 151 load_var 3 (content) + + 304 152 load_const 17 ("call_") + 153 load_var 19 (_47) + 154 bin_op + + 155 load_const 18 ("_") + 156 bin_op + + 157 load_var 20 (_49) + 158 bin_op + + 159 load_var 15 (fc) + 160 load_field 0 (name) + 161 load_var 16 (args) + 162 init_instance 2 (ai.content.ToolUse .id, .name, .args) + 163 call 4 ntypeargs=0 (baml.Array.push) + 164 pop 1 + + 306 165 load_var 5 (call_index) + 166 load_const 12 (1) + 167 add_int + 168 store_var 5 (call_index) + + 307 169 load_const 19 (true) + 170 store_var 4 (has_call) + + 298 171 jump -93 (to 78) + + 323 172 load_var 1 (resp) + 173 load_field 2 (promptFeedback) + 174 load_const 3 (null) + 175 cmp_op == + 176 pop_jump_if_false +2 (to 178) + 177 jump +5 (to 182) + 178 load_var 1 (resp) + 179 load_field 2 (promptFeedback) + 180 load_field 0 (0) + 181 jump +2 (to 183) + 182 load_const 3 (null) + 183 load_const 3 (null) + 184 call 635 ntypeargs=0 (baml.ops.equals_equals) + 185 unary_op ! + 186 store_var 25 (blocked) + + 324 187 load_var 4 (has_call) + 188 pop_jump_if_false +2 (to 190) + 189 jump +39 (to 228) + + 326 190 load_var 7 (finish) + 191 load_const 20 ("MAX_TOKENS") + 192 cmp_op == + 193 pop_jump_if_false +2 (to 195) + 194 jump +30 (to 224) + + 328 195 load_var 25 (blocked) + 196 jump_if_false +2 (to 198) + 197 jump +5 (to 202) + 198 pop 1 + 199 load_var 7 (finish) + 200 load_const 21 ("SAFETY") + 201 cmp_op == + 202 jump_if_false +2 (to 204) + 203 jump +5 (to 208) + 204 pop 1 + 205 load_var 7 (finish) + 206 load_const 22 ("RECITATION") + 207 cmp_op == + 208 jump_if_false +2 (to 210) + 209 jump +5 (to 214) + 210 pop 1 + 211 load_var 7 (finish) + 212 load_const 23 ("PROHIBITED_CONTENT") + 213 cmp_op == + 214 pop_jump_if_false +2 (to 216) + 215 jump +5 (to 220) + + 331 216 load_const 2 (ai.content.StopReason.Complete) + 217 alloc_variant 436 (ai.content.StopReason) + 218 store_var 26 (stop) + + 328 219 jump +12 (to 231) + + 329 220 load_const 24 (ai.content.StopReason.Refused) + 221 alloc_variant 436 (ai.content.StopReason) + 222 store_var 26 (stop) + + 328 223 jump +8 (to 231) + + 327 224 load_const 25 (ai.content.StopReason.MaxTokens) + 225 alloc_variant 436 (ai.content.StopReason) + 226 store_var 26 (stop) + + 326 227 jump +4 (to 231) + + 325 228 load_const 12 (ai.content.StopReason.ToolUse) + 229 alloc_variant 436 (ai.content.StopReason) + 230 store_var 26 (stop) + + 333 231 load_var 1 (resp) + 232 load_field 1 (usageMetadata) + 233 store_var 28 (_85) + 234 load_var 28 (_85) + 235 narrow_bind 26 28 + 236 pop_jump_if_false +2 (to 238) + 237 jump +4 (to 241) + + 341 238 load_const 3 (null) + 239 store_var 27 (usage) + + 333 240 jump +30 (to 270) + 241 load_var 28 (_85) + 242 store_var 29 (um) + + 335 243 load_var 29 (um) + 244 load_field 0 (promptTokenCount) + 245 store_var 31 (_88) + 246 load_var 31 (_88) + 247 store_var 30 (_87) + 248 load_var 31 (_88) + 249 load_const 3 (null) + 250 cmp_op == + 251 pop_jump_if_false +3 (to 254) + 252 load_const 2 (0) + 253 store_var 30 (_87) + + 336 254 load_var 29 (um) + 255 load_field 1 (candidatesTokenCount) + 256 store_var 33 (_91) + 257 load_var 33 (_91) + 258 store_var 32 (_90) + 259 load_var 33 (_91) + 260 load_const 3 (null) + 261 cmp_op == + 262 pop_jump_if_false +3 (to 265) + 263 load_const 2 (0) + 264 store_var 32 (_90) + + 334 265 load_var2 30 32 + 266 load_const 3 (null) + 267 load_const 3 (null) + 268 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 269 store_var 27 (usage) + + 343 270 load_var2 3 26 + 271 load_var 27 (usage) + 272 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 273 return +} + +function google.internal.google_render(c: google.GoogleClient, input: ai.ModelTurnInput) -> baml.http.Request { + 216 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 885 ntypeargs=0 (google.internal._google_request) + 3 return +} + +function google.internal.invoke(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 351 0 load_var 2 (input) + 1 load_field 1 (journal) + 2 call 783 ntypeargs=0 (ai.Journal.entries) + 3 container_len + 4 store_var 3 (seq) + + 352 5 load_var2 1 2 + 6 call 884 ntypeargs=0 (google.internal.google_render) + 7 store_var 4 (req) + + 353 8 load_type 0 + 9 load_var 4 (req) + 10 load_const 1 ("google") + 11 call 804 ntypeargs=1 (ai.wire.send_as) + + 354 12 load_var 3 (seq) + 13 call 886 ntypeargs=0 (google.internal.google_parse) + 14 return +} + +function google.internal.invoke_stream(c: google.GoogleClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 432 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 885 ntypeargs=0 (google.internal._google_request) + + 433 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 437 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 435 15 load_const 3 ("google") + + 437 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 442 22 load_const 6 (google.internal._google_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function openai.OpenAiClient.ai.Client.id(self: openai.OpenAiClient) -> string { + 58 0 load_type 0 + 1 load_var 1 (self) + 2 load_field 0 (model) + 3 call 138 ntypeargs=1 (baml.String.from) + 4 store_var 3 (_2) + 5 load_const 1 ("openai/") + 6 load_var 3 (_2) + 7 bin_op + + 8 store_var 2 (_0) + 9 load_var 2 (_0) + 10 return +} + +function openai.OpenAiClient.ai.Client.invoke(self: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 62 0 load_var2 1 2 + 1 call 857 ntypeargs=0 (openai.internal.invoke) + 2 jump +6 (to 8) + 3 load_var 3 (e) + 4 throw_if_panic + + 63 5 load_var 3 (e) + 6 call 834 ntypeargs=0 (ai.errors.normalize) + 7 throw + 8 return +} + +function openai.OpenAiClient.ai.stream.StreamingClient.invoke_stream(self: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 70 0 load_var2 1 2 + 1 call 859 ntypeargs=0 (openai.internal.invoke_stream) + 2 return +} + +function openai.OpenAiClient.new(model: string, api_key: string | null, base_url: string | null, api_key_env: string | null, base_url_env: string | null) -> openai.OpenAiClient { + 0 load_var 1 (model) + 1 load_const 0 () + 2 cmp_op == + 3 pop_jump_if_false +3 (to 6) + + 16 4 load_const 1 ("gpt-4o-mini") + 5 store_var 1 (model) + 6 load_var 2 (api_key) + 7 load_const 0 () + 8 cmp_op == + 9 pop_jump_if_false +3 (to 12) + + 17 10 load_const 2 (null) + 11 store_var 2 (api_key) + 12 load_var 3 (base_url) + 13 load_const 0 () + 14 cmp_op == + 15 pop_jump_if_false +3 (to 18) + + 18 16 load_const 2 (null) + 17 store_var 3 (base_url) + 18 load_var 4 (api_key_env) + 19 load_const 0 () + 20 cmp_op == + 21 pop_jump_if_false +3 (to 24) + + 19 22 load_const 2 (null) + 23 store_var 4 (api_key_env) + 24 load_var 5 (base_url_env) + 25 load_const 0 () + 26 cmp_op == + 27 pop_jump_if_false +3 (to 30) + + 20 28 load_const 2 (null) + 29 store_var 5 (base_url_env) + + 22 30 load_var2 1 2 + 31 load_var2 3 4 + 32 load_var 5 (base_url_env) + 33 init_instance 0 (openai.OpenAiClient .model, .api_key, .base_url, .api_key_env, .base_url_env) + 34 return +} + +function openai.OpenAiClient.resolved_api_key(self: openai.OpenAiClient) -> string { + 34 0 load_var 1 (self) + 1 load_field 1 (api_key) + 2 store_var 2 (_3) + 3 load_var 2 (_3) + 4 narrow_bind 0 2 + 5 pop_jump_if_false +2 (to 7) + 6 jump +22 (to 28) + + 37 7 load_var 1 (self) + 8 load_field 3 (api_key_env) + 9 store_var 4 (_6) + 10 load_var 4 (_6) + 11 narrow_bind 0 4 + 12 pop_jump_if_false +9 (to 21) + 13 load_var 4 (_6) + 14 store_var_load_var 5 (name) + + 38 15 sys_op 210 (baml.env.get) + 16 store_var 6 (_10) + 17 load_var 6 (_10) + 18 narrow_bind 0 6 + 19 pop_jump_if_false +2 (to 21) + 20 jump +4 (to 24) + + 42 21 load_const 1 ("OPENAI_API_KEY") + 22 call 211 ntypeargs=0 (baml.env.get_or_panic) + 23 jump +8 (to 31) + + 38 24 load_var 6 (_10) + 25 store_var 7 (v) + + 39 26 load_var 7 (v) + 27 jump +4 (to 31) + + 34 28 load_var 2 (_3) + 29 store_var 3 (k) + + 35 30 load_var 3 (k) + 31 return +} + +function openai.OpenAiClient.resolved_base_url(self: openai.OpenAiClient) -> string | null { + 47 0 load_var 1 (self) + 1 load_field 2 (base_url) + 2 store_var 2 (_3) + 3 load_var 2 (_3) + 4 narrow_bind 0 2 + 5 pop_jump_if_false +2 (to 7) + 6 jump +14 (to 20) + + 50 7 load_var 1 (self) + 8 load_field 4 (base_url_env) + 9 store_var 4 (_6) + 10 load_var 4 (_6) + 11 narrow_bind 0 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +3 (to 16) + + 53 14 load_const 1 (null) + 15 jump +8 (to 23) + + 50 16 load_var 4 (_6) + 17 store_var_load_var 5 (name) + + 51 18 sys_op 210 (baml.env.get) + 19 jump +4 (to 23) + + 47 20 load_var 2 (_3) + 21 store_var 3 (u) + + 48 22 load_var 3 (u) + 23 return +} + +function openai.internal._openai_decode_batch(batch: string) -> (ai.stream.TextDelta | ai.stream.TurnMeta | ai.stream.TurnDone)[] { + 254 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 255 3 load_var 1 (batch) + 4 call 825 ntypeargs=0 (ai.stream.decode_sse_batch) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +126 (to 143) + 18 load_var 5 (_5) + 19 store_var_load_var 6 (raw) + + 256 20 load_field 1 (data) + 21 store_var 7 (_10) + 22 load_var 7 (_10) + 23 narrow_bind 6 7 + 24 pop_jump_if_false -15 (to 9) + 25 load_var 7 (_10) + 26 store_var 8 (data) + + 257 27 load_type 7 + 28 load_var 8 (data) + 29 call 335 ntypeargs=1 (baml.json.from_string) + 30 jump +4 (to 34) + 31 load_var 9 (e) + 32 throw_if_panic + + 258 33 load_const 8 (null) + + 260 34 store_var 10 (_16) + 35 load_var 10 (_16) + 36 narrow_bind 9 10 + 37 pop_jump_if_false -28 (to 9) + 38 load_var 10 (_16) + 39 store_var 11 (event) + + 261 40 load_var 11 (event) + 41 load_field 0 (type) + 42 store_var 14 (_20) + 43 load_var 14 (_20) + 44 store_var 13 (_19) + 45 load_var 14 (_20) + 46 load_const 8 (null) + 47 cmp_op == + 48 pop_jump_if_false +4 (to 52) + 49 load_var 6 (raw) + 50 load_field 0 (event) + 51 store_var 13 (_19) + 52 load_var 13 (_19) + 53 store_var 12 (t) + 54 load_var 13 (_19) + 55 load_const 8 (null) + 56 cmp_op == + 57 pop_jump_if_false +3 (to 60) + 58 load_const 10 ("") + 59 store_var 12 (t) + + 262 60 load_var 12 (t) + 61 load_const 11 ("response.output_text.delta") + 62 cmp_op == + 63 pop_jump_if_false +2 (to 65) + 64 jump +66 (to 130) + + 270 65 load_var 12 (t) + 66 load_const 12 ("response.completed") + 67 cmp_op == + 68 jump_if_false +2 (to 70) + 69 jump +5 (to 74) + 70 pop 1 + 71 load_var 12 (t) + 72 load_const 13 ("response.incomplete") + 73 cmp_op == + 74 jump_if_false +2 (to 76) + 75 jump +5 (to 80) + 76 pop 1 + 77 load_var 12 (t) + 78 load_const 14 ("response.failed") + 79 cmp_op == + 80 pop_jump_if_false -71 (to 9) + + 271 81 load_var 11 (event) + 82 load_field 2 (response) + 83 store_var 17 (_38) + 84 load_var 17 (_38) + 85 narrow_bind 15 17 + 86 pop_jump_if_false +39 (to 125) + 87 load_var 17 (_38) + 88 store_var_load_var 18 (r) + + 272 89 call 856 ntypeargs=0 (openai.internal.openai_parse) + 90 store_var 19 (turn) + + 275 91 load_var 19 (turn) + 92 load_field 1 (stop_reason) + 93 store_var 20 (_44) + + 276 94 load_var 19 (turn) + 95 load_field 2 (usage) + 96 load_const 8 (null) + 97 cmp_op == + 98 pop_jump_if_false +2 (to 100) + 99 jump +6 (to 105) + 100 load_var 19 (turn) + 101 load_field 2 (usage) + 102 load_field 0 (0) + 103 store_var 21 (_45) + 104 jump +3 (to 107) + 105 load_const 8 (null) + 106 store_var 21 (_45) + + 277 107 load_var 19 (turn) + 108 load_field 2 (usage) + 109 load_const 8 (null) + 110 cmp_op == + 111 pop_jump_if_false +2 (to 113) + 112 jump +6 (to 118) + 113 load_var 19 (turn) + 114 load_field 2 (usage) + 115 load_field 1 (1) + 116 store_var 22 (_49) + 117 jump +3 (to 120) + 118 load_const 8 (null) + 119 store_var 22 (_49) + + 273 120 load_var2 3 20 + + 274 121 load_var2 21 22 + 122 init_instance 0 (ai.stream.TurnMeta .stop_reason, .input_tokens, .output_tokens) + 123 call 4 ntypeargs=0 (baml.Array.push) + 124 pop 1 + + 284 125 load_var 3 (out) + 126 alloc_instance 358 ntypeargs=0 (ai.stream.TurnDone) + 127 call 4 ntypeargs=0 (baml.Array.push) + 128 pop 1 + 129 jump -120 (to 9) + + 263 130 load_var 11 (event) + 131 load_field 1 (delta) + 132 store_var 15 (_26) + 133 load_var 15 (_26) + 134 narrow_bind 6 15 + 135 pop_jump_if_false -126 (to 9) + 136 load_var 15 (_26) + 137 store_var 16 (d) + + 264 138 load_var2 3 16 + 139 init_instance 1 (ai.stream.TextDelta .text) + 140 call 4 ntypeargs=0 (baml.Array.push) + 141 pop 1 + 142 jump -133 (to 9) + + 298 143 load_var 3 (out) + 144 store_var 2 (_0) + 145 load_var 2 (_0) + 146 return +} + +function openai.internal._openai_request(c: openai.OpenAiClient, input: ai.ModelTurnInput, stream: bool) -> baml.http.Request { + 128 0 load_var 2 (input) + 1 load_field 0 (prompt) + 2 store_var 5 (_5) + 3 load_var 2 (input) + 4 load_field 3 (output_type) + 5 call 805 ntypeargs=0 (ai.wire.render_output_format) + 6 load_var 5 (_5) + 7 call_indirect + + 129 8 call 852 ntypeargs=0 (openai.internal.openai_lower_prompt) + 9 store_var 6 (items) + + 130 10 load_var 2 (input) + 11 load_field 1 (journal) + 12 call 853 ntypeargs=0 (openai.internal.openai_lower_journal) + 13 load_type 0 + 14 load_const 1 ("iter") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 7 (_12) + 17 load_var 7 (_12) + 18 load_type 2 + 19 load_const 3 ("next") + 20 virtual_call nargs=1 ntypeargs=0 + 21 store_var 8 (_13) + 22 load_var 8 (_13) + 23 is_type 4 + 24 pop_jump_if_false +2 (to 26) + 25 jump +7 (to 32) + 26 load_var 8 (_13) + 27 store_var 9 (item) + + 131 28 load_var2 6 9 + 29 call 4 ntypeargs=0 (baml.Array.push) + 30 pop 1 + 31 jump -14 (to 17) + + 133 32 load_type 5 + 33 load_type 6 + 34 alloc_map 0 + 35 store_var 10 (body) + + 134 36 load_type 5 + 37 load_type 6 + 38 load_var 10 (body) + 39 load_const 7 ("model") + 40 load_var 1 (c) + 41 load_field 0 (model) + 42 call 37 ntypeargs=2 (baml.Map.set) + 43 pop 1 + + 135 44 load_type 5 + 45 load_type 6 + 46 load_var 10 (body) + 47 load_const 8 ("store") + 48 load_const 9 (false) + 49 call 37 ntypeargs=2 (baml.Map.set) + 50 pop 1 + + 136 51 load_type 5 + 52 load_type 6 + 53 load_var 10 (body) + 54 load_const 10 ("input") + 55 load_var 6 (items) + 56 call 37 ntypeargs=2 (baml.Map.set) + 57 pop 1 + + 137 58 load_var 2 (input) + 59 load_field 2 (toolbox) + 60 call 801 ntypeargs=0 (ai.tools.Toolbox.is_empty) + 61 unary_op ! + 62 pop_jump_if_false +82 (to 144) + + 138 63 load_type 11 + 64 alloc_array 0 + 65 store_var 11 (tools) + + 139 66 load_var 2 (input) + 67 load_field 2 (toolbox) + 68 call 799 ntypeargs=0 (ai.tools.Toolbox.list) + 69 load_type 12 + 70 load_const 13 ("iter") + 71 virtual_call nargs=1 ntypeargs=0 + 72 store_var 12 (_37) + 73 load_var 12 (_37) + 74 load_type 14 + 75 load_const 15 ("next") + 76 virtual_call nargs=1 ntypeargs=0 + 77 store_var 13 (_38) + 78 load_var 13 (_38) + 79 is_type 4 + 80 pop_jump_if_false +2 (to 82) + 81 jump +49 (to 130) + 82 load_var 13 (_38) + 83 store_var 14 (t) + + 140 84 load_type 5 + 85 load_type 6 + 86 alloc_map 0 + 87 store_var 15 (entry) + + 141 88 load_type 5 + 89 load_type 6 + 90 load_var 15 (entry) + 91 load_const 16 ("type") + 92 load_const 17 ("function") + 93 call 37 ntypeargs=2 (baml.Map.set) + 94 pop 1 + + 142 95 load_type 5 + 96 load_type 6 + 97 load_var 15 (entry) + 98 load_const 18 ("name") + 99 load_var 14 (t) + 100 load_field 0 (name) + 101 call 37 ntypeargs=2 (baml.Map.set) + 102 pop 1 + + 143 103 load_type 5 + 104 load_type 6 + 105 load_var 15 (entry) + 106 load_const 19 ("description") + 107 load_var 14 (t) + 108 load_field 1 (description) + 109 call 37 ntypeargs=2 (baml.Map.set) + 110 pop 1 + + 144 111 load_type 5 + 112 load_type 6 + 113 load_var 15 (entry) + 114 load_const 20 ("parameters") + 115 load_var 14 (t) + 116 load_field 2 (input_schema) + 117 call 37 ntypeargs=2 (baml.Map.set) + 118 pop 1 + + 145 119 load_type 5 + 120 load_type 6 + 121 load_var 15 (entry) + 122 load_const 21 ("strict") + 123 load_const 9 (false) + 124 call 37 ntypeargs=2 (baml.Map.set) + 125 pop 1 + + 146 126 load_var2 11 15 + 127 call 4 ntypeargs=0 (baml.Array.push) + 128 pop 1 + 129 jump -56 (to 73) + + 148 130 load_type 5 + 131 load_type 6 + 132 load_var 10 (body) + 133 load_const 22 ("tools") + 134 load_var 11 (tools) + 135 call 37 ntypeargs=2 (baml.Map.set) + 136 pop 1 + + 149 137 load_type 5 + 138 load_type 6 + 139 load_var 10 (body) + 140 load_const 23 ("tool_choice") + 141 load_const 24 ("auto") + 142 call 37 ntypeargs=2 (baml.Map.set) + 143 pop 1 + + 154 144 load_var 3 (stream) + 145 pop_jump_if_false +8 (to 153) + + 155 146 load_type 5 + 147 load_type 6 + 148 load_var 10 (body) + 149 load_const 25 ("stream") + 150 load_const 26 (true) + 151 call 37 ntypeargs=2 (baml.Map.set) + 152 pop 1 + + 162 153 load_var 1 (c) + 154 call 848 ntypeargs=0 (openai.OpenAiClient.resolved_base_url) + 155 store_var 18 (_76) + 156 load_var 18 (_76) + 157 store_var 17 (_75) + 158 load_var 18 (_76) + 159 load_const 27 (null) + 160 cmp_op == + 161 pop_jump_if_false +3 (to 164) + 162 load_const 28 ("https://api.openai.com/v1") + 163 store_var 17 (_75) + 164 load_type 5 + 165 load_var 17 (_75) + 166 call 138 ntypeargs=1 (baml.String.from) + 167 store_var 16 (_74) + + 163 168 load_var 1 (c) + 169 call 847 ntypeargs=0 (openai.OpenAiClient.resolved_api_key) + 170 store_var 20 (_82) + 171 load_type 5 + 172 load_var 20 (_82) + 173 call 138 ntypeargs=1 (baml.String.from) + 174 store_var 19 (_81) + + 164 175 load_type 11 + 176 load_var 10 (body) + 177 call 333 ntypeargs=1 (baml.json.to_json) + 178 call 330 ntypeargs=0 (baml.json.stringify) + 179 store_var 21 (_84) + + 160 180 load_const 29 ("POST") + + 162 181 load_var 16 (_74) + 182 load_const 30 ("/responses") + 183 bin_op + + + 163 184 load_const 31 ("Bearer ") + 185 load_var 19 (_81) + 186 bin_op + + 187 load_const 32 ("application/json") + 188 load_const 33 ("authorization") + 189 load_const 34 ("content-type") + 190 load_type 5 + 191 load_type 5 + 192 alloc_map 2 + 193 load_var 21 (_84) + 194 init_instance 0 (baml.http.Request .method, .url, .headers, .body) + 195 store_var 4 (_0) + 196 load_var 4 (_0) + 197 return +} + +function openai.internal.invoke(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.ModelTurn { + 231 0 load_var2 1 2 + 1 call 854 ntypeargs=0 (openai.internal.openai_render) + 2 store_var 3 (req) + + 232 3 load_type 0 + 4 load_var 3 (req) + 5 load_const 1 ("openai") + 6 call 804 ntypeargs=1 (ai.wire.send_as) + + 233 7 call 856 ntypeargs=0 (openai.internal.openai_parse) + 8 return +} + +function openai.internal.invoke_stream(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> ai.stream.TurnStream { + 304 0 load_var2 1 2 + 1 load_const 0 (true) + 2 call 855 ntypeargs=0 (openai.internal._openai_request) + + 305 3 sys_op 235 (baml.http.fetch_sse) + 4 jump +18 (to 22) + 5 load_var 3 (e) + 6 throw_if_panic + + 309 7 load_type 1 + 8 load_var 3 (e) + 9 call 138 ntypeargs=1 (baml.String.from) + 10 store_var 5 (_10) + 11 load_type 2 + 12 load_var 5 (_10) + 13 call 138 ntypeargs=1 (baml.String.from) + 14 store_var 4 (_9) + + 307 15 load_const 3 ("openai") + + 309 16 load_const 4 ("transport failed before a response arrived: ") + 17 load_var 4 (_9) + 18 bin_op + + 19 load_const 5 (null) + 20 init_instance 0 (ai.errors.NetworkFailure .provider, .detail, .raw_body) + 21 throw + + 314 22 load_const 6 (openai.internal._openai_decode_batch) + 23 call 826 ntypeargs=0 (ai.stream.TurnStream.from_sse) + 24 return +} + +function openai.internal.openai_lower_journal(j: ai.Journal) -> map[] { + 57 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (items) + + 58 3 load_var 1 (j) + 4 call 783 ntypeargs=0 (ai.Journal.entries) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +233 (to 250) + 18 load_var 5 (_5) + 19 store_var 6 (e) + + 59 20 load_var 6 (e) + 21 store_var 7 (_9) + 22 load_var 7 (_9) + 23 narrow_bind 6 7 + 24 pop_jump_if_false +2 (to 26) + 25 jump +200 (to 225) + 26 load_var 6 (e) + 27 store_var 10 (_21) + 28 load_var 10 (_21) + 29 narrow_bind 7 10 + 30 pop_jump_if_false +2 (to 32) + 31 jump +94 (to 125) + 32 load_var 6 (e) + 33 store_var 22 (_64) + 34 load_var 22 (_64) + 35 narrow_bind 8 22 + 36 pop_jump_if_false +2 (to 38) + 37 jump +55 (to 92) + 38 load_var 6 (e) + 39 store_var 25 (_80) + 40 load_var 25 (_80) + 41 narrow_bind 9 25 + 42 pop_jump_if_false -33 (to 9) + 43 load_var 25 (_80) + 44 store_var 26 (f) + + 101 45 load_type 10 + 46 load_type 11 + 47 alloc_map 0 + 48 store_var 27 (err) + + 102 49 load_type 10 + 50 load_type 11 + 51 load_var 27 (err) + 52 load_const 12 ("error") + 53 load_var 26 (f) + 54 load_field 1 (message) + 55 call 37 ntypeargs=2 (baml.Map.set) + 56 pop 1 + + 103 57 load_type 10 + 58 load_type 11 + 59 alloc_map 0 + 60 store_var 28 (m) + + 104 61 load_type 10 + 62 load_type 11 + 63 load_var 28 (m) + 64 load_const 13 ("type") + 65 load_const 14 ("function_call_output") + 66 call 37 ntypeargs=2 (baml.Map.set) + 67 pop 1 + + 105 68 load_type 10 + 69 load_type 11 + 70 load_var 28 (m) + 71 load_const 15 ("call_id") + 72 load_var 26 (f) + 73 load_field 0 (id) + 74 call 37 ntypeargs=2 (baml.Map.set) + 75 pop 1 + + 106 76 load_type 0 + 77 load_var 27 (err) + 78 call 333 ntypeargs=1 (baml.json.to_json) + 79 call 330 ntypeargs=0 (baml.json.stringify) + 80 store_var 29 (_96) + 81 load_type 10 + 82 load_type 11 + 83 load_var 28 (m) + 84 load_const 16 ("output") + 85 load_var 29 (_96) + 86 call 37 ntypeargs=2 (baml.Map.set) + 87 pop 1 + + 107 88 load_var2 3 28 + 89 call 4 ntypeargs=0 (baml.Array.push) + 90 pop 1 + 91 jump -82 (to 9) + + 59 92 load_var 22 (_64) + 93 store_var 23 (c) + + 93 94 load_type 10 + 95 load_type 11 + 96 alloc_map 0 + 97 store_var 24 (m) + + 94 98 load_type 10 + 99 load_type 11 + 100 load_var 24 (m) + 101 load_const 17 ("type") + 102 load_const 18 ("function_call_output") + 103 call 37 ntypeargs=2 (baml.Map.set) + 104 pop 1 + + 95 105 load_type 10 + 106 load_type 11 + 107 load_var 24 (m) + 108 load_const 19 ("call_id") + 109 load_var 23 (c) + 110 load_field 0 (id) + 111 call 37 ntypeargs=2 (baml.Map.set) + 112 pop 1 + + 96 113 load_type 10 + 114 load_type 11 + 115 load_var 24 (m) + 116 load_const 20 ("output") + 117 load_var 23 (c) + 118 load_field 1 (output) + 119 call 37 ntypeargs=2 (baml.Map.set) + 120 pop 1 + + 97 121 load_var2 3 24 + 122 call 4 ntypeargs=0 (baml.Array.push) + 123 pop 1 + 124 jump -115 (to 9) + + 59 125 load_var 10 (_21) + 126 store_var_load_var 11 (a) + + 68 127 load_field 0 (content) + 128 load_type 21 + 129 load_const 22 ("iter") + 130 virtual_call nargs=1 ntypeargs=0 + 131 store_var 12 (_24) + 132 load_var 12 (_24) + 133 load_type 23 + 134 load_const 24 ("next") + 135 virtual_call nargs=1 ntypeargs=0 + 136 store_var 13 (_25) + 137 load_var 13 (_25) + 138 is_type 5 + 139 pop_jump_if_false +2 (to 141) + 140 jump -131 (to 9) + 141 load_var 13 (_25) + 142 store_var 14 (b) + + 69 143 load_var 14 (b) + 144 store_var 15 (_29) + 145 load_var 15 (_29) + 146 narrow_bind 25 15 + 147 pop_jump_if_false +2 (to 149) + 148 jump +52 (to 200) + 149 load_var 14 (b) + 150 store_var 18 (_41) + 151 load_var 18 (_41) + 152 narrow_bind 26 18 + 153 pop_jump_if_false -21 (to 132) + 154 load_var 18 (_41) + 155 store_var 19 (use) + + 78 156 load_type 10 + 157 load_type 11 + 158 alloc_map 0 + 159 store_var 20 (m) + + 79 160 load_type 10 + 161 load_type 11 + 162 load_var 20 (m) + 163 load_const 27 ("type") + 164 load_const 28 ("function_call") + 165 call 37 ntypeargs=2 (baml.Map.set) + 166 pop 1 + + 80 167 load_type 10 + 168 load_type 11 + 169 load_var 20 (m) + 170 load_const 29 ("call_id") + 171 load_var 19 (use) + 172 load_field 0 (id) + 173 call 37 ntypeargs=2 (baml.Map.set) + 174 pop 1 + + 81 175 load_type 10 + 176 load_type 11 + 177 load_var 20 (m) + 178 load_const 30 ("name") + 179 load_var 19 (use) + 180 load_field 1 (name) + 181 call 37 ntypeargs=2 (baml.Map.set) + 182 pop 1 + + 82 183 load_type 0 + 184 load_var 19 (use) + 185 load_field 2 (args) + 186 call 333 ntypeargs=1 (baml.json.to_json) + 187 call 330 ntypeargs=0 (baml.json.stringify) + 188 store_var 21 (_56) + 189 load_type 10 + 190 load_type 11 + 191 load_var 20 (m) + 192 load_const 31 ("arguments") + 193 load_var 21 (_56) + 194 call 37 ntypeargs=2 (baml.Map.set) + 195 pop 1 + + 83 196 load_var2 3 20 + 197 call 4 ntypeargs=0 (baml.Array.push) + 198 pop 1 + 199 jump -67 (to 132) + + 69 200 load_var 15 (_29) + 201 store_var 16 (t) + + 71 202 load_type 10 + 203 load_type 11 + 204 alloc_map 0 + 205 store_var 17 (m) + + 72 206 load_type 10 + 207 load_type 11 + 208 load_var 17 (m) + 209 load_const 32 ("role") + 210 load_const 33 ("assistant") + 211 call 37 ntypeargs=2 (baml.Map.set) + 212 pop 1 + + 73 213 load_type 10 + 214 load_type 11 + 215 load_var 17 (m) + 216 load_const 34 ("content") + 217 load_var 16 (t) + 218 load_field 0 (text) + 219 call 37 ntypeargs=2 (baml.Map.set) + 220 pop 1 + + 74 221 load_var2 3 17 + 222 call 4 ntypeargs=0 (baml.Array.push) + 223 pop 1 + 224 jump -92 (to 132) + + 59 225 load_var 7 (_9) + 226 store_var 8 (u) + + 61 227 load_type 10 + 228 load_type 11 + 229 alloc_map 0 + 230 store_var 9 (m) + + 62 231 load_type 10 + 232 load_type 11 + 233 load_var 9 (m) + 234 load_const 35 ("role") + 235 load_const 36 ("user") + 236 call 37 ntypeargs=2 (baml.Map.set) + 237 pop 1 + + 63 238 load_type 10 + 239 load_type 11 + 240 load_var 9 (m) + 241 load_const 37 ("content") + 242 load_var 8 (u) + 243 load_field 0 (content) + 244 call 37 ntypeargs=2 (baml.Map.set) + 245 pop 1 + + 64 246 load_var2 3 9 + 247 call 4 ntypeargs=0 (baml.Array.push) + 248 pop 1 + 249 jump -240 (to 9) + + 113 250 load_var 3 (items) + 251 store_var 2 (_0) + 252 load_var 2 (_0) + 253 return +} + +function openai.internal.openai_lower_prompt(prompt: ai.Prompt) -> map[] { + 37 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (items) + + 38 3 load_var 1 (prompt) + 4 call 787 ntypeargs=0 (ai.Prompt.messages) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +46 (to 63) + 18 load_var 5 (_5) + 19 store_var_load_var 6 (message) + + 39 20 load_field 0 (role) + 21 load_const 6 ("") + 22 cmp_op == + 23 pop_jump_if_false +2 (to 25) + 24 jump +14 (to 38) + + 41 25 load_var 6 (message) + 26 load_field 0 (role) + 27 load_const 7 ("tool") + 28 cmp_op == + 29 pop_jump_if_false +2 (to 31) + 30 jump +5 (to 35) + + 44 31 load_var 6 (message) + 32 load_field 0 (role) + 33 store_var 7 (role) + + 41 34 jump +6 (to 40) + + 42 35 load_const 8 ("user") + 36 store_var 7 (role) + + 41 37 jump +3 (to 40) + + 40 38 load_const 9 ("user") + 39 store_var 7 (role) + + 46 40 load_type 10 + 41 load_type 11 + 42 alloc_map 0 + 43 store_var 8 (item) + + 47 44 load_type 10 + 45 load_type 11 + 46 load_var 8 (item) + 47 load_const 12 ("role") + 48 load_var 7 (role) + 49 call 37 ntypeargs=2 (baml.Map.set) + 50 pop 1 + + 48 51 load_type 10 + 52 load_type 11 + 53 load_var 8 (item) + 54 load_const 13 ("content") + 55 load_var 6 (message) + 56 load_field 1 (content) + 57 call 37 ntypeargs=2 (baml.Map.set) + 58 pop 1 + + 49 59 load_var2 3 8 + 60 call 4 ntypeargs=0 (baml.Array.push) + 61 pop 1 + 62 jump -53 (to 9) + + 51 63 load_var 3 (items) + 64 store_var 2 (_0) + 65 load_var 2 (_0) + 66 return +} + +function openai.internal.openai_parse(resp: openai.internal.OaResponse) -> ai.ModelTurn { + 170 0 load_type 0 + 1 alloc_array 0 + 2 store_var 2 (content) + + 171 3 load_const 1 (false) + 4 store_var 3 (has_call) + + 172 5 load_var 1 (resp) + 6 load_field 1 (output) + 7 load_type 2 + 8 load_const 3 ("iter") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 4 (_5) + 11 load_var 4 (_5) + 12 load_type 4 + 13 load_const 5 ("next") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 5 (_6) + 16 load_var 5 (_6) + 17 is_type 6 + 18 pop_jump_if_false +2 (to 20) + 19 jump +164 (to 183) + 20 load_var 5 (_6) + 21 store_var_load_var 6 (item) + + 173 22 load_field 0 (type) + 23 load_const 7 ("function_call") + 24 cmp_op == + 25 pop_jump_if_false +2 (to 27) + 26 jump +111 (to 137) + + 183 27 load_var 6 (item) + 28 load_field 0 (type) + 29 load_const 8 ("message") + 30 cmp_op == + 31 pop_jump_if_false +2 (to 33) + 32 jump +46 (to 78) + + 194 33 load_var 6 (item) + 34 load_field 0 (type) + 35 load_const 9 ("reasoning") + 36 cmp_op == + 37 pop_jump_if_false -26 (to 11) + + 195 38 load_var 6 (item) + 39 load_field 5 (summary) + 40 store_var 24 (_50) + 41 load_var 24 (_50) + 42 store_var 23 (parts) + 43 load_var 24 (_50) + 44 load_const 10 (null) + 45 cmp_op == + 46 pop_jump_if_false +4 (to 50) + 47 load_type 11 + 48 alloc_array 0 + 49 store_var 23 (parts) + + 196 50 load_var 23 (parts) + 51 load_type 12 + 52 load_const 13 ("iter") + 53 virtual_call nargs=1 ntypeargs=0 + 54 store_var 25 (_53) + 55 load_var 25 (_53) + 56 load_type 14 + 57 load_const 15 ("next") + 58 virtual_call nargs=1 ntypeargs=0 + 59 store_var 26 (_54) + 60 load_var 26 (_54) + 61 is_type 6 + 62 pop_jump_if_false +2 (to 64) + 63 jump -52 (to 11) + 64 load_var 26 (_54) + 65 store_var_load_var 27 (part) + + 197 66 load_field 1 (text) + 67 store_var 28 (_59) + 68 load_var 28 (_59) + 69 narrow_bind 16 28 + 70 pop_jump_if_false -15 (to 55) + 71 load_var 28 (_59) + 72 store_var 29 (txt) + + 198 73 load_var2 2 29 + 74 init_instance 0 (ai.content.Reasoning .summary) + 75 call 4 ntypeargs=0 (baml.Array.push) + 76 pop 1 + 77 jump -22 (to 55) + + 184 78 load_var 6 (item) + 79 load_field 4 (content) + 80 store_var 15 (_30) + 81 load_var 15 (_30) + 82 store_var 14 (parts) + 83 load_var 15 (_30) + 84 load_const 10 (null) + 85 cmp_op == + 86 pop_jump_if_false +4 (to 90) + 87 load_type 11 + 88 alloc_array 0 + 89 store_var 14 (parts) + + 185 90 load_var 14 (parts) + 91 load_type 12 + 92 load_const 17 ("iter") + 93 virtual_call nargs=1 ntypeargs=0 + 94 store_var 16 (_33) + 95 load_var 16 (_33) + 96 load_type 14 + 97 load_const 18 ("next") + 98 virtual_call nargs=1 ntypeargs=0 + 99 store_var 17 (_34) + 100 load_var 17 (_34) + 101 is_type 6 + 102 pop_jump_if_false +2 (to 104) + 103 jump -92 (to 11) + 104 load_var 17 (_34) + 105 store_var 18 (part) + + 186 106 load_var 18 (part) + 107 load_field 0 (type) + 108 store_var 20 (_40) + 109 load_var 20 (_40) + 110 store_var 19 (_39) + 111 load_var 20 (_40) + 112 load_const 10 (null) + 113 cmp_op == + 114 pop_jump_if_false +3 (to 117) + 115 load_const 19 ("") + 116 store_var 19 (_39) + 117 load_var 19 (_39) + 118 load_const 20 ("output_text") + 119 cmp_op == + 120 pop_jump_if_false -25 (to 95) + + 187 121 load_var 18 (part) + 122 load_field 1 (text) + 123 store_var 22 (_45) + 124 load_var 22 (_45) + 125 store_var 21 (_44) + 126 load_var 22 (_45) + 127 load_const 10 (null) + 128 cmp_op == + 129 pop_jump_if_false +3 (to 132) + 130 load_const 21 ("") + 131 store_var 21 (_44) + 132 load_var2 2 21 + 133 init_instance 1 (ai.content.Text .text) + 134 call 4 ntypeargs=0 (baml.Array.push) + 135 pop 1 + 136 jump -41 (to 95) + + 174 137 load_const 22 (true) + 138 store_var 3 (has_call) + + 175 139 load_type 23 + 140 load_type 24 + 141 alloc_map 0 + 142 store_var 7 (args) + + 176 143 load_var 6 (item) + 144 load_field 3 (arguments) + 145 store_var 8 (_14) + 146 load_var 8 (_14) + 147 narrow_bind 16 8 + 148 pop_jump_if_false +7 (to 155) + 149 load_var 8 (_14) + 150 store_var 9 (s) + + 177 151 load_type 25 + 152 load_var 9 (s) + 153 call 335 ntypeargs=1 (baml.json.from_string) + 154 store_var 7 (args) + + 180 155 load_var 6 (item) + 156 load_field 1 (call_id) + 157 store_var 11 (_21) + 158 load_var 11 (_21) + 159 store_var 10 (_20) + 160 load_var 11 (_21) + 161 load_const 10 (null) + 162 cmp_op == + 163 pop_jump_if_false +3 (to 166) + 164 load_const 26 ("") + 165 store_var 10 (_20) + 166 load_var 6 (item) + 167 load_field 2 (name) + 168 store_var 13 (_24) + 169 load_var 13 (_24) + 170 store_var 12 (_23) + 171 load_var 13 (_24) + 172 load_const 10 (null) + 173 cmp_op == + 174 pop_jump_if_false +3 (to 177) + 175 load_const 27 ("") + 176 store_var 12 (_23) + + 179 177 load_var2 2 10 + + 180 178 load_var2 12 7 + 179 init_instance 2 (ai.content.ToolUse .id, .name, .args) + 180 call 4 ntypeargs=0 (baml.Array.push) + 181 pop 1 + 182 jump -171 (to 11) + + 209 183 load_var 3 (has_call) + 184 pop_jump_if_false +2 (to 186) + 185 jump +25 (to 210) + + 211 186 load_var 1 (resp) + 187 load_field 0 (status) + 188 store_var 32 (_68) + 189 load_var 32 (_68) + 190 store_var 31 (_67) + 191 load_var 32 (_68) + 192 load_const 10 (null) + 193 cmp_op == + 194 pop_jump_if_false +3 (to 197) + 195 load_const 28 ("") + 196 store_var 31 (_67) + 197 load_var 31 (_67) + 198 load_const 29 ("incomplete") + 199 cmp_op == + 200 pop_jump_if_false +2 (to 202) + 201 jump +5 (to 206) + + 214 202 load_const 30 (ai.content.StopReason.Complete) + 203 alloc_variant 436 (ai.content.StopReason) + 204 store_var 30 (stop) + + 211 205 jump +8 (to 213) + + 212 206 load_const 31 (ai.content.StopReason.MaxTokens) + 207 alloc_variant 436 (ai.content.StopReason) + 208 store_var 30 (stop) + + 211 209 jump +4 (to 213) + + 210 210 load_const 16 (ai.content.StopReason.ToolUse) + 211 alloc_variant 436 (ai.content.StopReason) + 212 store_var 30 (stop) + + 216 213 load_var 1 (resp) + 214 load_field 2 (usage) + 215 store_var 34 (_72) + 216 load_var 34 (_72) + 217 narrow_bind 32 34 + 218 pop_jump_if_false +2 (to 220) + 219 jump +4 (to 223) + + 224 220 load_const 10 (null) + 221 store_var 33 (usage) + + 216 222 jump +10 (to 232) + 223 load_var 34 (_72) + 224 store_var_load_var 35 (u) + + 218 225 load_field 0 (input_tokens) + + 219 226 load_var 35 (u) + 227 load_field 1 (output_tokens) + 228 load_const 10 (null) + 229 load_const 10 (null) + 230 init_instance 3 (ai.events.Usage .input_tokens, .output_tokens, .cached_input_tokens, .reasoning_tokens) + 231 store_var 33 (usage) + + 226 232 load_var2 2 30 + 233 load_var 33 (usage) + 234 init_instance 4 (ai.ModelTurn .content, .stop_reason, .usage) + 235 return +} + +function openai.internal.openai_render(c: openai.OpenAiClient, input: ai.ModelTurnInput) -> baml.http.Request { + 118 0 load_var2 1 2 + 1 load_const 0 (false) + 2 call 855 ntypeargs=0 (openai.internal._openai_request) + 3 return +} + +function reflect.call_any(f: baml.AnyFunction, args: map) -> #0 { +} + +function reflect.signature(f: baml.AnyFunction) -> reflect.Signature { +} + +function testing.$invoke_collector(collector: (testing.TestCollector) -> void throws unknown, c: testing.TestCollector) -> void { + 143 0 load_var2 2 1 + 1 call_indirect + 2 return +} + +function testing.FailFast() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 104 0 make_closure 1593 0 + 1 store_var 1 (_0) + 2 load_var 1 (_0) + 3 return +} + +function testing.PassRate(threshold: float) -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 70 3 load_deref 1 + 4 load_const 0 (0.0) + 5 cmp_float_op < + 6 jump_if_false +2 (to 8) + 7 jump +5 (to 12) + 8 pop 1 + 9 load_deref 1 + 10 load_const 1 (1.0) + 11 cmp_float_op > + 12 pop_jump_if_false +4 (to 16) + + 71 13 load_const 2 ("testing.PassRate requires 0.0 <= threshold <= 1.0") + 14 call 260 ntypeargs=0 (baml.sys.panic) + 15 pop 1 + + 76 16 load_var 1 (threshold) + 17 make_closure 1588 1 + 18 store_var 2 (_0) + 19 load_var 2 (_0) + 20 return +} + +function testing.Quorum(n: int, m: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 2 6 load_deref 1 + 7 load_const 0 (0) + 8 cmp_int_op <= + 9 pop_jump_if_false +2 (to 11) + 10 jump +15 (to 25) + + 4 11 load_deref 2 + 12 load_const 0 (0) + 13 cmp_int_op < + 14 jump_if_false +2 (to 16) + 15 jump +5 (to 20) + 16 pop 1 + 17 load_deref 2 + 18 load_deref 1 + 19 cmp_int_op > + 20 pop_jump_if_false +8 (to 28) + + 5 21 load_const 1 ("testing.Quorum requires 0 <= m <= n") + 22 call 260 ntypeargs=0 (baml.sys.panic) + 23 pop 1 + 24 jump +4 (to 28) + + 3 25 load_const 2 ("testing.Quorum requires n > 0") + 26 call 260 ntypeargs=0 (baml.sys.panic) + 27 pop 1 + + 10 28 load_var2 1 2 + 29 make_closure 1572 2 + 30 store_var 3 (_0) + 31 load_var 3 (_0) + 32 return +} + +function testing.Retry(max_attempts: int) -> (() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 36 3 load_deref 1 + 4 load_const 0 (0) + 5 cmp_int_op <= + 6 pop_jump_if_false +4 (to 10) + + 37 7 load_const 1 ("testing.Retry requires max_attempts > 0") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 pop 1 + + 42 10 load_var 1 (max_attempts) + 11 make_closure 1582 1 + 12 store_var 2 (_0) + 13 load_var 2 (_0) + 14 return +} + +function testing.Sequential() -> (testing.TestSetChild[]) -> testing.TestSetReport throws never { + 98 0 make_closure 1591 0 + 1 store_var 1 (_0) + 2 load_var 1 (_0) + 3 return +} + +function testing.TestCollector.find_test(self: testing.TestCollector, name: string) -> testing.TestRegistration { + 131 0 load_var 1 (self) + 1 load_field 1 (tests) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 4 (_4) + 6 load_var 4 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 5 (_5) + 11 load_var 5 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +11 (to 25) + 15 load_var 5 (_5) + 16 store_var_load_var 6 (t) + + 132 17 load_field 0 (name) + 18 load_var 2 (name) + 19 cmp_op == + 20 pop_jump_if_false -14 (to 6) + + 133 21 load_var 6 (t) + 22 store_var 3 (_0) + 23 load_var 3 (_0) + 24 return + + 136 25 load_const 5 ("Test not found: ") + 26 load_var 2 (name) + 27 bin_op + + 28 throw +} + +function testing.TestCollector.find_testset(self: testing.TestCollector, name: string) -> testing.TestSetRegistration { + 122 0 load_var 1 (self) + 1 load_field 2 (testsets) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 4 (_4) + 6 load_var 4 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 5 (_5) + 11 load_var 5 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +11 (to 25) + 15 load_var 5 (_5) + 16 store_var_load_var 6 (ts) + + 123 17 load_field 0 (name) + 18 load_var 2 (name) + 19 cmp_op == + 20 pop_jump_if_false -14 (to 6) + + 124 21 load_var 6 (ts) + 22 store_var 3 (_0) + 23 load_var 3 (_0) + 24 return + + 127 25 load_const 5 ("TestSet not found: ") + 26 load_var 2 (name) + 27 bin_op + + 28 throw +} + +function testing.TestCollector.new(prefix: string) -> testing.TestCollector { + 30 0 load_var 1 (prefix) + 1 load_type 0 + 2 alloc_array 0 + 3 load_type 1 + 4 alloc_array 0 + 5 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 6 store_var 2 (_0) + 7 load_var 2 (_0) + 8 return +} + +function testing.TestCollector.register_test(self: testing.TestCollector, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { + 34 0 load_var 2 (name) + 1 load_const 0 ("::") + 2 call 147 ntypeargs=0 (baml.String.includes) + 3 pop_jump_if_false +2 (to 5) + 4 jump +89 (to 93) + + 39 5 load_var 1 (self) + 6 load_field 0 (prefix) + 7 load_const 1 ("") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +9 (to 19) + + 42 11 load_var 1 (self) + 12 load_field 0 (prefix) + 13 load_const 2 ("::") + 14 bin_op + + 15 load_var 2 (name) + 16 bin_op + + 17 store_var 6 (full_name) + + 39 18 jump +3 (to 21) + + 40 19 load_var 2 (name) + 20 store_var 6 (full_name) + + 44 21 load_const 3 (0) + 22 store_var 7 (count) + + 45 23 load_var 6 (full_name) + 24 load_const 4 ("#") + 25 bin_op + + 26 store_var 8 (hash_prefix) + + 46 27 load_var 1 (self) + 28 load_field 1 (tests) + 29 load_type 5 + 30 load_const 6 ("iter") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 9 (_17) + 33 load_var 9 (_17) + 34 load_type 7 + 35 load_const 8 ("next") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 10 (_18) + 38 load_var 10 (_18) + 39 is_type 9 + 40 pop_jump_if_false +2 (to 42) + 41 jump +19 (to 60) + 42 load_var 10 (_18) + 43 store_var_load_var 11 (t) + + 47 44 load_field 0 (name) + 45 load_var 6 (full_name) + 46 cmp_op == + 47 jump_if_false +2 (to 49) + 48 jump +6 (to 54) + 49 pop 1 + 50 load_var 11 (t) + 51 load_field 0 (name) + 52 load_var 8 (hash_prefix) + 53 call 148 ntypeargs=0 (baml.String.starts_with) + 54 pop_jump_if_false -21 (to 33) + + 48 55 load_var 7 (count) + 56 load_const 10 (1) + 57 add_int + 58 store_var 7 (count) + + 47 59 jump -26 (to 33) + + 53 60 load_var 7 (count) + 61 load_const 3 (0) + 62 cmp_int_op > + 63 pop_jump_if_false +2 (to 65) + 64 jump +4 (to 68) + + 56 65 load_var 6 (full_name) + 66 store_var 12 (final_name) + + 53 67 jump +14 (to 81) + + 54 68 load_var 6 (full_name) + 69 load_const 11 ("#") + 70 bin_op + + 71 store_var 13 (_31) + 72 load_type 12 + 73 load_var 7 (count) + 74 load_const 10 (1) + 75 add_int + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 14 (_33) + 78 load_var2 13 14 + 79 bin_op + + 80 store_var 12 (final_name) + + 58 81 load_type 13 + 82 load_var 1 (self) + 83 load_field 1 (tests) + 84 load_var2 12 3 + 85 load_var 4 (runner) + 86 init_instance 0 (testing.TestRegistration .name, .body, .runner) + 87 call 4 ntypeargs=1 (baml.Array.push) + 88 pop 1 + + 33 89 load_const 14 (null) + 90 store_var 5 (_0) + 91 load_var 5 (_0) + 92 return + + 35 93 load_const 15 ("test name may not contain reserved separator `::`: ") + 94 load_var 2 (name) + 95 bin_op + + 96 init_instance 1 (testing.InvalidTestName .message) + 97 throw +} + +function testing.TestCollector.register_test_at(self: testing.TestCollector, owner: string, name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> void { + 106 0 load_var2 2 1 + 1 load_field 1 (tests) + 2 load_var 1 (self) + 3 load_field 2 (testsets) + 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 5 store_var 6 (scoped) + + 107 6 load_var2 6 3 + 7 load_var2 4 5 + 8 call 721 ntypeargs=0 (testing.TestCollector.register_test) + 9 return +} + +function testing.TestCollector.register_test_set(self: testing.TestCollector, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { + 67 0 load_var 2 (name) + 1 load_const 0 ("::") + 2 call 147 ntypeargs=0 (baml.String.includes) + 3 pop_jump_if_false +2 (to 5) + 4 jump +89 (to 93) + + 72 5 load_var 1 (self) + 6 load_field 0 (prefix) + 7 load_const 1 ("") + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +9 (to 19) + + 75 11 load_var 1 (self) + 12 load_field 0 (prefix) + 13 load_const 2 ("::") + 14 bin_op + + 15 load_var 2 (name) + 16 bin_op + + 17 store_var 6 (full_name) + + 72 18 jump +3 (to 21) + + 73 19 load_var 2 (name) + 20 store_var 6 (full_name) + + 77 21 load_const 3 (0) + 22 store_var 7 (count) + + 78 23 load_var 6 (full_name) + 24 load_const 4 ("#") + 25 bin_op + + 26 store_var 8 (hash_prefix) + + 79 27 load_var 1 (self) + 28 load_field 2 (testsets) + 29 load_type 5 + 30 load_const 6 ("iter") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 9 (_17) + 33 load_var 9 (_17) + 34 load_type 7 + 35 load_const 8 ("next") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 10 (_18) + 38 load_var 10 (_18) + 39 is_type 9 + 40 pop_jump_if_false +2 (to 42) + 41 jump +19 (to 60) + 42 load_var 10 (_18) + 43 store_var_load_var 11 (ts) + + 80 44 load_field 0 (name) + 45 load_var 6 (full_name) + 46 cmp_op == + 47 jump_if_false +2 (to 49) + 48 jump +6 (to 54) + 49 pop 1 + 50 load_var 11 (ts) + 51 load_field 0 (name) + 52 load_var 8 (hash_prefix) + 53 call 148 ntypeargs=0 (baml.String.starts_with) + 54 pop_jump_if_false -21 (to 33) + + 81 55 load_var 7 (count) + 56 load_const 10 (1) + 57 add_int + 58 store_var 7 (count) + + 80 59 jump -26 (to 33) + + 86 60 load_var 7 (count) + 61 load_const 3 (0) + 62 cmp_int_op > + 63 pop_jump_if_false +2 (to 65) + 64 jump +4 (to 68) + + 89 65 load_var 6 (full_name) + 66 store_var 12 (final_name) + + 86 67 jump +14 (to 81) + + 87 68 load_var 6 (full_name) + 69 load_const 11 ("#") + 70 bin_op + + 71 store_var 13 (_31) + 72 load_type 12 + 73 load_var 7 (count) + 74 load_const 10 (1) + 75 add_int + 76 call 138 ntypeargs=1 (baml.String.from) + 77 store_var 14 (_33) + 78 load_var2 13 14 + 79 bin_op + + 80 store_var 12 (final_name) + + 91 81 load_type 13 + 82 load_var 1 (self) + 83 load_field 2 (testsets) + + 92 84 load_var2 12 3 + 85 load_var 4 (runner) + 86 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) + 87 call 4 ntypeargs=1 (baml.Array.push) + 88 pop 1 + + 66 89 load_const 14 (null) + 90 store_var 5 (_0) + 91 load_var 5 (_0) + 92 return + + 68 93 load_const 15 ("testset name may not contain reserved separator `::`: ") + 94 load_var 2 (name) + 95 bin_op + + 96 init_instance 1 (testing.InvalidTestName .message) + 97 throw +} + +function testing.TestCollector.register_test_set_at(self: testing.TestCollector, owner: string, name: string, collector: (testing.TestCollector) -> void throws unknown, runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> void { + 117 0 load_var2 2 1 + 1 load_field 1 (tests) + 2 load_var 1 (self) + 3 load_field 2 (testsets) + 4 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 5 store_var 6 (scoped) + + 118 6 load_var2 6 3 + 7 load_var2 4 5 + 8 call 722 ntypeargs=0 (testing.TestCollector.register_test_set) + 9 return +} + +function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: string) -> (testing.SerializedTest | testing.SerializedTestSet)[] { + 288 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 2 (testsets) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +13 (to 28) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (ts) + + 289 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 290 22 load_var2 1 5 + 23 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 24 pop 1 + + 291 25 load_var 1 (self) + 26 call 729 ntypeargs=0 (testing.TestRegistry.serialize) + 27 jump +33 (to 60) + + 295 28 load_type 5 + 29 load_type 6 + 30 load_var 1 (self) + 31 load_field 1 (expansions) + 32 call 35 ntypeargs=2 (baml.Map.keys) + 33 load_type 7 + 34 load_const 8 ("iter") + 35 virtual_call nargs=1 ntypeargs=0 + 36 store_var 6 (_17) + 37 load_var 6 (_17) + 38 load_type 9 + 39 load_const 10 ("next") + 40 virtual_call nargs=1 ntypeargs=0 + 41 store_var 7 (_18) + 42 load_var 7 (_18) + 43 is_type 4 + 44 pop_jump_if_false +2 (to 46) + 45 jump +16 (to 61) + 46 load_var 7 (_18) + 47 store_var 8 (k) + + 296 48 load_var 1 (self) + 49 load_field 1 (expansions) + 50 load_var 8 (k) + 51 load_map_element + 52 store_var 9 (sub) + + 297 53 load_var2 2 8 + 54 load_const 11 ("::") + 55 bin_op + + 56 call 148 ntypeargs=0 (baml.String.starts_with) + 57 pop_jump_if_false -20 (to 37) + + 298 58 load_var2 9 2 + 59 call 736 ntypeargs=0 (testing.TestRegistry.expand_set) + 60 return + + 301 61 load_const 12 ("TestSet not found for expansion: ") + 62 load_var 2 (name) + 63 bin_op + + 64 throw +} + +function testing.TestRegistry.expand_testset_registry(self: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestRegistry { + 305 0 load_type 0 + 1 load_type 1 + 2 load_var 1 (self) + 3 load_field 1 (expansions) + 4 load_var 2 (ts) + 5 load_field 0 (name) + 6 call 38 ntypeargs=2 (baml.Map.get) + 7 store_var 3 (_8) + 8 load_var 3 (_8) + 9 narrow_bind 2 3 + 10 pop_jump_if_false +2 (to 12) + 11 jump +53 (to 64) + + 308 12 sys_op 522 (baml.time.Instant.now) + 13 store_var 5 (start) + + 309 14 load_var 2 (ts) + 15 load_field 0 (name) + 16 load_type 3 + 17 alloc_array 0 + 18 load_type 4 + 19 alloc_array 0 + 20 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) + 21 store_var_load_var 6 (sub_collector) + + 310 22 load_var 2 (ts) + 23 load_field 1 (collector) + 24 call_indirect + 25 pop 1 + + 315 26 load_var 5 (start) + 27 call 523 ntypeargs=0 (baml.time.Instant.elapsed) + 28 call 510 ntypeargs=0 (baml.time.Duration.to_milliseconds) + 29 call 92 ntypeargs=0 (baml.Bigint.to_int) + 30 store_var 7 (elapsed) + 31 jump +15 (to 46) + 32 load_var 8 (_) + 33 is_type 5 + 34 pop_jump_if_false +2 (to 36) + 35 jump +3 (to 38) + 36 load_var 8 (_) + 37 rethrow + 38 load_var 8 (_) + 39 load_field 0 (0) + 40 store_var 9 (message) + + 317 41 load_const 6 ("testing: expansion duration: ") + 42 load_var 9 (message) + 43 bin_op + + 44 call 260 ntypeargs=0 (baml.sys.panic) + 45 store_var 7 (elapsed) + + 320 46 load_var 6 (sub_collector) + 47 load_type 0 + 48 load_type 1 + 49 alloc_map 0 + 50 load_var 7 (elapsed) + 51 init_instance 1 (testing.TestRegistry .collector, .expansions, .loading_time_ms) + 52 store_var 10 (sub_registry) + + 321 53 load_type 0 + 54 load_type 1 + 55 load_var 1 (self) + 56 load_field 1 (expansions) + 57 load_var 2 (ts) + 58 load_field 0 (name) + 59 load_var 10 (sub_registry) + 60 call 37 ntypeargs=2 (baml.Map.set) + 61 pop 1 + + 322 62 load_var 10 (sub_registry) + + 305 63 jump +4 (to 67) + 64 load_var 3 (_8) + 65 store_var 4 (existing) + + 306 66 load_var 4 (existing) + 67 return +} + +function testing.TestRegistry.list_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 281 0 load_var2 1 2 + 1 load_var2 3 4 + 2 load_var 5 (cli_exclude) + 3 call 757 ntypeargs=0 (testing.select_names_layered) + 4 return +} + +function testing.TestRegistry.new(collector: testing.TestCollector) -> testing.TestRegistry { + 169 0 load_var 1 (collector) + 1 load_type 0 + 2 load_type 1 + 3 alloc_map 0 + 4 load_const 2 (0) + 5 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) + 6 store_var 2 (_0) + 7 load_var 2 (_0) + 8 return +} + +function testing.TestRegistry.run_all(self: testing.TestRegistry) -> testing.TestSetReport { + 237 0 load_var 1 (self) + 1 call 738 ntypeargs=0 (testing.testset_children) + 2 load_const 0 (null) + 3 call 748 ntypeargs=0 (testing.run_testset) + 4 return +} + +function testing.TestRegistry.run_filtered(self: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> testing.FlatTestReport { + 259 0 load_var2 1 2 + 1 load_var2 3 4 + 2 load_var 5 (cli_exclude) + 3 call 757 ntypeargs=0 (testing.select_names_layered) + 4 store_var 6 (selected_names) + + 261 5 load_var 2 (profile_include) + 6 container_len + 7 store_var 7 (_12) + 8 load_var 7 (_12) + 9 load_const 0 (0) + 10 cmp_int_op == + 11 jump_if_false +8 (to 19) + 12 pop 1 + + 262 13 load_var 3 (profile_exclude) + 14 container_len + 15 store_var 8 (_13) + 16 load_var 8 (_13) + 17 load_const 0 (0) + 18 cmp_int_op == + + 261 19 jump_if_false +8 (to 27) + 20 pop 1 + + 263 21 load_var 4 (cli_include) + 22 container_len + 23 store_var 9 (_14) + 24 load_var 9 (_14) + 25 load_const 0 (0) + 26 cmp_int_op == + + 261 27 jump_if_false +8 (to 35) + 28 pop 1 + + 264 29 load_var 5 (cli_exclude) + 30 container_len + 31 store_var 10 (_15) + 32 load_var 10 (_15) + 33 load_const 0 (0) + 34 cmp_int_op == + + 260 35 pop_jump_if_false +2 (to 37) + 36 jump +4 (to 40) + + 268 37 load_var2 1 6 + 38 call 733 ntypeargs=0 (testing.TestRegistry.run_selected) + 39 jump +3 (to 42) + + 266 40 load_var 1 (self) + 41 call 732 ntypeargs=0 (testing.TestRegistry.run_all) + + 270 42 load_var 6 (selected_names) + 43 call 763 ntypeargs=0 (testing.flatten_with_tolerated) + 44 return +} + +function testing.TestRegistry.run_selected(self: testing.TestRegistry, names: string[]) -> testing.TestSetReport { + 241 0 load_var2 1 2 + 1 call 739 ntypeargs=0 (testing.testset_children_selected) + 2 load_const 0 (null) + 3 call 748 ntypeargs=0 (testing.run_testset) + 4 return +} + +function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) -> testing.TestReport { + 205 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 1 (tests) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +13 (to 28) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (t) + + 206 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 207 22 load_var 5 (t) + 23 load_field 1 (body) + 24 load_var 5 (t) + 25 load_field 2 (runner) + 26 call 747 ntypeargs=0 (testing.run_test) + 27 jump +33 (to 60) + + 211 28 load_type 5 + 29 load_type 6 + 30 load_var 1 (self) + 31 load_field 1 (expansions) + 32 call 35 ntypeargs=2 (baml.Map.keys) + 33 load_type 7 + 34 load_const 8 ("iter") + 35 virtual_call nargs=1 ntypeargs=0 + 36 store_var 6 (_17) + 37 load_var 6 (_17) + 38 load_type 9 + 39 load_const 10 ("next") + 40 virtual_call nargs=1 ntypeargs=0 + 41 store_var 7 (_18) + 42 load_var 7 (_18) + 43 is_type 4 + 44 pop_jump_if_false +2 (to 46) + 45 jump +16 (to 61) + 46 load_var 7 (_18) + 47 store_var 8 (k) + + 212 48 load_var 1 (self) + 49 load_field 1 (expansions) + 50 load_var 8 (k) + 51 load_map_element + 52 store_var 9 (sub) + + 214 53 load_var2 2 8 + 54 load_const 11 ("::") + 55 bin_op + + 56 call 148 ntypeargs=0 (baml.String.starts_with) + 57 pop_jump_if_false -20 (to 37) + + 215 58 load_var2 9 2 + 59 call 730 ntypeargs=0 (testing.TestRegistry.run_test) + 60 return + + 218 61 load_const 12 ("Test not found: ") + 62 load_var 2 (name) + 63 bin_op + + 64 throw +} + +function testing.TestRegistry.run_testset(self: testing.TestRegistry, name: string) -> testing.TestSetReport { + 222 0 load_var 1 (self) + 1 load_field 0 (collector) + 2 load_field 2 (testsets) + 3 load_type 0 + 4 load_const 1 ("iter") + 5 virtual_call nargs=1 ntypeargs=0 + 6 store_var 3 (_4) + 7 load_var 3 (_4) + 8 load_type 2 + 9 load_const 3 ("next") + 10 virtual_call nargs=1 ntypeargs=0 + 11 store_var 4 (_5) + 12 load_var 4 (_5) + 13 is_type 4 + 14 pop_jump_if_false +2 (to 16) + 15 jump +14 (to 29) + 16 load_var 4 (_5) + 17 store_var_load_var 5 (ts) + + 223 18 load_field 0 (name) + 19 load_var 2 (name) + 20 cmp_op == + 21 pop_jump_if_false -14 (to 7) + + 224 22 load_var2 1 5 + 23 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 24 call 738 ntypeargs=0 (testing.testset_children) + 25 load_var 5 (ts) + 26 load_field 2 (runner) + 27 call 748 ntypeargs=0 (testing.run_testset) + 28 jump +33 (to 61) + + 227 29 load_type 5 + 30 load_type 6 + 31 load_var 1 (self) + 32 load_field 1 (expansions) + 33 call 35 ntypeargs=2 (baml.Map.keys) + 34 load_type 7 + 35 load_const 8 ("iter") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 6 (_19) + 38 load_var 6 (_19) + 39 load_type 9 + 40 load_const 10 ("next") + 41 virtual_call nargs=1 ntypeargs=0 + 42 store_var 7 (_20) + 43 load_var 7 (_20) + 44 is_type 4 + 45 pop_jump_if_false +2 (to 47) + 46 jump +16 (to 62) + 47 load_var 7 (_20) + 48 store_var 8 (k) + + 228 49 load_var 1 (self) + 50 load_field 1 (expansions) + 51 load_var 8 (k) + 52 load_map_element + 53 store_var 9 (sub) + + 229 54 load_var2 2 8 + 55 load_const 11 ("::") + 56 bin_op + + 57 call 148 ntypeargs=0 (baml.String.starts_with) + 58 pop_jump_if_false -20 (to 38) + + 230 59 load_var2 9 2 + 60 call 731 ntypeargs=0 (testing.TestRegistry.run_testset) + 61 return + + 233 62 load_const 12 ("TestSet not found: ") + 63 load_var 2 (name) + 64 bin_op + + 65 throw +} + +function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing.SerializedTest | testing.SerializedTestSet)[] { + 178 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (items) + + 179 3 load_var 1 (self) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 5 (_5) + 15 load_var 5 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +11 (to 29) + 19 load_var 5 (_5) + 20 store_var 6 (t) + + 180 21 load_var 3 (items) + 22 load_const 6 ("test") + 23 load_var 6 (t) + 24 load_field 0 (name) + 25 init_instance 0 (testing.SerializedTest .type, .name) + 26 call 4 ntypeargs=0 (baml.Array.push) + 27 pop 1 + 28 jump -18 (to 10) + + 182 29 load_var 1 (self) + 30 load_field 0 (collector) + 31 load_field 2 (testsets) + 32 load_type 7 + 33 load_const 8 ("iter") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 7 (_13) + 36 load_var 7 (_13) + 37 load_type 9 + 38 load_const 10 ("next") + 39 virtual_call nargs=1 ntypeargs=0 + 40 store_var 8 (_14) + 41 load_var 8 (_14) + 42 is_type 5 + 43 pop_jump_if_false +2 (to 45) + 44 jump +38 (to 82) + 45 load_var 8 (_14) + 46 store_var 9 (ts) + + 183 47 load_type 11 + 48 load_type 12 + 49 load_var 1 (self) + 50 load_field 1 (expansions) + 51 load_var 9 (ts) + 52 load_field 0 (name) + 53 call 38 ntypeargs=2 (baml.Map.get) + + 184 54 store_var 10 (_24) + 55 load_var 10 (_24) + 56 narrow_bind 13 10 + 57 pop_jump_if_false +2 (to 59) + 58 jump +9 (to 67) + + 195 59 load_var 3 (items) + 60 load_const 14 ("lazyTestSet") + 61 load_var 9 (ts) + 62 load_field 0 (name) + 63 init_instance 1 (testing.SerializedTest .type, .name) + 64 call 4 ntypeargs=0 (baml.Array.push) + 65 pop 1 + 66 jump -30 (to 36) + + 184 67 load_var 10 (_24) + 68 store_var 11 (sub) + + 188 69 load_var 9 (ts) + 70 load_field 0 (name) + 71 store_var 12 (_27) + + 189 72 load_var 11 (sub) + 73 call 729 ntypeargs=0 (testing.TestRegistry.serialize) + 74 store_var 13 (_28) + + 186 75 load_var2 3 12 + + 187 76 load_var2 13 11 + + 190 77 load_field 2 (loading_time_ms) + 78 init_instance 2 (testing.SerializedTestSet .name, .items, .loadingTimeMs) + 79 call 4 ntypeargs=0 (baml.Array.push) + 80 pop 1 + 81 jump -45 (to 36) + + 199 82 load_var 3 (items) + 83 store_var 2 (_0) + 84 load_var 2 (_0) + 85 return +} + +function testing._has_selected_descendant(prefix: string, names: string[]) -> bool { + 415 0 load_var 1 (prefix) + 1 load_const 0 ("::") + 2 bin_op + + 3 store_var 3 (descendant_prefix) + + 416 4 load_var 2 (names) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +8 (to 25) + 18 load_var 5 (_5) + 19 store_var 6 (selected) + + 417 20 load_var2 6 3 + 21 call 148 ntypeargs=0 (baml.String.starts_with) + 22 pop_jump_if_false -13 (to 9) + + 418 23 load_const 6 (true) + 24 jump +2 (to 26) + + 423 25 load_const 7 (false) + 26 return +} + +function testing._int_to_float(value: int) -> float { + 128 0 load_type 0 + 1 load_var 1 (value) + 2 call 138 ntypeargs=1 (baml.String.from) + 3 call 130 ntypeargs=0 (baml.Float.parse) + 4 jump +5 (to 9) + 5 load_var 2 (e) + 6 throw_if_panic + + 129 7 load_const 1 ("failed to convert int to float") + 8 call 260 ntypeargs=0 (baml.sys.panic) + 9 return +} + +function testing._name_selected(name: string, names: string[]) -> bool { + 404 0 load_var 2 (names) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +8 (to 21) + 14 load_var 4 (_4) + 15 store_var_load_var 5 (selected) + + 405 16 load_var 1 (name) + 17 cmp_op == + 18 pop_jump_if_false -13 (to 5) + + 406 19 load_const 5 (true) + 20 jump +2 (to 22) + + 411 21 load_const 6 (false) + 22 return +} + +function testing.aggregate_reports(named_results: testing.NamedChildReport[]) -> testing.TestSetReport { + 427 0 load_const 0 (0) + 1 store_var 3 (passed) + + 428 2 load_const 0 (0) + 3 store_var 4 (failed) + + 429 4 load_const 1 (false) + 5 store_var 5 (has_error) + + 430 6 load_type 2 + 7 alloc_array 0 + 8 store_var 6 (failed_names) + + 431 9 load_type 3 + 10 alloc_array 0 + 11 store_var 7 (results) + + 432 12 load_type 2 + 13 alloc_array 0 + 14 store_var 8 (result_names) + + 433 15 load_var 1 (named_results) + 16 load_type 4 + 17 load_const 5 ("iter") + 18 virtual_call nargs=1 ntypeargs=0 + 19 store_var 9 (_8) + 20 load_var 9 (_8) + 21 load_type 6 + 22 load_const 7 ("next") + 23 virtual_call nargs=1 ntypeargs=0 + 24 store_var 10 (_9) + 25 load_var 10 (_9) + 26 is_type 8 + 27 pop_jump_if_false +2 (to 29) + 28 jump +98 (to 126) + 29 load_var 10 (_9) + 30 store_var 11 (named_result) + + 434 31 load_var 11 (named_result) + 32 load_field 1 (report) + 33 store_var 12 (result) + + 435 34 load_var2 7 12 + 35 call 4 ntypeargs=0 (baml.Array.push) + 36 pop 1 + + 436 37 load_var2 8 11 + 38 load_field 0 (name) + 39 call 4 ntypeargs=0 (baml.Array.push) + 40 pop 1 + + 437 41 load_var 12 (result) + 42 store_var 14 (_19) + 43 load_var 14 (_19) + 44 narrow_bind 9 14 + 45 pop_jump_if_false +2 (to 47) + 46 jump +7 (to 53) + 47 load_var 12 (result) + 48 store_var 16 (report) + + 439 49 load_var 16 (report) + 50 load_field 0 (outcome) + 51 store_var 13 (outcome) + + 437 52 jump +6 (to 58) + 53 load_var 14 (_19) + 54 store_var 15 (report) + + 438 55 load_var 15 (report) + 56 load_field 0 (outcome) + 57 store_var 13 (outcome) + + 441 58 load_var 13 (outcome) + 59 load_const 10 ("pass") + 60 call 635 ntypeargs=0 (baml.ops.equals_equals) + 61 pop_jump_if_false +2 (to 63) + 62 jump +59 (to 121) + + 444 63 load_var 4 (failed) + 64 load_const 11 (1) + 65 add_int + 66 store_var 4 (failed) + + 445 67 load_var 12 (result) + 68 store_var 17 (_25) + 69 load_var 17 (_25) + 70 narrow_bind 9 17 + 71 pop_jump_if_false +2 (to 73) + 72 jump +19 (to 91) + 73 load_var 12 (result) + 74 store_var_load_var 18 (report) + + 448 75 load_field 4 (failed_names) + 76 container_len + 77 store_var 19 (_29) + 78 load_var 19 (_29) + 79 load_const 0 (0) + 80 cmp_int_op > + 81 pop_jump_if_false +2 (to 83) + 82 jump +6 (to 88) + + 451 83 load_var 11 (named_result) + 84 load_field 0 (name) + 85 load_type 2 + 86 alloc_array 1 + + 448 87 jump +8 (to 95) + + 449 88 load_var 18 (report) + 89 load_field 4 (failed_names) + + 448 90 jump +5 (to 95) + + 446 91 load_var 11 (named_result) + 92 load_field 0 (name) + 93 load_type 2 + 94 alloc_array 1 + + 455 95 load_type 12 + 96 load_const 13 ("iter") + 97 virtual_call nargs=1 ntypeargs=0 + 98 store_var 20 (_33) + 99 load_var 20 (_33) + 100 load_type 14 + 101 load_const 15 ("next") + 102 virtual_call nargs=1 ntypeargs=0 + 103 store_var 21 (_34) + 104 load_var 21 (_34) + 105 is_type 8 + 106 pop_jump_if_false +2 (to 108) + 107 jump +7 (to 114) + 108 load_var 21 (_34) + 109 store_var 22 (name) + + 456 110 load_var2 6 22 + 111 call 4 ntypeargs=0 (baml.Array.push) + 112 pop 1 + 113 jump -14 (to 99) + + 458 114 load_var 13 (outcome) + 115 load_const 16 ("error") + 116 call 635 ntypeargs=0 (baml.ops.equals_equals) + 117 pop_jump_if_false -97 (to 20) + + 459 118 load_const 17 (true) + 119 store_var 5 (has_error) + + 458 120 jump -100 (to 20) + + 442 121 load_var 3 (passed) + 122 load_const 11 (1) + 123 add_int + 124 store_var 3 (passed) + + 441 125 jump -105 (to 20) + + 465 126 load_var 5 (has_error) + 127 pop_jump_if_false +2 (to 129) + 128 jump +10 (to 138) + + 467 129 load_var 4 (failed) + 130 load_const 0 (0) + 131 cmp_int_op == + 132 pop_jump_if_false +2 (to 134) + 133 jump +3 (to 136) + + 470 134 load_const 18 ("fail") + + 467 135 jump +4 (to 139) + + 468 136 load_const 19 ("pass") + + 467 137 jump +2 (to 139) + + 466 138 load_const 20 ("error") + + 473 139 store_var 23 (_46) + + 474 140 load_var 3 (passed) + 141 store_var 24 (_47) + + 475 142 load_var 4 (failed) + 143 store_var 25 (_48) + + 476 144 load_var 7 (results) + 145 container_len + 146 store_var 26 (_49) + + 472 147 load_var2 23 24 + 148 load_var2 25 26 + + 477 149 load_var2 6 7 + + 479 150 load_var 8 (result_names) + 151 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) + 152 store_var 2 (_0) + 153 load_var 2 (_0) + 154 return +} + +function testing.any_pattern_matches(pats: string[], canonical_id: string) -> bool { + 607 0 load_var 1 (pats) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +8 (to 21) + 14 load_var 4 (_4) + 15 store_var 5 (p) + + 608 16 load_var2 2 5 + 17 call 750 ntypeargs=0 (testing.glob_match) + 18 pop_jump_if_false -13 (to 5) + + 609 19 load_const 5 (true) + 20 jump +2 (to 22) + + 612 21 load_const 6 (false) + 22 return +} + +function testing.classify_selected_names(selected_names: string[], hard_failed_names: string[], all_failed_names: string[]) -> testing.LeafIdentities { + 947 0 load_type 0 + 1 alloc_array 0 + 2 load_type 0 + 3 alloc_array 0 + 4 load_type 0 + 5 alloc_array 0 + 6 init_instance 0 (testing.LeafIdentities .passed, .failed, .tolerated) + 7 store_var 5 (out) + + 948 8 load_var 1 (selected_names) + 9 load_type 1 + 10 load_const 2 ("iter") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 6 (_8) + 13 load_var 6 (_8) + 14 load_type 3 + 15 load_const 4 ("next") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 7 (_9) + 18 load_var 7 (_9) + 19 is_type 5 + 20 pop_jump_if_false +2 (to 22) + 21 jump +32 (to 53) + 22 load_var 7 (_9) + 23 store_var_load_var 8 (name) + + 949 24 load_var 3 (all_failed_names) + 25 call 766 ntypeargs=0 (testing.failure_matches_selected) + 26 pop_jump_if_false +2 (to 28) + 27 jump +8 (to 35) + + 956 28 load_type 0 + 29 load_var 5 (out) + 30 load_field 0 (passed) + 31 load_var 8 (name) + 32 call 4 ntypeargs=1 (baml.Array.push) + 33 pop 1 + 34 jump -21 (to 13) + + 950 35 load_var2 8 2 + 36 call 766 ntypeargs=0 (testing.failure_matches_selected) + 37 pop_jump_if_false +2 (to 39) + 38 jump +8 (to 46) + + 953 39 load_type 0 + 40 load_var 5 (out) + 41 load_field 2 (tolerated) + 42 load_var 8 (name) + 43 call 4 ntypeargs=1 (baml.Array.push) + 44 pop 1 + 45 jump -32 (to 13) + + 951 46 load_type 0 + 47 load_var 5 (out) + 48 load_field 1 (failed) + 49 load_var 8 (name) + 50 call 4 ntypeargs=1 (baml.Array.push) + 51 pop 1 + 52 jump -39 (to 13) + + 959 53 load_var 5 (out) + 54 store_var 4 (_0) + 55 load_var 4 (_0) + 56 return +} + +function testing.collect_all_failed_names(report: testing.TestSetReport, out: string[]) -> void { + 1049 0 load_var 1 (report) + 1 load_field 4 (failed_names) + 2 load_type 0 + 3 load_const 1 ("iter") + 4 virtual_call nargs=1 ntypeargs=0 + 5 store_var 4 (_4) + 6 load_var 4 (_4) + 7 load_type 2 + 8 load_const 3 ("next") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 5 (_5) + 11 load_var 5 (_5) + 12 is_type 4 + 13 pop_jump_if_false +2 (to 15) + 14 jump +11 (to 25) + 15 load_var 5 (_5) + 16 store_var_load_var 6 (name) + + 1050 17 load_var 2 (out) + 18 call 765 ntypeargs=0 (testing.name_in) + 19 unary_op ! + 20 pop_jump_if_false -14 (to 6) + + 1051 21 load_var2 2 6 + 22 call 4 ntypeargs=0 (baml.Array.push) + 23 pop 1 + 24 jump -18 (to 6) + + 1054 25 load_var 1 (report) + 26 load_field 5 (results) + 27 load_type 5 + 28 load_const 6 ("iter") + 29 virtual_call nargs=1 ntypeargs=0 + 30 store_var 7 (_15) + 31 load_var 7 (_15) + 32 load_type 7 + 33 load_const 8 ("next") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 8 (_16) + 36 load_var 8 (_16) + 37 is_type 4 + 38 pop_jump_if_false +2 (to 40) + 39 jump +12 (to 51) + 40 load_var 8 (_16) + 41 store_var_load_var 9 (child) + + 1055 42 is_type 9 + 43 pop_jump_if_false +2 (to 45) + 44 jump -13 (to 31) + 45 load_var 9 (child) + 46 store_var_load_var 10 (nested) + + 1057 47 load_var 2 (out) + 48 call 768 ntypeargs=0 (testing.collect_all_failed_names) + 49 pop 1 + 50 jump -19 (to 31) + + 1048 51 load_const 10 (null) + 52 store_var 3 (_0) + 53 load_var 3 (_0) + 54 return +} + +function testing.collect_leaf_identities(report: testing.TestSetReport, tolerated_by_parent: bool, selected_names: string[], out: testing.LeafIdentities) -> void { + 993 0 load_var 1 (report) + 1 load_field 6 (result_names) + 2 store_var_load_var 5 (_5) + 3 load_const 0 (null) + 4 cmp_op == + 5 pop_jump_if_false +2 (to 7) + 6 jump +157 (to 163) + 7 load_var 5 (_5) + 8 store_var 6 (names) + + 996 9 load_var 6 (names) + 10 container_len + 11 store_var 8 (_10) + 12 load_var 1 (report) + 13 load_field 5 (results) + 14 container_len + 15 store_var 9 (_11) + 16 load_var2 8 9 + 17 cmp_int_op < + 18 pop_jump_if_false +2 (to 20) + 19 jump +6 (to 25) + + 999 20 load_var 1 (report) + 21 load_field 5 (results) + 22 container_len + 23 store_var 7 (limit) + 24 jump +4 (to 28) + + 997 25 load_var 6 (names) + 26 container_len + 27 store_var 7 (limit) + + 1001 28 load_const 1 (0) + 29 store_var 10 (i) + 30 load_var2 10 7 + 31 cmp_int_op < + 32 pop_jump_if_false +2 (to 34) + 33 jump +3 (to 36) + + 995 34 load_const 0 (null) + + 993 35 jump +129 (to 164) + + 1002 36 load_var2 6 10 + 37 load_array_element + 38 store_var 11 (name) + + 1003 39 load_var 1 (report) + 40 load_field 5 (results) + 41 load_var 10 (i) + 42 load_array_element + 43 store_var 12 (_22) + 44 load_var 12 (_22) + 45 store_var 13 (_25) + 46 load_var 13 (_25) + 47 narrow_bind 2 13 + 48 pop_jump_if_false +2 (to 50) + 49 jump +79 (to 128) + 50 load_var 12 (_22) + 51 store_var 15 (nested) + + 1014 52 load_var 2 (tolerated_by_parent) + 53 jump_if_false +3 (to 56) + 54 store_var 16 (nested_tolerated) + 55 jump +7 (to 62) + 56 pop 1 + 57 load_var 15 (nested) + 58 load_field 0 (outcome) + 59 load_const 3 ("pass") + 60 call 635 ntypeargs=0 (baml.ops.equals_equals) + 61 store_var 16 (nested_tolerated) + + 1015 62 load_var 15 (nested) + 63 load_field 5 (results) + 64 container_len + 65 store_var 17 (_42) + 66 load_var 17 (_42) + 67 load_const 1 (0) + 68 cmp_int_op > + 69 pop_jump_if_false +2 (to 71) + 70 jump +53 (to 123) + + 1022 71 load_var 15 (nested) + 72 load_field 2 (failed) + 73 load_const 1 (0) + 74 cmp_int_op > + 75 pop_jump_if_false +83 (to 158) + + 1023 76 load_var 11 (name) + 77 load_const 4 ("::(failed to expand)") + 78 bin_op + + 79 store_var_load_var 18 (sentinel) + + 1024 80 load_var 3 (selected_names) + 81 call 765 ntypeargs=0 (testing.name_in) + 82 pop_jump_if_false +2 (to 84) + 83 jump +21 (to 104) + + 1026 84 load_var 15 (nested) + 85 load_field 4 (failed_names) + 86 container_len + 87 store_var 20 (_54) + 88 load_var 20 (_54) + 89 load_const 1 (0) + 90 cmp_int_op > + 91 pop_jump_if_false +2 (to 93) + 92 jump +6 (to 98) + + 1029 93 load_var 11 (name) + 94 load_const 5 ("::(testset error)") + 95 bin_op + + 96 store_var 19 (identity) + + 1026 97 jump +9 (to 106) + + 1027 98 load_var 15 (nested) + 99 load_field 4 (failed_names) + 100 load_const 1 (0) + 101 load_array_element + 102 store_var 19 (identity) + + 1026 103 jump +3 (to 106) + + 1025 104 load_var 18 (sentinel) + 105 store_var 19 (identity) + + 1031 106 load_var 16 (nested_tolerated) + 107 pop_jump_if_false +2 (to 109) + 108 jump +8 (to 116) + + 1034 109 load_type 6 + 110 load_var 4 (out) + 111 load_field 1 (failed) + 112 load_var 19 (identity) + 113 call 4 ntypeargs=1 (baml.Array.push) + 114 pop 1 + 115 jump +43 (to 158) + + 1032 116 load_type 6 + 117 load_var 4 (out) + 118 load_field 2 (tolerated) + 119 load_var 19 (identity) + 120 call 4 ntypeargs=1 (baml.Array.push) + 121 pop 1 + 122 jump +36 (to 158) + + 1017 123 load_var2 15 16 + + 1018 124 load_var2 3 4 + 125 call 767 ntypeargs=0 (testing.collect_leaf_identities) + 126 pop 1 + 127 jump +31 (to 158) + + 1003 128 load_var 13 (_25) + 129 store_var_load_var 14 (leaf) + + 1005 130 load_field 0 (outcome) + 131 load_const 7 ("pass") + 132 call 635 ntypeargs=0 (baml.ops.equals_equals) + 133 pop_jump_if_false +2 (to 135) + 134 jump +18 (to 152) + + 1007 135 load_var 2 (tolerated_by_parent) + 136 pop_jump_if_false +2 (to 138) + 137 jump +8 (to 145) + + 1010 138 load_type 6 + 139 load_var 4 (out) + 140 load_field 1 (failed) + 141 load_var 11 (name) + 142 call 4 ntypeargs=1 (baml.Array.push) + 143 pop 1 + 144 jump +14 (to 158) + + 1008 145 load_type 6 + 146 load_var 4 (out) + 147 load_field 2 (tolerated) + 148 load_var 11 (name) + 149 call 4 ntypeargs=1 (baml.Array.push) + 150 pop 1 + 151 jump +7 (to 158) + + 1006 152 load_type 6 + 153 load_var 4 (out) + 154 load_field 0 (passed) + 155 load_var 11 (name) + 156 call 4 ntypeargs=1 (baml.Array.push) + 157 pop 1 + + 1001 158 load_var 10 (i) + 159 load_const 8 (1) + 160 add_int + 161 store_var 10 (i) + 162 jump -132 (to 30) + + 994 163 load_const 0 (null) + 164 return +} + +function testing.collect_leaf_messages(results: (testing.TestReport | testing.TestSetReport)[], out: string[]) -> void { + 1065 0 load_var 1 (results) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 4 (_3) + 5 load_var 4 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 5 (_4) + 10 load_var 5 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +51 (to 64) + 14 load_var 5 (_4) + 15 store_var 6 (r) + + 1066 16 load_var 6 (r) + 17 store_var 7 (_8) + 18 load_var 7 (_8) + 19 narrow_bind 5 7 + 20 pop_jump_if_false +2 (to 22) + 21 jump +8 (to 29) + 22 load_var 6 (r) + 23 store_var_load_var 14 (tsr) + + 1077 24 load_field 5 (results) + 25 load_var 2 (out) + 26 call 769 ntypeargs=0 (testing.collect_leaf_messages) + 27 pop 1 + 28 jump -23 (to 5) + + 1066 29 load_var 7 (_8) + 30 store_var_load_var 8 (tr) + + 1068 31 load_field 1 (runs) + 32 load_type 6 + 33 load_const 7 ("iter") + 34 virtual_call nargs=1 ntypeargs=0 + 35 store_var 9 (_11) + 36 load_var 9 (_11) + 37 load_type 8 + 38 load_const 9 ("next") + 39 virtual_call nargs=1 ntypeargs=0 + 40 store_var 10 (_12) + 41 load_var 10 (_12) + 42 is_type 4 + 43 pop_jump_if_false +2 (to 45) + 44 jump -39 (to 5) + 45 load_var 10 (_12) + 46 store_var_load_var 11 (run) + + 1069 47 load_field 0 (outcome) + 48 load_const 10 ("pass") + 49 call 635 ntypeargs=0 (baml.ops.equals_equals) + 50 unary_op ! + 51 pop_jump_if_false -15 (to 36) + + 1070 52 load_var 11 (run) + 53 load_field 2 (message) + 54 store_var 12 (_20) + 55 load_var 12 (_20) + 56 narrow_bind 11 12 + 57 pop_jump_if_false -21 (to 36) + 58 load_var 12 (_20) + 59 store_var 13 (m) + + 1071 60 load_var2 2 13 + 61 call 4 ntypeargs=0 (baml.Array.push) + 62 pop 1 + 63 jump -27 (to 36) + + 1064 64 load_const 12 (null) + 65 store_var 3 (_0) + 66 load_var 3 (_0) + 67 return +} + +function testing.collect_leaf_names(registry: testing.TestRegistry) -> string[] { + 744 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (out) + + 745 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 5 (_5) + 15 load_var 5 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +8 (to 26) + 19 load_var 5 (_5) + 20 store_var 6 (t) + + 746 21 load_var2 3 6 + 22 load_field 0 (name) + 23 call 4 ntypeargs=0 (baml.Array.push) + 24 pop 1 + 25 jump -15 (to 10) + + 748 26 load_var 1 (registry) + 27 load_field 0 (collector) + 28 load_field 2 (testsets) + 29 load_type 6 + 30 load_const 7 ("iter") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 7 (_12) + 33 load_var 7 (_12) + 34 load_type 8 + 35 load_const 9 ("next") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 8 (_13) + 38 load_var 8 (_13) + 39 is_type 5 + 40 pop_jump_if_false +2 (to 42) + 41 jump +24 (to 65) + 42 load_var 8 (_13) + 43 store_var 9 (ts) + + 749 44 load_var2 1 9 + 45 call 760 ntypeargs=0 (testing.collect_subtree_names) + 46 load_type 10 + 47 load_const 11 ("iter") + 48 virtual_call nargs=1 ntypeargs=0 + 49 store_var 10 (_19) + 50 load_var 10 (_19) + 51 load_type 12 + 52 load_const 13 ("next") + 53 virtual_call nargs=1 ntypeargs=0 + 54 store_var 11 (_20) + 55 load_var 11 (_20) + 56 is_type 5 + 57 pop_jump_if_false +2 (to 59) + 58 jump -25 (to 33) + 59 load_var 11 (_20) + 60 store_var 12 (name) + + 750 61 load_var2 3 12 + 62 call 4 ntypeargs=0 (baml.Array.push) + 63 pop 1 + 64 jump -14 (to 50) + + 753 65 load_var 3 (out) + 66 store_var 2 (_0) + 67 load_var 2 (_0) + 68 return +} + +function testing.collect_subtree_names(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> string[] { + 762 0 load_var2 1 2 + 1 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + 2 call 759 ntypeargs=0 (testing.collect_leaf_names) + 3 jump +91 (to 94) + 4 load_var 3 (e) + 5 store_var 4 (_5) + 6 load_var 4 (_5) + 7 narrow_bind 0 4 + 8 pop_jump_if_false +2 (to 10) + 9 jump +81 (to 90) + 10 load_var 3 (e) + 11 is_type 1 + 12 pop_jump_if_false +2 (to 14) + 13 jump +70 (to 83) + 14 load_var 3 (e) + 15 is_type 2 + 16 pop_jump_if_false +2 (to 18) + 17 jump +66 (to 83) + 18 load_var 3 (e) + 19 is_type 3 + 20 pop_jump_if_false +2 (to 22) + 21 jump +62 (to 83) + 22 load_var 3 (e) + 23 is_type 4 + 24 pop_jump_if_false +2 (to 26) + 25 jump +58 (to 83) + 26 load_var 3 (e) + 27 is_type 5 + 28 pop_jump_if_false +2 (to 30) + 29 jump +54 (to 83) + 30 load_var 3 (e) + 31 is_type 6 + 32 pop_jump_if_false +2 (to 34) + 33 jump +50 (to 83) + 34 load_var 3 (e) + 35 is_type 7 + 36 pop_jump_if_false +2 (to 38) + 37 jump +46 (to 83) + 38 load_var 3 (e) + 39 is_type 8 + 40 pop_jump_if_false +2 (to 42) + 41 jump +42 (to 83) + 42 load_var 3 (e) + 43 is_type 9 + 44 pop_jump_if_false +2 (to 46) + 45 jump +38 (to 83) + 46 load_var 3 (e) + 47 is_type 10 + 48 pop_jump_if_false +2 (to 50) + 49 jump +34 (to 83) + 50 load_var 3 (e) + 51 is_type 11 + 52 pop_jump_if_false +2 (to 54) + 53 jump +30 (to 83) + 54 load_var 3 (e) + 55 is_type 12 + 56 pop_jump_if_false +2 (to 58) + 57 jump +26 (to 83) + 58 load_var 3 (e) + 59 is_type 13 + 60 pop_jump_if_false +2 (to 62) + 61 jump +22 (to 83) + 62 load_var 3 (e) + 63 is_type 14 + 64 pop_jump_if_false +2 (to 66) + 65 jump +18 (to 83) + 66 load_var 3 (e) + 67 is_type 15 + 68 pop_jump_if_false +2 (to 70) + 69 jump +14 (to 83) + 70 load_var 3 (e) + 71 is_type 16 + 72 pop_jump_if_false +2 (to 74) + 73 jump +10 (to 83) + 74 load_var 3 (e) + 75 throw_if_panic + + 765 76 load_var 2 (ts) + 77 load_field 0 (name) + 78 load_const 17 ("::(failed to expand)") + 79 bin_op + + 80 load_type 18 + 81 alloc_array 1 + + 762 82 jump +12 (to 94) + + 764 83 load_var 2 (ts) + 84 load_field 0 (name) + 85 load_const 19 ("::(failed to expand)") + 86 bin_op + + 87 load_type 18 + 88 alloc_array 1 + + 762 89 jump +5 (to 94) + 90 load_var 4 (_5) + 91 store_var 5 (err) + + 763 92 load_var 5 (err) + 93 throw + 94 return +} + +function testing.collect_subtree_names_layered(registry: testing.TestRegistry, ts: testing.TestSetRegistration, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 778 0 load_var2 1 2 + 1 call 737 ntypeargs=0 (testing.TestRegistry.expand_testset_registry) + + 777 2 load_var2 3 4 + 3 load_var2 5 6 + 4 call 757 ntypeargs=0 (testing.select_names_layered) + 5 jump +111 (to 116) + 6 load_var 7 (e) + 7 store_var 8 (_9) + 8 load_var 8 (_9) + 9 narrow_bind 0 8 + 10 pop_jump_if_false +2 (to 12) + 11 jump +101 (to 112) + 12 load_var 7 (e) + 13 is_type 1 + 14 pop_jump_if_false +2 (to 16) + 15 jump +80 (to 95) + 16 load_var 7 (e) + 17 is_type 2 + 18 pop_jump_if_false +2 (to 20) + 19 jump +76 (to 95) + 20 load_var 7 (e) + 21 is_type 3 + 22 pop_jump_if_false +2 (to 24) + 23 jump +72 (to 95) + 24 load_var 7 (e) + 25 is_type 4 + 26 pop_jump_if_false +2 (to 28) + 27 jump +68 (to 95) + 28 load_var 7 (e) + 29 is_type 5 + 30 pop_jump_if_false +2 (to 32) + 31 jump +64 (to 95) + 32 load_var 7 (e) + 33 is_type 6 + 34 pop_jump_if_false +2 (to 36) + 35 jump +60 (to 95) + 36 load_var 7 (e) + 37 is_type 7 + 38 pop_jump_if_false +2 (to 40) + 39 jump +56 (to 95) + 40 load_var 7 (e) + 41 is_type 8 + 42 pop_jump_if_false +2 (to 44) + 43 jump +52 (to 95) + 44 load_var 7 (e) + 45 is_type 9 + 46 pop_jump_if_false +2 (to 48) + 47 jump +48 (to 95) + 48 load_var 7 (e) + 49 is_type 10 + 50 pop_jump_if_false +2 (to 52) + 51 jump +44 (to 95) + 52 load_var 7 (e) + 53 is_type 11 + 54 pop_jump_if_false +2 (to 56) + 55 jump +40 (to 95) + 56 load_var 7 (e) + 57 is_type 12 + 58 pop_jump_if_false +2 (to 60) + 59 jump +36 (to 95) + 60 load_var 7 (e) + 61 is_type 13 + 62 pop_jump_if_false +2 (to 64) + 63 jump +32 (to 95) + 64 load_var 7 (e) + 65 is_type 14 + 66 pop_jump_if_false +2 (to 68) + 67 jump +28 (to 95) + 68 load_var 7 (e) + 69 is_type 15 + 70 pop_jump_if_false +2 (to 72) + 71 jump +24 (to 95) + 72 load_var 7 (e) + 73 is_type 16 + 74 pop_jump_if_false +2 (to 76) + 75 jump +20 (to 95) + 76 load_var 7 (e) + 77 throw_if_panic + + 802 78 load_var 2 (ts) + 79 load_field 0 (name) + 80 load_const 17 ("::(failed to expand)") + 81 bin_op + + 82 store_var_load_var 11 (sentinel) + + 805 83 load_var2 3 4 + 84 load_var2 5 6 + 85 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 803 86 pop_jump_if_false +2 (to 88) + 87 jump +4 (to 91) + + 814 88 load_type 18 + 89 alloc_array 0 + + 803 90 jump +26 (to 116) + + 812 91 load_var 11 (sentinel) + 92 load_type 18 + 93 alloc_array 1 + + 803 94 jump +22 (to 116) + + 786 95 load_var 2 (ts) + 96 load_field 0 (name) + 97 load_const 19 ("::(failed to expand)") + 98 bin_op + + 99 store_var_load_var 10 (sentinel) + + 789 100 load_var2 3 4 + 101 load_var2 5 6 + 102 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 787 103 pop_jump_if_false +2 (to 105) + 104 jump +4 (to 108) + + 798 105 load_type 18 + 106 alloc_array 0 + + 787 107 jump +9 (to 116) + + 796 108 load_var 10 (sentinel) + 109 load_type 18 + 110 alloc_array 1 + + 787 111 jump +5 (to 116) + + 777 112 load_var 8 (_9) + 113 store_var 9 (err) + + 784 114 load_var 9 (err) + 115 throw + 116 return +} + +function testing.count_leaves(results: (testing.TestReport | testing.TestSetReport)[], tolerated_by_parent: bool) -> testing.LeafCounts { + 838 0 load_const 0 (0) + 1 store_var 3 (passed) + + 839 2 load_const 0 (0) + 3 store_var 4 (failed) + + 840 4 load_const 0 (0) + 5 store_var 5 (tolerated) + + 841 6 load_const 0 (0) + 7 store_var 6 (total) + + 842 8 load_var 1 (results) + 9 load_type 1 + 10 load_const 2 ("iter") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 7 (_7) + 13 load_var 7 (_7) + 14 load_type 3 + 15 load_const 4 ("next") + 16 virtual_call nargs=1 ntypeargs=0 + 17 store_var 8 (_8) + 18 load_var 8 (_8) + 19 is_type 5 + 20 pop_jump_if_false +2 (to 22) + 21 jump +106 (to 127) + 22 load_var 8 (_8) + 23 store_var 9 (r) + + 843 24 load_var 9 (r) + 25 store_var 11 (_13) + 26 load_var 11 (_13) + 27 narrow_bind 6 11 + 28 pop_jump_if_false +2 (to 30) + 29 jump +51 (to 80) + 30 load_var 9 (r) + 31 store_var 13 (tsr) + + 854 32 load_var 2 (tolerated_by_parent) + 33 jump_if_false +3 (to 36) + 34 store_var 14 (ft) + 35 jump +7 (to 42) + 36 pop 1 + 37 load_var 13 (tsr) + 38 load_field 0 (outcome) + 39 load_const 7 ("pass") + 40 call 635 ntypeargs=0 (baml.ops.equals_equals) + 41 store_var 14 (ft) + + 855 42 load_var 13 (tsr) + 43 load_field 5 (results) + 44 container_len + 45 store_var 15 (_21) + 46 load_var 15 (_21) + 47 load_const 0 (0) + 48 cmp_int_op > + 49 pop_jump_if_false +2 (to 51) + 50 jump +24 (to 74) + + 857 51 load_var 14 (ft) + 52 pop_jump_if_false +2 (to 54) + 53 jump +11 (to 64) + + 866 54 load_var 13 (tsr) + 55 load_field 1 (passed) + + 867 56 load_var 13 (tsr) + 57 load_field 2 (failed) + 58 load_const 0 (0) + + 869 59 load_var 13 (tsr) + 60 load_field 3 (total) + 61 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 62 store_var 10 (delta) + + 857 63 jump +47 (to 110) + + 859 64 load_var 13 (tsr) + 65 load_field 1 (passed) + 66 load_const 0 (0) + + 861 67 load_var 13 (tsr) + 68 load_field 2 (failed) + + 862 69 load_var 13 (tsr) + 70 load_field 3 (total) + 71 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 72 store_var 10 (delta) + + 857 73 jump +37 (to 110) + + 856 74 load_var 13 (tsr) + 75 load_field 5 (results) + 76 load_var 14 (ft) + 77 call 762 ntypeargs=0 (testing.count_leaves) + 78 store_var 10 (delta) + 79 jump +31 (to 110) + + 843 80 load_var 11 (_13) + 81 store_var_load_var 12 (tr) + + 845 82 load_field 0 (outcome) + 83 load_const 8 ("pass") + 84 call 635 ntypeargs=0 (baml.ops.equals_equals) + 85 pop_jump_if_false +2 (to 87) + 86 jump +18 (to 104) + + 847 87 load_var 2 (tolerated_by_parent) + 88 pop_jump_if_false +2 (to 90) + 89 jump +8 (to 97) + + 850 90 load_const 0 (0) + 91 load_const 9 (1) + 92 load_const 0 (0) + 93 load_const 9 (1) + 94 init_instance 2 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 95 store_var 10 (delta) + + 847 96 jump +14 (to 110) + + 848 97 load_const 0 (0) + 98 load_const 0 (0) + 99 load_const 9 (1) + 100 load_const 9 (1) + 101 init_instance 3 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 102 store_var 10 (delta) + + 847 103 jump +7 (to 110) + + 846 104 load_const 9 (1) + 105 load_const 0 (0) + 106 load_const 0 (0) + 107 load_const 9 (1) + 108 init_instance 4 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 109 store_var 10 (delta) + + 874 110 load_var2 3 10 + 111 load_field 0 (passed) + 112 add_int + 113 store_var 3 (passed) + + 875 114 load_var2 4 10 + 115 load_field 1 (failed) + 116 add_int + 117 store_var 4 (failed) + + 876 118 load_var2 5 10 + 119 load_field 2 (tolerated) + 120 add_int + 121 store_var 5 (tolerated) + + 877 122 load_var2 6 10 + 123 load_field 3 (total) + 124 add_int + 125 store_var 6 (total) + + 842 126 jump -113 (to 13) + + 879 127 load_var2 3 4 + 128 load_var2 5 6 + 129 init_instance 5 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 130 return +} + +function testing.expansion_error_report(name: string) -> testing.TestSetReport { + 553 0 load_const 0 ("error") + 1 load_const 1 (0) + 2 load_const 2 (1) + 3 load_const 2 (1) + + 564 4 load_var 1 (name) + 5 load_const 3 ("::(testset error)") + 6 bin_op + + 7 load_type 4 + 8 alloc_array 1 + + 565 9 load_type 5 + 10 alloc_array 0 + + 566 11 load_type 4 + 12 alloc_array 0 + 13 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .failed_names, .results, .result_names) + 14 store_var 2 (_0) + 15 load_var 2 (_0) + 16 return +} + +function testing.failure_matches_selected(selected: string, failed_names: string[]) -> bool { + 972 0 load_var2 1 2 + 1 call 765 ntypeargs=0 (testing.name_in) + 2 pop_jump_if_false +2 (to 4) + 3 jump +43 (to 46) + + 975 4 load_const 0 ("::(failed to expand)") + 5 store_var 3 (sentinel_suffix) + + 976 6 load_var2 1 3 + 7 call 149 ntypeargs=0 (baml.String.ends_with) + 8 pop_jump_if_false +36 (to 44) + + 977 9 load_var 1 (selected) + 10 call 139 ntypeargs=0 (baml.String.length) + 11 store_var 5 (_10) + 12 load_var 3 (sentinel_suffix) + 13 call 139 ntypeargs=0 (baml.String.length) + 14 store_var 6 (_11) + 15 load_var 1 (selected) + 16 load_const 1 (0) + 17 load_var2 5 6 + 18 sub_int + 19 call 153 ntypeargs=0 (baml.String.substring) + 20 load_const 2 ("::") + 21 bin_op + + 22 store_var 4 (prefix) + + 978 23 load_var 2 (failed_names) + 24 load_type 3 + 25 load_const 4 ("iter") + 26 virtual_call nargs=1 ntypeargs=0 + 27 store_var 7 (_12) + 28 load_var 7 (_12) + 29 load_type 5 + 30 load_const 6 ("next") + 31 virtual_call nargs=1 ntypeargs=0 + 32 store_var 8 (_13) + 33 load_var 8 (_13) + 34 is_type 7 + 35 pop_jump_if_false +2 (to 37) + 36 jump +8 (to 44) + 37 load_var 8 (_13) + 38 store_var 9 (failed) + + 979 39 load_var2 9 4 + 40 call 148 ntypeargs=0 (baml.String.starts_with) + 41 pop_jump_if_false -13 (to 28) + + 980 42 load_const 8 (true) + 43 jump +4 (to 47) + + 984 44 load_const 9 (false) + 45 jump +2 (to 47) + + 973 46 load_const 8 (true) + 47 return +} + +function testing.flatten_with_tolerated(report: testing.TestSetReport, selected_names: string[]) -> testing.FlatTestReport { + 887 0 load_var 1 (report) + 1 load_field 0 (outcome) + 2 load_const 0 ("pass") + 3 call 635 ntypeargs=0 (baml.ops.equals_equals) + 4 store_var 3 (top_tolerated) + + 888 5 load_var 1 (report) + 6 load_field 5 (results) + 7 container_len + 8 store_var 5 (_7) + 9 load_var 5 (_7) + 10 load_const 1 (0) + 11 cmp_int_op > + 12 pop_jump_if_false +2 (to 14) + 13 jump +24 (to 37) + + 890 14 load_var 3 (top_tolerated) + 15 pop_jump_if_false +2 (to 17) + 16 jump +11 (to 27) + + 899 17 load_var 1 (report) + 18 load_field 1 (passed) + + 900 19 load_var 1 (report) + 20 load_field 2 (failed) + 21 load_const 1 (0) + + 902 22 load_var 1 (report) + 23 load_field 3 (total) + 24 init_instance 0 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 25 store_var 4 (counts) + + 890 26 jump +16 (to 42) + + 892 27 load_var 1 (report) + 28 load_field 1 (passed) + 29 load_const 1 (0) + + 894 30 load_var 1 (report) + 31 load_field 2 (failed) + + 895 32 load_var 1 (report) + 33 load_field 3 (total) + 34 init_instance 1 (testing.LeafCounts .passed, .failed, .tolerated, .total) + 35 store_var 4 (counts) + + 890 36 jump +6 (to 42) + + 889 37 load_var 1 (report) + 38 load_field 5 (results) + 39 load_var 3 (top_tolerated) + 40 call 762 ntypeargs=0 (testing.count_leaves) + 41 store_var 4 (counts) + + 905 42 load_type 2 + 43 alloc_array 0 + 44 store_var 6 (messages) + + 906 45 load_var 1 (report) + 46 load_field 5 (results) + 47 load_var 6 (messages) + 48 call 769 ntypeargs=0 (testing.collect_leaf_messages) + 49 pop 1 + + 907 50 load_type 2 + 51 alloc_array 0 + 52 store_var 7 (all_failed_names) + + 908 53 load_var2 1 7 + 54 call 768 ntypeargs=0 (testing.collect_all_failed_names) + 55 pop 1 + + 909 56 load_type 2 + 57 alloc_array 0 + 58 load_type 2 + 59 alloc_array 0 + 60 load_type 2 + 61 alloc_array 0 + 62 init_instance 2 (testing.LeafIdentities .passed, .failed, .tolerated) + 63 store_var 8 (executed) + + 910 64 load_var2 1 3 + 65 load_var2 2 8 + 66 call 767 ntypeargs=0 (testing.collect_leaf_identities) + 67 pop 1 + + 916 68 load_var 8 (executed) + 69 load_field 0 (passed) + 70 container_len + 71 store_var 10 (_36) + 72 load_var2 10 4 + 73 load_field 0 (passed) + 74 cmp_int_op == + 75 jump_if_false +9 (to 84) + 76 pop 1 + + 917 77 load_var 8 (executed) + 78 load_field 1 (failed) + 79 container_len + 80 store_var 11 (_39) + 81 load_var2 11 4 + 82 load_field 1 (failed) + 83 cmp_int_op == + + 916 84 jump_if_false +9 (to 93) + 85 pop 1 + + 918 86 load_var 8 (executed) + 87 load_field 2 (tolerated) + 88 container_len + 89 store_var 12 (_42) + 90 load_var2 12 4 + 91 load_field 2 (tolerated) + 92 cmp_int_op == + + 915 93 pop_jump_if_false +2 (to 95) + 94 jump +24 (to 118) + + 921 95 load_var 2 (selected_names) + 96 container_len + 97 store_var 13 (_46) + 98 load_var2 13 4 + 99 load_field 3 (total) + 100 cmp_int_op == + 101 pop_jump_if_false +2 (to 103) + 102 jump +10 (to 112) + + 927 103 load_type 2 + 104 alloc_array 0 + 105 load_type 2 + 106 alloc_array 0 + 107 load_type 2 + 108 alloc_array 0 + 109 init_instance 3 (testing.LeafIdentities .passed, .failed, .tolerated) + 110 store_var 9 (identities) + + 921 111 jump +9 (to 120) + + 922 112 load_var2 2 1 + 113 load_field 4 (failed_names) + 114 load_var 7 (all_failed_names) + 115 call 764 ntypeargs=0 (testing.classify_selected_names) + 116 store_var 9 (identities) + 117 jump +3 (to 120) + + 920 118 load_var 8 (executed) + 119 store_var 9 (identities) + + 930 120 load_var 1 (report) + 121 load_field 0 (outcome) + + 931 122 load_var 4 (counts) + 123 load_field 0 (passed) + + 932 124 load_var 4 (counts) + 125 load_field 1 (failed) + + 933 126 load_var 4 (counts) + 127 load_field 2 (tolerated) + + 934 128 load_var 4 (counts) + 129 load_field 3 (total) + + 935 130 load_var 9 (identities) + 131 load_field 0 (passed) + + 936 132 load_var 9 (identities) + 133 load_field 1 (failed) + + 937 134 load_var 9 (identities) + 135 load_field 2 (tolerated) + + 938 136 load_var 6 (messages) + 137 init_instance 4 (testing.FlatTestReport .outcome, .passed, .failed, .tolerated, .total, .passed_names, .failed_names, .tolerated_names, .messages) + 138 return +} + +function testing.glob_match(subject: string, pattern: string) -> bool { + 574 0 load_var 2 (pattern) + 1 load_const 0 ("*") + 2 call 150 ntypeargs=0 (baml.String.split) + 3 store_var 3 (parts) + + 575 4 load_var 3 (parts) + 5 container_len + 6 store_var 4 (n) + + 576 7 load_var 4 (n) + 8 load_const 1 (1) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +87 (to 98) + + 579 12 load_var 3 (parts) + 13 load_const 2 (0) + 14 load_array_element + 15 store_var 5 (first) + + 580 16 load_var2 3 4 + 17 load_const 1 (1) + 18 sub_int + 19 load_array_element + 20 store_var 6 (last) + + 581 21 load_var2 1 5 + 22 call 148 ntypeargs=0 (baml.String.starts_with) + 23 unary_op ! + 24 pop_jump_if_false +2 (to 26) + 25 jump +71 (to 96) + + 584 26 load_var2 1 6 + 27 call 149 ntypeargs=0 (baml.String.ends_with) + 28 unary_op ! + 29 pop_jump_if_false +2 (to 31) + 30 jump +64 (to 94) + + 587 31 load_var 5 (first) + 32 call 139 ntypeargs=0 (baml.String.length) + 33 store_var 7 (start) + + 588 34 load_var 1 (subject) + 35 call 139 ntypeargs=0 (baml.String.length) + 36 store_var 9 (_24) + 37 load_var 6 (last) + 38 call 139 ntypeargs=0 (baml.String.length) + 39 store_var 10 (_25) + 40 load_var2 9 10 + 41 sub_int + 42 store_var 8 (end_limit) + + 589 43 load_var2 7 8 + 44 cmp_int_op > + 45 pop_jump_if_false +2 (to 47) + 46 jump +46 (to 92) + + 592 47 load_var 7 (start) + 48 store_var 11 (pos) + + 593 49 load_const 1 (1) + 50 store_var 12 (i) + 51 load_var2 12 4 + 52 load_const 1 (1) + 53 sub_int + 54 cmp_int_op < + 55 pop_jump_if_false +2 (to 57) + 56 jump +3 (to 59) + + 603 57 load_const 3 (true) + 58 jump +45 (to 103) + + 594 59 load_var2 3 12 + 60 load_array_element + 61 store_var_load_var 13 (part) + + 595 62 load_const 4 ("") + 63 cmp_op != + 64 pop_jump_if_false +23 (to 87) + + 596 65 load_var2 1 11 + 66 load_var 8 (end_limit) + 67 call 153 ntypeargs=0 (baml.String.substring) + 68 load_var 13 (part) + 69 call 155 ntypeargs=0 (baml.String.index_of) + 70 store_var 14 (_45) + 71 load_var 14 (_45) + 72 narrow_bind 2 14 + 73 pop_jump_if_false +2 (to 75) + 74 jump +3 (to 77) + + 599 75 load_const 5 (false) + 76 jump +27 (to 103) + + 596 77 load_var 14 (_45) + 78 store_var 15 (idx) + + 597 79 load_var2 11 15 + 80 add_int + 81 store_var 16 (_47) + 82 load_var 13 (part) + 83 call 139 ntypeargs=0 (baml.String.length) + 84 load_var 16 (_47) + 85 add_int + 86 store_var 11 (pos) + + 593 87 load_var 12 (i) + 88 load_const 1 (1) + 89 add_int + 90 store_var 12 (i) + 91 jump -40 (to 51) + + 590 92 load_const 5 (false) + 93 jump +10 (to 103) + + 585 94 load_const 5 (false) + 95 jump +8 (to 103) + + 582 96 load_const 5 (false) + 97 jump +6 (to 103) + + 577 98 load_var2 1 2 + 99 call 155 ntypeargs=0 (baml.String.index_of) + 100 load_const 6 (null) + 101 call 635 ntypeargs=0 (baml.ops.equals_equals) + 102 unary_op ! + 103 return +} + +function testing.leaf_selected(name: string, include: string[], exclude: string[]) -> bool { + 618 0 load_var2 3 1 + 1 call 751 ntypeargs=0 (testing.any_pattern_matches) + 2 pop_jump_if_false +2 (to 4) + 3 jump +14 (to 17) + + 621 4 load_var 2 (include) + 5 container_len + 6 store_var 4 (_6) + 7 load_var 4 (_6) + 8 load_const 0 (0) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +4 (to 15) + + 624 12 load_var2 2 1 + 13 call 751 ntypeargs=0 (testing.any_pattern_matches) + 14 jump +4 (to 18) + + 622 15 load_const 1 (true) + 16 jump +2 (to 18) + + 619 17 load_const 2 (false) + 18 return +} + +function testing.leaf_selected_layered(name: string, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> bool { + 637 0 load_var2 1 2 + 1 load_var 3 (profile_exclude) + 2 call 752 ntypeargs=0 (testing.leaf_selected) + 3 jump_if_false +5 (to 8) + 4 pop 1 + + 638 5 load_var2 1 4 + 6 load_var 5 (cli_exclude) + 7 call 752 ntypeargs=0 (testing.leaf_selected) + 8 return +} + +function testing.name_in(name: string, names: string[]) -> bool { + 963 0 load_var 2 (names) + 1 load_type 0 + 2 load_const 1 ("iter") + 3 virtual_call nargs=1 ntypeargs=0 + 4 store_var 3 (_3) + 5 load_var 3 (_3) + 6 load_type 2 + 7 load_const 3 ("next") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 is_type 4 + 12 pop_jump_if_false +2 (to 14) + 13 jump +8 (to 21) + 14 load_var 4 (_4) + 15 store_var_load_var 5 (candidate) + + 964 16 load_var 1 (name) + 17 cmp_op == + 18 pop_jump_if_false -13 (to 5) + + 965 19 load_const 5 (true) + 20 jump +2 (to 22) + + 968 21 load_const 6 (false) + 22 return +} + +function testing.pattern_may_match_descendant(pattern: string, prefix: string) -> bool { + 666 0 load_var 2 (prefix) + 1 load_const 0 ("::") + 2 bin_op + + 3 store_var 3 (descendant_prefix) + + 667 4 load_var 1 (pattern) + 5 load_const 1 ("*") + 6 call 155 ntypeargs=0 (baml.String.index_of) + 7 store_var 4 (_4) + 8 load_var 4 (_4) + 9 load_const 2 (null) + 10 cmp_op == + 11 pop_jump_if_false +2 (to 13) + 12 jump +16 (to 28) + 13 load_var 4 (_4) + 14 store_var 5 (star) + + 670 15 load_var 1 (pattern) + 16 load_const 3 (0) + 17 load_var 5 (star) + 18 call 153 ntypeargs=0 (baml.String.substring) + 19 store_var 6 (literal) + + 671 20 load_var2 3 6 + 21 call 148 ntypeargs=0 (baml.String.starts_with) + 22 jump_if_false +2 (to 24) + 23 jump +6 (to 29) + 24 pop 1 + 25 load_var2 6 3 + 26 call 148 ntypeargs=0 (baml.String.starts_with) + 27 jump +2 (to 29) + + 668 28 load_const 4 (true) + 29 return +} + +function testing.run_children_parallel(children: testing.TestSetChild[]) -> testing.TestSetReport { + 0 load_var 5 + 1 make_cell + 2 store_var 5 + + 484 3 load_type 0 + 4 alloc_array 0 + 5 store_var 2 (futures) + + 485 6 load_var 1 (children) + 7 load_type 1 + 8 load_const 2 ("iter") + 9 virtual_call nargs=1 ntypeargs=0 + 10 store_var 3 (_3) + 11 load_var 3 (_3) + 12 load_type 3 + 13 load_const 4 ("next") + 14 virtual_call nargs=1 ntypeargs=0 + 15 store_var 4 (_4) + 16 load_var 4 (_4) + 17 is_type 5 + 18 pop_jump_if_false +2 (to 20) + 19 jump +18 (to 37) + 20 load_const 6 (null) + 21 make_cell + 22 store_var 5 (child) + 23 load_var 4 (_4) + 24 store_deref 5 + + 486 25 load_var 5 (child) + 26 make_closure 1473 1 + 27 load_const 6 (null) + 28 load_const 6 (null) + 29 load_type 7 + 30 load_type 8 + 31 spawn + 32 store_var 6 (_11) + 33 load_var2 2 6 + 34 call 4 ntypeargs=0 (baml.Array.push) + 35 pop 1 + 36 jump -25 (to 11) + + 490 37 load_type 7 + 38 load_type 8 + 39 load_var 2 (futures) + 40 call 484 ntypeargs=2 (baml.future.all_complete) + 41 await + + 491 42 call 745 ntypeargs=0 (testing.aggregate_reports) + 43 return +} + +function testing.run_children_sequential(children: testing.TestSetChild[], fail_fast: bool) -> testing.TestSetReport { + 110 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (named_results) + + 111 3 load_var 1 (children) + 4 load_type 1 + 5 load_const 2 ("iter") + 6 virtual_call nargs=1 ntypeargs=0 + 7 store_var 4 (_4) + 8 load_var 4 (_4) + 9 load_type 3 + 10 load_const 4 ("next") + 11 virtual_call nargs=1 ntypeargs=0 + 12 store_var 5 (_5) + 13 load_var 5 (_5) + 14 is_type 5 + 15 pop_jump_if_false +2 (to 17) + 16 jump +40 (to 56) + 17 load_var 5 (_5) + 18 store_var_load_var 6 (child) + + 112 19 load_field 1 (run) + 20 call_indirect + 21 store_var 7 (report) + + 113 22 load_var2 3 6 + 23 load_field 0 (name) + 24 load_var 7 (report) + 25 init_instance 0 (testing.NamedChildReport .name, .report) + 26 call 4 ntypeargs=0 (baml.Array.push) + 27 pop 1 + + 114 28 load_var 7 (report) + 29 store_var 9 (_16) + 30 load_var 9 (_16) + 31 narrow_bind 6 9 + 32 pop_jump_if_false +2 (to 34) + 33 jump +7 (to 40) + 34 load_var 7 (report) + 35 store_var 11 (r) + + 116 36 load_var 11 (r) + 37 load_field 0 (outcome) + 38 store_var 8 (outcome) + + 114 39 jump +6 (to 45) + 40 load_var 9 (_16) + 41 store_var 10 (r) + + 115 42 load_var 10 (r) + 43 load_field 0 (outcome) + 44 store_var 8 (outcome) + + 118 45 load_var 2 (fail_fast) + 46 jump_if_false +6 (to 52) + 47 pop 1 + 48 load_var 8 (outcome) + 49 load_const 7 ("pass") + 50 call 635 ntypeargs=0 (baml.ops.equals_equals) + 51 unary_op ! + 52 pop_jump_if_false -44 (to 8) + + 119 53 load_var 3 (named_results) + 54 call 745 ntypeargs=0 (testing.aggregate_reports) + 55 jump +3 (to 58) + + 124 56 load_var 3 (named_results) + 57 call 745 ntypeargs=0 (testing.aggregate_reports) + 58 return +} + +function testing.run_test(body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestReport { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + + 496 3 load_var 1 (body) + 4 make_closure 1485 1 + 5 store_var 3 (base_run) + + 527 6 load_var 2 (runner) + 7 load_const 0 (null) + 8 cmp_op == + 9 pop_jump_if_false +2 (to 11) + 10 jump +7 (to 17) + 11 load_var 2 (runner) + 12 store_var 4 (r) + + 530 13 load_var2 3 4 + 14 call_indirect + + 531 15 call_indirect + 16 jump +3 (to 19) + + 528 17 load_var 3 (base_run) + 18 call_indirect + 19 return +} + +function testing.run_testset(children: testing.TestSetChild[], runner: ((testing.TestSetChild[]) -> testing.TestSetReport throws never) | null) -> testing.TestSetReport { + 538 0 load_var 2 (runner) + 1 load_const 0 (null) + 2 cmp_op == + 3 pop_jump_if_false +2 (to 5) + 4 jump +6 (to 10) + 5 load_var 2 (runner) + 6 store_var 3 (r) + + 540 7 load_var2 1 3 + 8 call_indirect + 9 jump +3 (to 12) + + 539 10 load_var 1 (children) + 11 call 746 ntypeargs=0 (testing.run_children_parallel) + 12 return +} + +function testing.select_names(registry: testing.TestRegistry, include: string[], exclude: string[]) -> string[] { + 739 0 load_var 1 (registry) + 1 load_type 0 + 2 alloc_array 0 + 3 load_type 0 + 4 alloc_array 0 + 5 load_var2 2 3 + 6 call 757 ntypeargs=0 (testing.select_names_layered) + 7 return +} + +function testing.select_names_layered(registry: testing.TestRegistry, profile_include: string[], profile_exclude: string[], cli_include: string[], cli_exclude: string[]) -> string[] { + 700 0 load_type 0 + 1 alloc_array 0 + 2 store_var 7 (out) + + 701 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 8 (_8) + 10 load_var 8 (_8) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 9 (_9) + 15 load_var 9 (_9) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +13 (to 31) + 19 load_var 9 (_9) + 20 store_var_load_var 10 (t) + + 704 21 load_field 0 (name) + 22 load_var2 2 3 + 23 load_var2 4 5 + 24 call 753 ntypeargs=0 (testing.leaf_selected_layered) + + 702 25 pop_jump_if_false -15 (to 10) + + 711 26 load_var2 7 10 + 27 load_field 0 (name) + 28 call 4 ntypeargs=0 (baml.Array.push) + 29 pop 1 + 30 jump -20 (to 10) + + 714 31 load_var 1 (registry) + 32 load_field 0 (collector) + 33 load_field 2 (testsets) + 34 load_type 6 + 35 load_const 7 ("iter") + 36 virtual_call nargs=1 ntypeargs=0 + 37 store_var 11 (_18) + 38 load_var 11 (_18) + 39 load_type 8 + 40 load_const 9 ("next") + 41 virtual_call nargs=1 ntypeargs=0 + 42 store_var 12 (_19) + 43 load_var 12 (_19) + 44 is_type 5 + 45 pop_jump_if_false +2 (to 47) + 46 jump +36 (to 82) + 47 load_var 12 (_19) + 48 store_var_load_var 13 (ts) + + 718 49 load_field 0 (name) + 50 load_var2 2 3 + 51 call 756 ntypeargs=0 (testing.subtree_may_be_selected) + 52 jump_if_false +6 (to 58) + 53 pop 1 + + 719 54 load_var 13 (ts) + 55 load_field 0 (name) + 56 load_var2 4 5 + 57 call 756 ntypeargs=0 (testing.subtree_may_be_selected) + + 717 58 pop_jump_if_false -20 (to 38) + + 721 59 load_var2 1 13 + + 723 60 load_var2 2 3 + 61 load_var2 4 5 + 62 call 761 ntypeargs=0 (testing.collect_subtree_names_layered) + + 729 63 load_type 10 + 64 load_const 11 ("iter") + 65 virtual_call nargs=1 ntypeargs=0 + 66 store_var 14 (_30) + 67 load_var 14 (_30) + 68 load_type 12 + 69 load_const 13 ("next") + 70 virtual_call nargs=1 ntypeargs=0 + 71 store_var 15 (_31) + 72 load_var 15 (_31) + 73 is_type 5 + 74 pop_jump_if_false +2 (to 76) + 75 jump -37 (to 38) + 76 load_var 15 (_31) + 77 store_var 16 (name) + + 730 78 load_var2 7 16 + 79 call 4 ntypeargs=0 (baml.Array.push) + 80 pop 1 + 81 jump -14 (to 67) + + 734 82 load_var 7 (out) + 83 store_var 6 (_0) + 84 load_var 6 (_0) + 85 return +} + +function testing.subtree_excluded(prefix: string, excludes: string[]) -> bool { + 645 0 load_var 1 (prefix) + 1 load_const 0 ("::") + 2 bin_op + + 3 store_var 3 (descendant_prefix) + + 646 4 load_var 2 (excludes) + 5 load_type 1 + 6 load_const 2 ("iter") + 7 virtual_call nargs=1 ntypeargs=0 + 8 store_var 4 (_4) + 9 load_var 4 (_4) + 10 load_type 3 + 11 load_const 4 ("next") + 12 virtual_call nargs=1 ntypeargs=0 + 13 store_var 5 (_5) + 14 load_var 5 (_5) + 15 is_type 5 + 16 pop_jump_if_false +2 (to 18) + 17 jump +29 (to 46) + 18 load_var 5 (_5) + 19 store_var 6 (pattern) + + 649 20 load_var 6 (pattern) + 21 load_const 6 ("*") + 22 call 155 ntypeargs=0 (baml.String.index_of) + 23 load_const 7 (null) + 24 call 635 ntypeargs=0 (baml.ops.equals_equals) + 25 jump_if_false +7 (to 32) + 26 pop 1 + 27 load_var2 3 6 + 28 call 155 ntypeargs=0 (baml.String.index_of) + 29 load_const 7 (null) + 30 call 635 ntypeargs=0 (baml.ops.equals_equals) + 31 unary_op ! + 32 pop_jump_if_false +2 (to 34) + 33 jump +11 (to 44) + + 654 34 load_var 6 (pattern) + 35 load_const 8 ("*") + 36 call 149 ntypeargs=0 (baml.String.ends_with) + 37 jump_if_false +4 (to 41) + 38 pop 1 + 39 load_var2 3 6 + 40 call 750 ntypeargs=0 (testing.glob_match) + 41 pop_jump_if_false -32 (to 9) + + 655 42 load_const 9 (true) + 43 jump +4 (to 47) + + 650 44 load_const 9 (true) + 45 jump +2 (to 47) + + 658 46 load_const 10 (false) + 47 return +} + +function testing.subtree_may_be_selected(prefix: string, include: string[], exclude: string[]) -> bool { + 677 0 load_var2 1 3 + 1 call 754 ntypeargs=0 (testing.subtree_excluded) + 2 pop_jump_if_false +2 (to 4) + 3 jump +34 (to 37) + + 680 4 load_var 2 (include) + 5 container_len + 6 store_var 4 (_6) + 7 load_var 4 (_6) + 8 load_const 0 (0) + 9 cmp_int_op == + 10 pop_jump_if_false +2 (to 12) + 11 jump +24 (to 35) + + 683 12 load_var 2 (include) + 13 load_type 1 + 14 load_const 2 ("iter") + 15 virtual_call nargs=1 ntypeargs=0 + 16 store_var 5 (_7) + 17 load_var 5 (_7) + 18 load_type 3 + 19 load_const 4 ("next") + 20 virtual_call nargs=1 ntypeargs=0 + 21 store_var 6 (_8) + 22 load_var 6 (_8) + 23 is_type 5 + 24 pop_jump_if_false +2 (to 26) + 25 jump +8 (to 33) + 26 load_var 6 (_8) + 27 store_var_load_var 7 (pattern) + + 684 28 load_var 1 (prefix) + 29 call 755 ntypeargs=0 (testing.pattern_may_match_descendant) + 30 pop_jump_if_false -13 (to 17) + + 685 31 load_const 6 (true) + 32 jump +6 (to 38) + + 688 33 load_const 7 (false) + 34 jump +4 (to 38) + + 681 35 load_const 6 (true) + 36 jump +2 (to 38) + + 678 37 load_const 7 (false) + 38 return +} + +function testing.test_child(name: string, body: () -> void throws unknown, runner: ((() -> testing.TestReport throws never) -> (() -> testing.TestReport throws never) throws never) | null) -> testing.TestSetChild { + 0 load_var 2 + 1 make_cell + 2 store_var 2 + 3 load_var 3 + 4 make_cell + 5 store_var 3 + + 364 6 load_var2 1 2 + + 366 7 load_var 3 (runner) + 8 make_closure 1450 2 + 9 init_instance 0 (testing.TestSetChild .name, .run) + 10 store_var 4 (_0) + 11 load_var 4 (_0) + 12 return +} + +function testing.testset_child(registry: testing.TestRegistry, ts: testing.TestSetRegistration) -> testing.TestSetChild { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + + 374 6 load_deref 2 + 7 load_field 0 (name) + + 375 8 load_var2 1 2 + 9 make_closure 1452 2 + 10 init_instance 0 (testing.TestSetChild .name, .run) + 11 store_var 3 (_0) + 12 load_var 3 (_0) + 13 return +} + +function testing.testset_child_selected(registry: testing.TestRegistry, ts: testing.TestSetRegistration, names: string[]) -> testing.TestSetChild { + 0 load_var 1 + 1 make_cell + 2 store_var 1 + 3 load_var 2 + 4 make_cell + 5 store_var 2 + 6 load_var 3 + 7 make_cell + 8 store_var 3 + + 390 9 load_deref 2 + 10 load_field 0 (name) + + 391 11 load_var2 1 2 + 12 load_var 3 (names) + 13 make_closure 1454 3 + 14 init_instance 0 (testing.TestSetChild .name, .run) + 15 store_var 4 (_0) + 16 load_var 4 (_0) + 17 return +} + +function testing.testset_children(registry: testing.TestRegistry) -> testing.TestSetChild[] { + 329 0 load_type 0 + 1 alloc_array 0 + 2 store_var 3 (children) + + 330 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 4 (_4) + 10 load_var 4 (_4) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 5 (_5) + 15 load_var 5 (_5) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +14 (to 32) + 19 load_var 5 (_5) + 20 store_var_load_var 6 (t) + + 331 21 load_field 0 (name) + 22 load_var 6 (t) + 23 load_field 1 (body) + 24 load_var 6 (t) + 25 load_field 2 (runner) + 26 call 740 ntypeargs=0 (testing.test_child) + 27 store_var 7 (_10) + 28 load_var2 3 7 + 29 call 4 ntypeargs=0 (baml.Array.push) + 30 pop 1 + 31 jump -21 (to 10) + + 333 32 load_var 1 (registry) + 33 load_field 0 (collector) + 34 load_field 2 (testsets) + 35 load_type 6 + 36 load_const 7 ("iter") + 37 virtual_call nargs=1 ntypeargs=0 + 38 store_var 8 (_15) + 39 load_var 8 (_15) + 40 load_type 8 + 41 load_const 9 ("next") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 9 (_16) + 44 load_var 9 (_16) + 45 is_type 5 + 46 pop_jump_if_false +2 (to 48) + 47 jump +10 (to 57) + 48 load_var 9 (_16) + 49 store_var 10 (ts) + + 334 50 load_var2 1 10 + 51 call 741 ntypeargs=0 (testing.testset_child) + 52 store_var 11 (_21) + 53 load_var2 3 11 + 54 call 4 ntypeargs=0 (baml.Array.push) + 55 pop 1 + 56 jump -17 (to 39) + + 336 57 load_var 3 (children) + 58 store_var 2 (_0) + 59 load_var 2 (_0) + 60 return +} + +function testing.testset_children_selected(registry: testing.TestRegistry, names: string[]) -> testing.TestSetChild[] { + 340 0 load_type 0 + 1 alloc_array 0 + 2 store_var 4 (children) + + 341 3 load_var 1 (registry) + 4 load_field 0 (collector) + 5 load_field 1 (tests) + 6 load_type 1 + 7 load_const 2 ("iter") + 8 virtual_call nargs=1 ntypeargs=0 + 9 store_var 5 (_5) + 10 load_var 5 (_5) + 11 load_type 3 + 12 load_const 4 ("next") + 13 virtual_call nargs=1 ntypeargs=0 + 14 store_var 6 (_6) + 15 load_var 6 (_6) + 16 is_type 5 + 17 pop_jump_if_false +2 (to 19) + 18 jump +19 (to 37) + 19 load_var 6 (_6) + 20 store_var_load_var 7 (t) + + 342 21 load_field 0 (name) + 22 load_var 2 (names) + 23 call 743 ntypeargs=0 (testing._name_selected) + 24 pop_jump_if_false -14 (to 10) + + 343 25 load_var 7 (t) + 26 load_field 0 (name) + 27 load_var 7 (t) + 28 load_field 1 (body) + 29 load_var 7 (t) + 30 load_field 2 (runner) + 31 call 740 ntypeargs=0 (testing.test_child) + 32 store_var 8 (_13) + 33 load_var2 4 8 + 34 call 4 ntypeargs=0 (baml.Array.push) + 35 pop 1 + 36 jump -26 (to 10) + + 348 37 load_var 1 (registry) + 38 load_field 0 (collector) + 39 load_field 2 (testsets) + 40 load_type 6 + 41 load_const 7 ("iter") + 42 virtual_call nargs=1 ntypeargs=0 + 43 store_var 9 (_18) + 44 load_var 9 (_18) + 45 load_type 8 + 46 load_const 9 ("next") + 47 virtual_call nargs=1 ntypeargs=0 + 48 store_var 10 (_19) + 49 load_var 10 (_19) + 50 is_type 5 + 51 pop_jump_if_false +2 (to 53) + 52 jump +15 (to 67) + 53 load_var 10 (_19) + 54 store_var_load_var 11 (ts) + + 354 55 load_field 0 (name) + 56 load_var 2 (names) + 57 call 744 ntypeargs=0 (testing._has_selected_descendant) + 58 pop_jump_if_false -14 (to 44) + + 355 59 load_var2 1 11 + 60 load_var 2 (names) + 61 call 742 ntypeargs=0 (testing.testset_child_selected) + 62 store_var 12 (_26) + 63 load_var2 4 12 + 64 call 4 ntypeargs=0 (baml.Array.push) + 65 pop 1 + 66 jump -22 (to 44) + + 360 67 load_var 4 (children) + 68 store_var 3 (_0) + 69 load_var 3 (_0) + 70 return +} + +function user.User.promote(self: User, bonus: int) -> Report { + 9 0 load_var 1 (self) + 1 copy 0 + 2 load_field 1 (age) + 3 load_const 0 (1) + 4 bin_op + + 5 store_field 1 (age) + + 10 6 load_var2 1 2 + 7 call 912 ntypeargs=0 (user.score) + 8 store_var 4 (base) + + 11 9 load_var 4 (base) + 10 load_field 0 (score) + 11 load_var 2 (bonus) + 12 add_int + 13 store_var_load_var 5 (new_score) + + 14 14 load_var 4 (base) + 15 load_field 1 (label) + + 15 16 load_var 4 (base) + 17 load_field 2 (breakdown) + 18 init_instance 0 (user.Report .score, .label, .breakdown) + 19 store_var 3 (_0) + 20 load_var 3 (_0) + 21 return +} + +function user.http_status(code: int) -> string { + 95 0 load_const 0 ("HTTP ") + 1 store_var 2 (prefix) + + 96 2 load_var 1 (code) + 3 dense_tag 0 + 4 jump_table 0 ([to 23, to 20, to 17, to 14, to 11, to 8], default to 5) + + 103 5 load_const 1 ("Unknown") + 6 store_var 3 (label) + + 96 7 jump +18 (to 25) + + 102 8 load_const 2 ("Internal Server Error") + 9 store_var 3 (label) + + 96 10 jump +15 (to 25) + + 101 11 load_const 3 ("Not Found") + 12 store_var 3 (label) + + 96 13 jump +12 (to 25) + + 100 14 load_const 4 ("Bad Request") + 15 store_var 3 (label) + + 96 16 jump +9 (to 25) + + 99 17 load_const 5 ("No Content") + 18 store_var 3 (label) + + 96 19 jump +6 (to 25) + + 98 20 load_const 6 ("Created") + 21 store_var 3 (label) + + 96 22 jump +3 (to 25) + + 97 23 load_const 7 ("OK") + 24 store_var 3 (label) + + 105 25 load_var2 2 3 + 26 bin_op + + 27 return +} + +function user.score(input: User | ErrorInfo, threshold: int) -> Report { + 45 0 load_var 1 (input) + 1 store_var 4 (_4) + 2 load_var 4 (_4) + 3 narrow_bind 0 4 + 4 pop_jump_if_false +2 (to 6) + 5 jump +7 (to 12) + 6 load_var 1 (input) + 7 store_var 6 (e) + + 47 8 load_var 6 (e) + 9 load_field 1 (message) + 10 store_var 3 (name) + + 45 11 jump +6 (to 17) + 12 load_var 4 (_4) + 13 store_var 5 (u) + + 46 14 load_var 5 (u) + 15 load_field 0 (name) + 16 store_var 3 (name) + + 50 17 load_var 1 (input) + 18 store_var 8 (_8) + 19 load_var 8 (_8) + 20 narrow_bind 0 8 + 21 pop_jump_if_false +2 (to 23) + 22 jump +7 (to 29) + 23 load_var 1 (input) + 24 store_var_load_var 10 (e) + + 52 25 load_field 0 (code) + 26 unary_op - + 27 store_var 7 (age) + + 50 28 jump +6 (to 34) + 29 load_var 8 (_8) + 30 store_var 9 (u) + + 51 31 load_var 9 (u) + 32 load_field 1 (age) + 33 store_var 7 (age) + + 55 34 load_var 1 (input) + 35 store_var 12 (_13) + 36 load_var 12 (_13) + 37 narrow_bind 0 12 + 38 pop_jump_if_false +2 (to 40) + 39 jump +4 (to 43) + + 62 40 load_var 2 (threshold) + 41 store_var 11 (role_mult) + + 55 42 jump +17 (to 59) + 43 load_var 12 (_13) + 44 store_var_load_var 13 (u) + + 56 45 load_field 2 (role) + 46 discriminant + 47 jump_table 0 ([to 57, to 54, to 51, to 48], default to 115) + + 60 48 load_var 2 (threshold) + 49 store_var 11 (role_mult) + + 56 50 jump +9 (to 59) + + 59 51 load_var 2 (threshold) + 52 store_var 11 (role_mult) + + 56 53 jump +6 (to 59) + + 58 54 load_var 2 (threshold) + 55 store_var 11 (role_mult) + + 56 56 jump +3 (to 59) + + 57 57 load_var 2 (threshold) + 58 store_var 11 (role_mult) + + 65 59 load_var 7 (age) + 60 load_const 1 (2) + 61 mul_int + 62 load_var 11 (role_mult) + 63 add_int + 64 store_var_load_var 14 (base) + + 66 65 load_var 11 (role_mult) + 66 cmp_int_op > + 67 pop_jump_if_false +2 (to 69) + 68 jump +4 (to 72) + + 69 69 load_var 14 (base) + 70 store_var 15 (capped) + + 66 71 jump +3 (to 74) + + 67 72 load_var 11 (role_mult) + 73 store_var 15 (capped) + + 71 74 load_var2 15 11 + 75 add_int + 76 store_var_load_var 16 (total) + + 73 77 load_var 2 (threshold) + 78 cmp_int_op > + 79 load_const 2 (true) + 80 cmp_op == + 81 pop_jump_if_false +2 (to 83) + 82 jump +4 (to 86) + + 75 83 load_const 3 (" [LOW]") + 84 store_var 17 (suffix) + + 73 85 jump +3 (to 88) + + 74 86 load_const 4 (" [HIGH]") + 87 store_var 17 (suffix) + + 77 88 load_var2 3 17 + 89 bin_op + + 90 store_var 18 (label) + + 79 91 load_var2 14 15 + 92 load_var 16 (total) + 93 load_type 5 + 94 alloc_array 3 + 95 store_var 19 (scores) + + 80 96 load_var 19 (scores) + 97 load_const 6 (0) + 98 load_var 16 (total) + 99 store_array_element + + 81 100 load_var 19 (scores) + 101 load_const 6 (0) + 102 load_array_element + 103 store_var 20 (top) + + 83 104 load_var2 14 11 + 105 load_const 7 ("base") + 106 load_const 8 ("role") + 107 load_type 9 + 108 load_type 5 + 109 alloc_map 2 + 110 store_var 21 (breakdown) + + 86 111 load_var2 20 18 + + 88 112 load_var 21 (breakdown) + 113 init_instance 0 (user.Report .score, .label, .breakdown) + 114 return + 115 unreachable +} diff --git a/baml_language/crates/baml_tests/tests/net.rs b/baml_language/crates/baml_tests/tests/net.rs index 3c2d486c477..f780c3abee8 100644 --- a/baml_language/crates/baml_tests/tests/net.rs +++ b/baml_language/crates/baml_tests/tests/net.rs @@ -26,21 +26,25 @@ async fn net_connect_and_read() { let output = baml_test!(&format!( r#" - function main() -> uint8array {{ + function main() -> uint8array? {{ let sock = baml.net.TcpStream.connect("{addr}"); - sock.read() + sock.read(1024) }} "# )); server.await.unwrap(); insta::assert_snapshot!(stabilize_bytecode(&output.bytecode, &addr), @r#" - function main() -> uint8array { + function main() -> uint8array | null { load_const "{ADDR}" load_const call baml.net.TcpStream.connect - load_const - call baml.net.TcpStream.read + load_const 1024 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _0 + load_var _0 return } "#); @@ -54,20 +58,24 @@ async fn net_connect_and_read() { async fn net_connect_failure() { let output = baml_test!( r#" - function main() -> uint8array { + function main() -> uint8array? { let sock = baml.net.TcpStream.connect("127.0.0.1:1"); - sock.read() + sock.read(1024) } "# ); insta::assert_snapshot!(output.bytecode, @r#" - function main() -> uint8array { + function main() -> uint8array | null { load_const "127.0.0.1:1" load_const call baml.net.TcpStream.connect - load_const - call baml.net.TcpStream.read + load_const 1024 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _0 + load_var _0 return } "#); @@ -91,10 +99,10 @@ async fn net_multiple_reads() { let output = baml_test!(&format!( r#" - function main() -> uint8array {{ + function main() -> uint8array? {{ let sock = baml.net.TcpStream.connect("{addr}"); - let first = sock.read(); - let second = sock.read(); + let first = sock.read(1024); + let second = sock.read(1024); first }} "# @@ -102,18 +110,22 @@ async fn net_multiple_reads() { server.await.unwrap(); insta::assert_snapshot!(stabilize_bytecode(&output.bytecode, &addr), @r#" - function main() -> uint8array { + function main() -> uint8array | null { load_const "{ADDR}" load_const call baml.net.TcpStream.connect store_var sock load_var sock - load_const - call baml.net.TcpStream.read + load_const 1024 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 store_var first load_var sock - load_const - call baml.net.TcpStream.read + load_const 1024 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 store_var second load_var first return @@ -125,16 +137,19 @@ async fn net_multiple_reads() { ); } -// Kept in Rust (not the baml_src corpus): the silent peer must be a -// controlled Rust listener that accepts and holds the connection open. A -// corpus version using `baml.http.Server.bind` as the silent peer is flaky — -// the BAML listener object can be GC-collected between `connect` and the -// throwing `read`, resetting the connection into an `Io` error instead of the -// expected `Timeout`, intermittently under load. +// `read` carries no deadline of its own: a blocked read is bounded by the +// native cancellation system, so a timeout is a `CancelToken` fired by a +// sleeping task. These two cases stay in Rust (not the baml_src corpus) +// because the silent peer must be a controlled listener that accepts and holds +// the connection open. A corpus version using `baml.http.Server.bind` as the +// silent peer is flaky — the BAML listener object can be GC-collected between +// `connect` and the read, resetting the connection into an `Io` error instead +// of the expected cancellation, intermittently under load. #[tokio::test] -async fn net_read_timeout_fires() { - // The server accepts the connection but never writes, so a bare read() would - // block forever. A short read timeout must surface as baml.errors.Timeout. +async fn net_read_cancelled_by_deadline() { + // The server accepts the connection but never writes, so the read parks + // forever; firing the spawn's cancel token must unpark it as + // baml.panics.Cancelled. let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let addr = listener.local_addr().unwrap().to_string(); @@ -146,27 +161,39 @@ async fn net_read_timeout_fires() { let output = baml_test!(&format!( r#" - function main() -> uint8array {{ + function main() -> string {{ let sock = baml.net.TcpStream.connect("{addr}"); - sock.read(timeout = baml.time.Duration.from_milliseconds(50n)) + let tok = baml.spawn.CancelToken.new(); + let read = spawn with baml.spawn.options(cancel = tok) {{ + sock.read(1024) + }}; + let deadline = spawn {{ + baml.sys.sleep(baml.time.Duration.from_milliseconds(50n)); + tok.cancel() + }}; + let outcome = (await read) catch (e) {{ + baml.panics.Cancelled => "cancelled" + }}; + match (outcome) {{ + let reason: string => reason, + null => "eof", + let chunk: uint8array => "read", + }} }} "# )); server.await.unwrap(); - let err = output - .result - .expect_err("read with a 50ms timeout against a silent peer should time out") - .to_string(); - assert!( - err.contains("baml.errors.Timeout"), - "expected a baml.errors.Timeout throw, got: {err}" + assert_eq!( + output.result, + Ok(BexExternalValue::String("cancelled".into())), + "a read against a silent peer should be cancelled by the 50ms deadline" ); } #[tokio::test] -async fn net_read_succeeds_within_timeout() { - // A generous read timeout must not interfere with a prompt response. +async fn net_read_completes_before_deadline() { + // A generous deadline must not interfere with a prompt response. let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let addr = listener.local_addr().unwrap().to_string(); @@ -178,9 +205,20 @@ async fn net_read_succeeds_within_timeout() { let output = baml_test!(&format!( r#" - function main() -> uint8array {{ + function main() -> uint8array? {{ let sock = baml.net.TcpStream.connect("{addr}"); - sock.read(timeout = baml.time.Duration.from_seconds(5n)) + let tok = baml.spawn.CancelToken.new(); + let read = spawn with baml.spawn.options(cancel = tok) {{ + sock.read(1024) + }}; + let deadline = spawn {{ + baml.sys.sleep(baml.time.Duration.from_seconds(5n)); + tok.cancel() + }}; + let chunk = await read; + // Stop the pending deadline so the test does not wait it out. + deadline.cancel(); + chunk }} "# )); @@ -207,12 +245,12 @@ async fn net_connect_timeout_param_accepted() { let output = baml_test!(&format!( r#" - function main() -> uint8array {{ + function main() -> uint8array? {{ let sock = baml.net.TcpStream.connect( "{addr}", timeout = baml.time.Duration.from_seconds(5n), ); - sock.read() + sock.read(1024) }} "# )); diff --git a/baml_language/crates/sys_native/src/io_impls.rs b/baml_language/crates/sys_native/src/io_impls.rs index 4cd46888106..c66b927b512 100644 --- a/baml_language/crates/sys_native/src/io_impls.rs +++ b/baml_language/crates/sys_native/src/io_impls.rs @@ -1935,88 +1935,86 @@ impl io::IoClassNetTcpStream for NativeSysOps { }) } - fn _read( + fn read( &self, _heap: &Arc, _call_id: CallId, stream: owned::net::TcpStream, - timeout_nanos: Arc, + amount: i64, _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { use tokio::io::AsyncReadExt; - let timeout = timeout_from_nanos(&timeout_nanos); + let amount = match u64::try_from(amount) { + Err(_) | Ok(0) => return SysOpOutput::Ready(Ok(Some(Vec::new()))), + Ok(amount) => amount, + }; + let amount = usize::try_from(amount).unwrap_or(usize::MAX); // does nothing on 64bit+ + SysOpOutput::async_op(async move { let handle = downcast_tcpstream(&stream)?; let mut guard = handle.lock().await; let stream = guard.as_mut().ok_or_else(|| VmBamlError::Io { message: "TcpStream is closed".to_string(), })?; - let mut buffer = vec![0u8; 4096]; - let read = stream.read(&mut buffer); - let n = match timeout { - Some(dur) => match tokio::time::timeout(dur, read).await { - Ok(result) => result, - Err(_elapsed) => { - return Err(VmBamlError::Timeout { - message: "Reading from socket timed out".to_string(), - duration_ms: i64::try_from(dur.as_millis()).ok(), - } - .into()); - } - }, - None => read.await, + + let mut buffer = Vec::new(); + buffer + .try_reserve(amount) + .map_err(|err| VmPanic::AllocFailure { + message: format!("Failed to reserve buffer: {err}"), + })?; + buffer.resize(amount, 0); + + let read = stream + .read(&mut buffer) + .await + .map_err(|e| VmBamlError::Io { + message: format!("Failed to read from socket: {e}"), + })?; + // The peer's half-close is sticky at the socket level — further + // reads keep returning 0 — so EOF needs no bookkeeping here. The + // handle stays live so a later read still reports EOF rather than + // the "closed" error that dropping it would produce. + if read == 0 { + return Ok(None); } - .map_err(|e| VmBamlError::Io { - message: format!("Failed to read from socket: {e}"), - })?; - buffer.truncate(n); - Ok(buffer) + buffer.truncate(read); + Ok(Some(buffer)) }) } - fn _write( + fn write( &self, _heap: &Arc, _call_id: CallId, stream: owned::net::TcpStream, data: Vec, - timeout_nanos: Arc, _ctx: &SysOpContext, - ) -> SysOpOutput<()> { + ) -> SysOpOutput { use tokio::io::AsyncWriteExt; - let timeout = timeout_from_nanos(&timeout_nanos); SysOpOutput::async_op(async move { let handle = downcast_tcpstream(&stream)?; let mut guard = handle.lock().await; let stream = guard.as_mut().ok_or_else(|| VmBamlError::Io { message: "TcpStream is closed".to_string(), })?; - // The whole write (every byte flushed) shares one deadline. - let write = async { - stream.write_all(&data).await.map_err(|e| VmBamlError::Io { - message: format!("Failed to write to socket: {e}"), - })?; - stream.flush().await.map_err(|e| VmBamlError::Io { - message: format!("Failed to flush socket: {e}"), - })?; - Ok::<(), VmBamlError>(()) - }; - match timeout { - Some(dur) => match tokio::time::timeout(dur, write).await { - Ok(result) => result?, - Err(_elapsed) => { - return Err(VmBamlError::Timeout { - message: "Writing to socket timed out".to_string(), - duration_ms: i64::try_from(dur.as_millis()).ok(), - } - .into()); + + // TCP streams don't need to be flushed + stream + .write(&data) + .await + .map(|written| { + i64::try_from(written) + .unwrap_or_else(|_| unreachable!("a single write cannot exceed i64::MAX")) + }) + .map_err(|e| { + VmBamlError::Io { + message: format!("Failed to write to socket: {e}"), } - }, - None => write.await?, - } - Ok(()) + .into() + }) }) } diff --git a/baml_language/crates/sys_ops/src/lib.rs b/baml_language/crates/sys_ops/src/lib.rs index c2f73c2ea0a..7030cd5e70b 100644 --- a/baml_language/crates/sys_ops/src/lib.rs +++ b/baml_language/crates/sys_ops/src/lib.rs @@ -1355,27 +1355,26 @@ impl io::IoClassNetTcpStream for DefaultIoOps { message: "Operation not supported on this platform".to_string(), }) } - fn _read( + fn read( &self, _h: &Arc, _c: CallId, _s: io::owned::net::TcpStream, - _timeout_nanos: Arc, + _amount: i64, _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) } - fn _write( + fn write( &self, _h: &Arc, _c: CallId, _s: io::owned::net::TcpStream, _data: Vec, - _timeout_nanos: Arc, _ctx: &SysOpContext, - ) -> SysOpOutput<()> { + ) -> SysOpOutput { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) @@ -2324,16 +2323,16 @@ impl IoSysOpsBuilder { t.__glue_baml_net_tcpstream__connect(heap, permit, args, ctx, call_id) }) }; - self.inner.baml_net_tcpstream__read = { + self.inner.baml_net_tcpstream_root_io_read_read = { let t = instance.clone(); Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_net_tcpstream__read(heap, permit, args, ctx, call_id) + t.__glue_baml_net_tcpstream_root_io_read_read(heap, permit, args, ctx, call_id) }) }; - self.inner.baml_net_tcpstream__write = { + self.inner.baml_net_tcpstream_root_io_write_write = { let t = instance.clone(); Arc::new(move |heap, permit, args, ctx, call_id| { - t.__glue_baml_net_tcpstream__write(heap, permit, args, ctx, call_id) + t.__glue_baml_net_tcpstream_root_io_write_write(heap, permit, args, ctx, call_id) }) }; self.inner.baml_net_tcpstream_close = { From 14444d175787130ff2ed92d593ac1db12ac15b88 Mon Sep 17 00:00:00 2001 From: 2kai2kai2 Date: Fri, 14 Aug 2026 10:08:44 -0700 Subject: [PATCH 4/5] `ReadPipe` and `WritePipe` for child processes --- .../baml_std/ai/ns_mcp/mcp.baml | 14 +- .../baml_std/baml/ns_io/write.baml | 3 + .../baml_std/baml/ns_sys/sys.baml | 153 +++++-- .../baml_std/baml/uint8array.baml | 6 + .../baml_std/claude_code/ns_internal/cli.baml | 7 +- ...tests__render_builtin_package_listing.snap | 29 +- .../ns_byte_strings/byte_strings.baml | 20 + .../snapshots/baml_src/byte_strings.snap | 28 ++ ..._tests__compiles____ai_std____03_ppir.snap | 8 +- ...tests__compiles____ai_std____04_5_mir.snap | 114 +++--- ...sts__compiles____ai_std____06_codegen.snap | 31 +- ...ests__compiles____baml_std____03_ppir.snap | 58 ++- ...sts__compiles____baml_std____04_5_mir.snap | 255 ++++++++++-- ...s__compiles____baml_std____06_codegen.snap | 194 +++++++-- ...__phase5__snapshot_baml_package_items.snap | 9 +- .../crates/baml_tests/tests/shell.rs | 57 ++- .../bex_vm/src/package_baml/uint8array.rs | 9 + .../crates/bridge_wasm/src/wasm_sys.rs | 55 ++- .../crates/sys_native/src/io_impls.rs | 386 ++++++++++-------- baml_language/crates/sys_ops/src/lib.rs | 55 ++- 20 files changed, 1064 insertions(+), 427 deletions(-) diff --git a/baml_language/crates/baml_builtins2/baml_std/ai/ns_mcp/mcp.baml b/baml_language/crates/baml_builtins2/baml_std/ai/ns_mcp/mcp.baml index f8365abd7a3..211458ceed2 100644 --- a/baml_language/crates/baml_builtins2/baml_std/ai/ns_mcp/mcp.baml +++ b/baml_language/crates/baml_builtins2/baml_std/ai/ns_mcp/mcp.baml @@ -24,6 +24,10 @@ function rpc_line(id: int?, method: string, params: map?) -> st class McpConnection { server_name: string, p: baml.sys.Process, + // Framed once at connect: the stream buffers whatever it read past the + // last newline, so re-framing per `_request` would drop the start of the + // next message. + out: baml.sys.ReadPipeLines, next_id: int, // Spawn the server and perform the initialize handshake. The connection @@ -42,7 +46,6 @@ class McpConnection { env: null, timeout_ms: timeout_ms, stdin: null, - keep_stdin_open: true, }, ) catch_all (e) { _ => { @@ -53,7 +56,10 @@ class McpConnection { } }, }; - let conn = McpConnection { server_name: name, p: p, next_id: 1 }; + // `lines()` only wraps the pipe — reading it is what can fail, and that + // surfaces at `_request`. + let out = p.stdout.lines(); + let conn = McpConnection { server_name: name, p: p, out: out, next_id: 1 }; let init: map = { "protocolVersion": "2025-06-18", "capabilities": {}, @@ -69,7 +75,7 @@ class McpConnection { // lose the newline the protocol frames on; the newline is a quoted // string, appended before the single write. let framed = [line, "\n"].join(""); - let _ = self.p.write_stdin(framed) catch_all (e) { + self.p.stdin.write_all(framed.to_utf8()) catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `mcp/${self.server_name}`, @@ -87,7 +93,7 @@ class McpConnection { self.next_id += 1; self._send(rpc_line(id, method, params)); while (true) { - let next = self.p.stdout.next() catch_all (e) { + let next = self.out.next() catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `mcp/${self.server_name}`, diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml index 34f16e6b451..a7bbdaa840c 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/write.baml @@ -11,6 +11,9 @@ interface Write { function write_all(self, data: uint8array) -> void throws root.errors.Io { while (data.length() > 0) { let written = self.write(data); + if (written == 0) { + throw root.errors.Io { message: "stream closed without writing all data" }; + } data = data.slice(written, data.length()); } } diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml index 03787de3dd8..892211f3733 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml @@ -6,13 +6,12 @@ class ProcessOptions { env: map?, /// Maximum time in milliseconds to wait for the process to complete. timeout_ms: int?, - /// Data to write to the child process's stdin. + /// The child process's complete stdin. `start_process` writes it and then + /// closes the pipe, so a child that reads to EOF sees one. Leave it unset + /// to drive `Process.stdin` incrementally instead. stdin: string?, - /// Keep a writable stdin pipe on a process returned by `start_process`. - /// - /// When this is `true`, use `Process.write_stdin` to send data incrementally - /// and `Process.close_stdin` to deliver EOF. This option has no effect on - /// `exec` or `shell`. + /// No longer has any effect: `start_process` always hands back a writable + /// `Process.stdin`, and EOF is delivered by closing that pipe. keep_stdin_open: bool?, } @@ -39,64 +38,95 @@ class ProcessExit { } } -/// A live line-oriented child-process output stream. +/// A line-oriented view over a `ReadPipe`. +/// +/// A combinator, not a resource: it reads through to the pipe on demand and +/// holds only the bytes past the last newline, so the pipe stays open and +/// owned by whoever created it. Interleaving raw `pipe.read` calls with line +/// reads splits a line across the two — a caller error the type does not +/// prevent. /// /// Iteration waits for one complete UTF-8 line without blocking other BAML -/// green threads. The final unterminated line is yielded at EOF. -class ProcessLineStream { - _handle: $rust_type, +/// green threads. The final unterminated line is yielded at EOF, and invalid +/// UTF-8 is replaced with U+FFFD rather than throwing. +class ReadPipeLines { + /// The pipe being framed. + pipe: ReadPipe, + /// Bytes read past the last newline, carried into the next `next()`. + _pending: uint8array, implements root.iter.Iterable { type Item = string - type Error = root.errors.Io | root.errors.Timeout + type Error = root.errors.Io function iter( self, - ) -> root.iter.Iterator throws never { + ) -> root.iter.Iterator throws never { self } } implements root.iter.Iterator { type Item = string - type Error = root.errors.Io | root.errors.Timeout + type Error = root.errors.Io - function next(self) -> string | root.iter.Done throws root.errors.Io | root.errors.Timeout { - match (self._next()) { - let line: string => line, - null => root.iter.Done { }, + /// Wait for and return the next line, or `Done` at EOF. + function next(self) -> string | root.iter.Done throws root.errors.Io { + // `line` stays `Done` until a newline is found or EOF flushes the + // tail; `framing` ends the loop in both cases. + let line: string | root.iter.Done = root.iter.Done { }; + let framing = true; + while (framing) { + // 10 is `\n`; 65536 is how much one framing read asks for. + match (self._pending.index_of(10)) { + let index: int => { + let bytes = self._pending.slice(0, index); + self._pending = self._pending.slice(index + 1, self._pending.length()); + line = _strip_carriage_return(bytes).to_string(); + framing = false; + }, + null => { + match (self.pipe.read(65536)) { + let chunk: uint8array => { + self._pending = self._pending.concat(chunk); + }, + // EOF: whatever follows the last newline is the + // final, unterminated line; an empty remainder is + // just the end. + null => { + if (self._pending.length() > 0) { + line = _strip_carriage_return(self._pending).to_string(); + self._pending = b""; + } + framing = false; + }, + } + }, + } } + line } } +} - /// Wait for and return the next line, or `null` at EOF. - function _next(self) -> string? throws root.errors.Io | root.errors.Timeout { - $rust_io_function - } - - /// Stop reading this stream. Later reads return EOF. - function close(self) -> null throws never { - $rust_io_function +/// Drops one trailing `\r` (13) so CRLF input frames into clean lines. +function _strip_carriage_return(line: uint8array) -> uint8array throws never { + match (line.at(line.length() - 1)) { + 13 => line.slice(0, line.length() - 1), + _ => line, } } /// A live child process created with `start_process`. /// -/// `stdout` is consumed incrementally. Stderr inherits the parent process so -/// diagnostics remain visible without risking a blocked, unread stderr pipe. +/// All three streams are pipes the caller owns and consumes incrementally. +/// Stderr is no longer inherited from the parent, so a child that writes more +/// than the pipe buffer holds blocks until `stderr` is drained. class Process { - stdout: ProcessLineStream, _handle: $rust_type, - - /// Write data to the child process's open stdin pipe. - function write_stdin(self, data: string) -> null throws root.errors.Io { - $rust_io_function - } - - /// Close the child process's stdin pipe, delivering EOF. - function close_stdin(self) -> null throws root.errors.Io { - $rust_io_function - } + stdin: WritePipe, + stdout: ReadPipe, + stderr: ReadPipe, /// Wait for the child to exit. function wait(self) -> ProcessExit throws root.errors.Io | root.errors.Timeout { @@ -104,7 +134,7 @@ class Process { } /// Request that the child terminate. - function kill(self) -> null throws root.errors.Io { + function kill(self) -> void throws root.errors.Io { $rust_io_function } @@ -116,6 +146,51 @@ class Process { } } +/// A system pipe for reading data, typically from another process. +/// +/// Generally should only be used with a single reader, competing `read` calls +/// will behave FIFO. +class ReadPipe { + _pipe: $rust_type, + + /// Close the read pipe, releasing any resources. + function close(self) -> void throws root.errors.Io { + $rust_io_function + } + + /// A line-oriented view over this pipe. The pipe stays open and readable; + /// the stream only buffers what it has read past the last newline. + function lines(self) -> ReadPipeLines throws never { + ReadPipeLines { pipe: self, _pending: b"" } + } + + implements root.io.Read { + function read(self, limit: int) -> uint8array? throws root.errors.Io { + $rust_io_function + } + } +} + +/// A system pipe for writing data, typically to another process. +class WritePipe { + _pipe: $rust_type, + + /// Close the write pipe, releasing any resources. + function close(self) -> void throws root.errors.Io { + $rust_io_function + } + + implements root.io.Write { + function write(self, data: uint8array) -> int throws root.errors.Io { + $rust_io_function + } + + function flush(self) -> void throws root.errors.Io { + $rust_io_function + } + } +} + /// Runs `program` with the given `args` and returns its output. Throws on I/O failure or timeout. function exec( program: string, diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/uint8array.baml b/baml_language/crates/baml_builtins2/baml_std/baml/uint8array.baml index 5020ab93973..fb63c1e37f6 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/uint8array.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/uint8array.baml @@ -38,6 +38,12 @@ class Uint8Array { $rust_function } + /// Returns the index of the first occurrence of `item`, or `null` when it + /// is absent. An `item` outside the `u8` range is never present. + function index_of(self, item: int) -> int? throws never { + $rust_function + } + /// Returns a new `uint8array` with the bytes in reverse order. function reverse(self) -> uint8array throws never { $rust_function diff --git a/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml b/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml index e890716a9f0..4300ff7541d 100644 --- a/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml +++ b/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml @@ -125,7 +125,7 @@ Application tool catalog (request via outcome.calls only): // terminal result event. function _read_result(p: baml.sys.Process) -> json { let result: json = null; - for (let line in p.stdout) { + for (let line in p.stdout.lines()) { let trimmed = line.trim(); if (trimmed.length() > 0) { let raw = baml.json.parse(trimmed) catch_all (e) { @@ -295,7 +295,10 @@ function invoke(c: root.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelT p.close() } // the CLI reads stdin when the pipe is open; deliver EOF immediately - let _ = p.close_stdin() catch_all (e) { + let _ = { + p.stdin.close(); + null + } catch_all (e) { _ => null, }; // events stream LIVE: each JSONL line logs as it arrives, and the last diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index a440ea71001..c0e366d7934 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -304,19 +304,22 @@ class baml.spawn.TaskGroup /baml/ns_spawn/spawn. class baml.spawn.CancelToken /baml/ns_spawn/spawn.baml:85 function baml.spawn.options /baml/ns_spawn/spawn.baml:123 class baml.sys.ProcessOptions /baml/ns_sys/sys.baml:2 -class baml.sys.ShellOutput /baml/ns_sys/sys.baml:20 -class baml.sys.ProcessExit /baml/ns_sys/sys.baml:32 -class baml.sys.ProcessLineStream /baml/ns_sys/sys.baml:46 -class baml.sys.Process /baml/ns_sys/sys.baml:87 -function baml.sys.exec /baml/ns_sys/sys.baml:120 -function baml.sys.start_process /baml/ns_sys/sys.baml:132 -function baml.sys.shell /baml/ns_sys/sys.baml:141 -function baml.sys.sleep /baml/ns_sys/sys.baml:149 -function baml.sys.collect_garbage /baml/ns_sys/sys.baml:156 -function baml.sys.panic /baml/ns_sys/sys.baml:162 -function baml.sys.exit /baml/ns_sys/sys.baml:168 -function baml.sys.argv /baml/ns_sys/sys.baml:174 -function baml.sys.pid /baml/ns_sys/sys.baml:183 +class baml.sys.ShellOutput /baml/ns_sys/sys.baml:19 +class baml.sys.ProcessExit /baml/ns_sys/sys.baml:31 +class baml.sys.ReadPipeLines /baml/ns_sys/sys.baml:52 +function baml.sys._strip_carriage_return /baml/ns_sys/sys.baml:113 +class baml.sys.Process /baml/ns_sys/sys.baml:125 +class baml.sys.ReadPipe /baml/ns_sys/sys.baml:153 +class baml.sys.WritePipe /baml/ns_sys/sys.baml:175 +function baml.sys.exec /baml/ns_sys/sys.baml:195 +function baml.sys.start_process /baml/ns_sys/sys.baml:207 +function baml.sys.shell /baml/ns_sys/sys.baml:216 +function baml.sys.sleep /baml/ns_sys/sys.baml:224 +function baml.sys.collect_garbage /baml/ns_sys/sys.baml:231 +function baml.sys.panic /baml/ns_sys/sys.baml:237 +function baml.sys.exit /baml/ns_sys/sys.baml:243 +function baml.sys.argv /baml/ns_sys/sys.baml:249 +function baml.sys.pid /baml/ns_sys/sys.baml:258 class baml.time.Duration /baml/ns_time/duration.baml:4 class baml.time.Instant /baml/ns_time/instant.baml:2 class baml.time.PlainDate /baml/ns_time/plaindate.baml:5 diff --git a/baml_language/crates/baml_tests/baml_src/ns_byte_strings/byte_strings.baml b/baml_language/crates/baml_tests/baml_src/ns_byte_strings/byte_strings.baml index ed03e8513c5..94c67691d8c 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_byte_strings/byte_strings.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_byte_strings/byte_strings.baml @@ -261,3 +261,23 @@ test "literal_as_call_argument" { test "index_read_direct" { assert.equal(byte_strings_index_read_direct(), 65) } + +// ─── B10. index_of: first match, absence, and out-of-range bytes ────────────── + +// 0x6c = 108 ('l'), first at index 2 of "hello" +test "index_of_finds_first_match" { + assert.equal(b"hello".index_of(108), 2) +} + +test "index_of_absent_byte_is_null" { + assert.is_true(b"hello".index_of(122) == null) +} + +// Outside the u8 range, so it can never be present — matching `includes`. +test "index_of_non_byte_is_null" { + assert.is_true(b"hello".index_of(300) == null) +} + +test "index_of_empty_is_null" { + assert.is_true(b"".index_of(108) == null) +} diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/byte_strings.snap b/baml_language/crates/baml_tests/snapshots/baml_src/byte_strings.snap index 476c94a34aa..4c56b037076 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/byte_strings.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/byte_strings.snap @@ -205,6 +205,34 @@ function byte_strings.$init_test_ns_byte_strings_byte_strings(registry: testing. load_const null call testing.TestCollector.register_test_at pop 1 + load_var registry + load_const "root.byte_strings" + load_const "index_of_finds_first_match" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_var registry + load_const "root.byte_strings" + load_const "index_of_absent_byte_is_null" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_var registry + load_const "root.byte_strings" + load_const "index_of_non_byte_is_null" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_var registry + load_const "root.byte_strings" + load_const "index_of_empty_is_null" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 load_const null return } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____03_ppir.snap index 586e33014db..71e4a947ffa 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____03_ppir.snap @@ -483,18 +483,20 @@ function ai.internal._wire_blocks(content: root.content.Block[], keep_reasoning: class ai.mcp.McpConnection { server_name: string p: baml.sys.Process + out: baml.sys.ReadPipeLines next_id: int } class ai.mcp.McpConnection$stream { server_name: string | null p: baml.sys.Process$stream | null + out: baml.sys.ReadPipeLines$stream | null next_id: int | null } function ai.mcp._request(self: ?, method: string, params: map) -> baml.json.json [expr] { - { let id = self.next_id; self.next_id Add= 1; self._send(rpc_line(id, method, params)); while true { let next = self.p.stdout.next() catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } }; match (next) { line: string => { let trimmed = line.trim() } if (trimmed.length() Gt 0) { let msg = baml.json.parse(trimmed) catch_all (e) { _ => null } } if (baml.json.path_or(msg, ".id", Neg 1) Eq id) { let err = baml.json.path_or(msg, ".error", null); if (err Ne null) { throw root.errors.InvalidRequest { provider: `...`, status_code: baml.json.path_or(err, ".code", null), detail: baml.json.path_or(err, ".message", "MCP error"), raw_body: baml.json.stringify(err) } }; return baml.json.path_or(msg, ".result", null) }, _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } } }; throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } + { let id = self.next_id; self.next_id Add= 1; self._send(rpc_line(id, method, params)); while true { let next = self.out.next() catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } }; match (next) { line: string => { let trimmed = line.trim() } if (trimmed.length() Gt 0) { let msg = baml.json.parse(trimmed) catch_all (e) { _ => null } } if (baml.json.path_or(msg, ".id", Neg 1) Eq id) { let err = baml.json.path_or(msg, ".error", null); if (err Ne null) { throw root.errors.InvalidRequest { provider: `...`, status_code: baml.json.path_or(err, ".code", null), detail: baml.json.path_or(err, ".message", "MCP error"), raw_body: baml.json.stringify(err) } }; return baml.json.path_or(msg, ".result", null) }, _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } } }; throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } } function ai.mcp._send(self: ?, line: string) -> void [expr] { - { let framed = [line, "\n"].join(""); let _ = self.p.write_stdin(framed) catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } } } + { let framed = [line, "\n"].join(""); self.p.stdin.write_all(framed.to_utf8()) catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } } } } function ai.mcp.call_tool(self: ?, name: string, args: map) -> string [expr] { { let params: map = map { "name": name, "arguments": args }; let result = self._request("tools/call", params); let texts: string[] = []; for item in baml.json.path_or(result, ".content", []) { } if (baml.json.path_or(item, ".type", "") Eq "text") { texts.push(baml.json.path_or(item, ".text", "")) }; let joined = texts.join("\n"); if (baml.json.path_or(result, ".isError", false)) { throw baml.errors.InvalidArgument { message: `...` } } } joined @@ -503,7 +505,7 @@ function ai.mcp.close(self: ?) -> void [expr] { { self.p.close() } } function ai.mcp.connect(name: string, command: string, args: string[], timeout_ms: int = 30000) -> ai.mcp.McpConnection [expr] { - { let p = baml.sys.start_process(command, args, baml.sys.ProcessOptions { cwd: null, env: null, timeout_ms: timeout_ms, stdin: null, keep_stdin_open: true }) catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } }; let conn = ai.mcp.McpConnection { server_name: name, p: p, next_id: 1 }; let init: map = map { "protocolVersion": "2025-06-18", "capabilities": map { }, "clientInfo": map { "name": "baml-mcp", "version": "0.1" } }; let _ = conn._request("initialize", init); conn._send(rpc_line(null, "notifications/ini...", null)) } conn + { let p = baml.sys.start_process(command, args, baml.sys.ProcessOptions { cwd: null, env: null, timeout_ms: timeout_ms, stdin: null }) catch_all (e) { _ => { throw root.errors.NetworkFailure { provider: `...`, detail: `...`, raw_body: null } } }; let out = p.stdout.lines(); let conn = ai.mcp.McpConnection { server_name: name, p: p, out: out, next_id: 1 }; let init: map = map { "protocolVersion": "2025-06-18", "capabilities": map { }, "clientInfo": map { "name": "baml-mcp", "version": "0.1" } }; let _ = conn._request("initialize", init); conn._send(rpc_line(null, "notifications/ini...", null)) } conn } function ai.mcp.rpc_line(id: int?, method: string, params: map?) -> string [expr] { { let m: map = map { "jsonrpc": "2.0", "method": method }; if let i: int = id { let _ = m.set("id", i) }; if let p: map = params { let _ = m.set("params", p) } } baml.json.stringify(baml.json.to_json(m)) diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap index 5d0ec6641e2..02ab755f75a 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap @@ -4329,15 +4329,18 @@ fn ai.mcp.McpConnection.connect(name: string, command: string, args: string[], t let _15: string let _16: type let _17: type - let _18: ai.mcp.McpConnection // conn - let _19: baml.sys.Process - let _20: map // init - let _21: map - let _22: map - let _23: int | float | string | bool | null | baml.json.json[] | map + let _18: baml.sys.ReadPipeLines // out + let _19: (baml.sys.ReadPipe) -> baml.sys.ReadPipeLines throws never + let _20: ai.mcp.McpConnection // conn + let _21: baml.sys.Process + let _22: baml.sys.ReadPipeLines + let _23: map // init let _24: map - let _25: void - let _26: string + let _25: map + let _26: int | float | string | bool | null | baml.json.json[] | map + let _27: map + let _28: void + let _29: string bb0: { _5 = copy _4 == const ; @@ -4350,58 +4353,64 @@ fn ai.mcp.McpConnection.connect(name: string, command: string, args: string[], t } bb2: { - _8 = baml.sys.ProcessOptions { const null, const null, copy _4, const null, const true }; - _6 = sys_op const fn baml.sys.start_process(copy _2, copy _3, copy _8) -> bb3 unwind bb8; + _8 = baml.sys.ProcessOptions { const null, const null, copy _4, const null, const null }; + _6 = sys_op const fn baml.sys.start_process(copy _2, copy _3, copy _8) -> bb3 unwind bb9; } bb3: { - _19 = copy _6; - _18 = ai.mcp.McpConnection { copy _1, copy _19, const 1_i64 }; - _21 = { }: map; - _22 = { const "name": const "baml-mcp", const "version": const "0.1" }: map; - _20 = { const "protocolVersion": const "2025-06-18", const "capabilities": copy _21, const "clientInfo": copy _22 }: map; - _24 = copy _20; - _23 = call const fn ai.mcp.McpConnection._request(copy _18, const "initialize", copy _24) -> [bb4]; + _19 = copy _6.2; + _18 = call const fn baml.sys.ReadPipe.lines(copy _19) -> [bb4]; } bb4: { - _26 = call const fn ai.mcp.rpc_line(const null, const "notifications/initialized", const null) -> [bb5]; + _21 = copy _6; + _22 = copy _18; + _20 = ai.mcp.McpConnection { copy _1, copy _21, copy _22, const 1_i64 }; + _24 = { }: map; + _25 = { const "name": const "baml-mcp", const "version": const "0.1" }: map; + _23 = { const "protocolVersion": const "2025-06-18", const "capabilities": copy _24, const "clientInfo": copy _25 }: map; + _27 = copy _23; + _26 = call const fn ai.mcp.McpConnection._request(copy _20, const "initialize", copy _27) -> [bb5]; } bb5: { - _25 = call const fn ai.mcp.McpConnection._send(copy _18, copy _26) -> [bb6]; + _29 = call const fn ai.mcp.rpc_line(const null, const "notifications/initialized", const null) -> [bb6]; } bb6: { - _0 = copy _18; - goto -> bb7; + _28 = call const fn ai.mcp.McpConnection._send(copy _20, copy _29) -> [bb7]; } bb7: { - return; + _0 = copy _20; + goto -> bb8; } bb8: { - throw_if_panic copy _7 -> bb9; + return; } bb9: { - _12 = load_type(string); - _11 = call const fn baml.String.from(copy _1) -> [bb10]; + throw_if_panic copy _7 -> bb10; } bb10: { + _12 = load_type(string); + _11 = call const fn baml.String.from(copy _1) -> [bb11]; + } + + bb11: { _10 = const "mcp/" + copy _11; _16 = load_type(baml.errors.Io); - _15 = call const fn baml.String.from(copy _7) -> [bb11]; + _15 = call const fn baml.String.from(copy _7) -> [bb12]; } - bb11: { + bb12: { _17 = load_type(string); - _14 = call const fn baml.String.from(copy _15) -> [bb12]; + _14 = call const fn baml.String.from(copy _15) -> [bb13]; } - bb12: { + bb13: { _13 = const "the MCP server could not start: " + copy _14; _9 = ai.errors.NetworkFailure { copy _10, copy _13, const null }; throw copy _9; @@ -4416,10 +4425,10 @@ fn ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> void let _3: string // framed let _4: string[] let _5: type - let _6: null + let _6: void let _7: unknown // e - let _8: (baml.sys.Process, string) -> null throws baml.errors.Io - let _9: string + let _8: baml.sys.WritePipe + let _9: uint8array let _10: ai.errors.NetworkFailure let _11: string let _12: string @@ -4438,42 +4447,45 @@ fn ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> void } bb1: { - _8 = copy _1.1; - _9 = copy _3; - _6 = sys_op const fn baml.sys.Process.write_stdin(copy _8, copy _9) -> bb2 unwind bb4; + _8 = copy _1.1.1; + _9 = call const fn baml.String.to_utf8(copy _3) -> [bb2, unwind: bb5]; } bb2: { - _0 = const null; - goto -> bb3; + _6 = virtual_call write_all as baml.io.Write(copy _8, copy _9) -> [bb3, unwind: bb5]; } bb3: { - return; + _0 = const null; + goto -> bb4; } bb4: { - throw_if_panic copy _7 -> bb5; + return; } bb5: { + throw_if_panic copy _7 -> bb6; + } + + bb6: { _13 = copy _1.0; _14 = load_type(string); - _12 = call const fn baml.String.from(copy _13) -> [bb6]; + _12 = call const fn baml.String.from(copy _13) -> [bb7]; } - bb6: { + bb7: { _11 = const "mcp/" + copy _12; _18 = load_type(baml.errors.Io); - _17 = call const fn baml.String.from(copy _7) -> [bb7]; + _17 = call const fn baml.String.from(copy _7) -> [bb8]; } - bb7: { + bb8: { _19 = load_type(string); - _16 = call const fn baml.String.from(copy _17) -> [bb8]; + _16 = call const fn baml.String.from(copy _17) -> [bb9]; } - bb8: { + bb9: { _15 = const "writing to the MCP server failed: " + copy _16; _10 = ai.errors.NetworkFailure { copy _11, copy _15, const null }; throw copy _10; @@ -4492,7 +4504,7 @@ fn ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, par let _7: int let _8: string | baml.iter.Done // next let _9: unknown // e - let _10: baml.sys.ProcessLineStream + let _10: baml.sys.ReadPipeLines let _11: ai.errors.NetworkFailure let _12: string let _13: string @@ -4555,8 +4567,8 @@ fn ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, par let _70: type bb0: { - _4 = copy _1.2; - _1.2 = copy _1.2 + const 1_i64; + _4 = copy _1.3; + _1.3 = copy _1.3 + const 1_i64; _7 = copy _4; _6 = call const fn ai.mcp.rpc_line(copy _7, copy _2, copy _3) -> [bb1]; } @@ -4609,8 +4621,8 @@ fn ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, par } bb10: { - _10 = copy _1.1.0; - _8 = virtual_call next as baml.iter.Iterator(copy _10) -> [bb16, unwind: bb11]; + _10 = copy _1.2; + _8 = virtual_call next as baml.iter.Iterator(copy _10) -> [bb16, unwind: bb11]; } bb11: { @@ -4625,7 +4637,7 @@ fn ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: string, par bb13: { _12 = const "mcp/" + copy _13; - _19 = load_type(baml.errors.Io | baml.errors.Timeout); + _19 = load_type(baml.errors.Io); _18 = call const fn baml.String.from(copy _9) -> [bb14]; } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap index 337d437e031..f2177c42a82 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap @@ -4712,9 +4712,8 @@ function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: strin L2: load_var self - load_field .p - load_field .stdout - load_type baml.iter.Iterator + load_field .out + load_type baml.iter.Iterator load_const "next" virtual_call nargs=1 ntypeargs=0 store_var next @@ -4726,7 +4725,7 @@ function ai.mcp.McpConnection._request(self: ai.mcp.McpConnection, method: strin load_field .server_name call baml.String.from store_var _13 - load_type baml.errors.Io | baml.errors.Timeout + load_type baml.errors.Io load_var e call baml.String.from store_var _18 @@ -4858,11 +4857,16 @@ function ai.mcp.McpConnection._send(self: ai.mcp.McpConnection, line: string) -> alloc_array 2 load_const "" call baml.Array.join - store_var framed load_var self load_field .p - load_var framed - sys_op baml.sys.Process.write_stdin + load_field .stdin + store_var _8 + call baml.String.to_utf8 + store_var _9 + load_var2 4 5 + load_type baml.io.Write + load_const "write_all" + virtual_call nargs=2 ntypeargs=0 pop 1 jump L0 load_var e @@ -5015,7 +5019,7 @@ function ai.mcp.McpConnection.connect(name: string, command: string, args: strin load_const null load_var timeout_ms load_const null - load_const true + load_const null init_instance baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open sys_op baml.sys.start_process store_var p @@ -5045,9 +5049,14 @@ function ai.mcp.McpConnection.connect(name: string, command: string, args: strin throw L1: + load_var p + load_field .stdout + call baml.sys.ReadPipe.lines + store_var out load_var2 1 5 + load_var out load_const 1 - init_instance ai.mcp.McpConnection .server_name, .p, .next_id + init_instance ai.mcp.McpConnection .server_name, .p, .out, .next_id store_var conn load_var conn load_const "initialize" @@ -5074,8 +5083,8 @@ function ai.mcp.McpConnection.connect(name: string, command: string, args: strin load_const "notifications/initialized" load_const null call ai.mcp.rpc_line - store_var _26 - load_var2 10 11 + store_var _29 + load_var2 11 12 call ai.mcp.McpConnection._send pop 1 load_var conn diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap index 41c77222996..21b29bcf736 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap @@ -1019,7 +1019,7 @@ function baml.io.read_to_string(self: ?) -> string [expr] { function baml.io.flush(self: ?) -> void [missing] function baml.io.write(self: ?, data: uint8array) -> int [missing] function baml.io.write_all(self: ?, data: uint8array) -> void [expr] { - { while data.length() Gt 0 { let written = self.write(data); data = data.slice(written, data.length()) } } + { while data.length() Gt 0 { let written = self.write(data); if (written Eq 0) { throw root.errors.Io { message: "stream closed wit..." } }; data = data.slice(written, data.length()) } } } --- /baml/ns_iter/iter.baml --- @@ -2099,12 +2099,16 @@ lambda (params) in options: captures [group, cancel, detach] --- /baml/ns_sys/sys.baml --- class baml.sys.Process { - stdout: baml.sys.ProcessLineStream _handle: $rust_type + stdin: baml.sys.WritePipe + stdout: baml.sys.ReadPipe + stderr: baml.sys.ReadPipe } class baml.sys.Process$stream { - stdout: baml.sys.ProcessLineStream$stream | null _handle: $rust_type + stdin: baml.sys.WritePipe$stream | null + stdout: baml.sys.ReadPipe$stream | null + stderr: baml.sys.ReadPipe$stream | null } class baml.sys.ProcessExit { exit_code: int @@ -2114,12 +2118,6 @@ class baml.sys.ProcessExit$stream { exit_code: int | null signal: string | null } -class baml.sys.ProcessLineStream { - _handle: $rust_type -} -class baml.sys.ProcessLineStream$stream { - _handle: $rust_type -} class baml.sys.ProcessOptions { cwd: string? env: map? @@ -2134,6 +2132,20 @@ class baml.sys.ProcessOptions$stream { stdin: string | null keep_stdin_open: bool | null } +class baml.sys.ReadPipe { + _pipe: $rust_type +} +class baml.sys.ReadPipe$stream { + _pipe: $rust_type +} +class baml.sys.ReadPipeLines { + pipe: baml.sys.ReadPipe + _pending: uint8array +} +class baml.sys.ReadPipeLines$stream { + pipe: baml.sys.ReadPipe$stream | null + _pending: uint8array +} class baml.sys.ShellOutput { stdout: uint8array stderr: uint8array @@ -2144,20 +2156,32 @@ class baml.sys.ShellOutput$stream { stderr: uint8array exit_code: int | null } -function baml.sys._next(self: ?) -> string? [builtin] +class baml.sys.WritePipe { + _pipe: $rust_type +} +class baml.sys.WritePipe$stream { + _pipe: $rust_type +} +function baml.sys._strip_carriage_return(line: uint8array) -> uint8array [expr] { + { } match (line.at(line.length() Sub 1)) { 13 => line.slice(0, line.length() Sub 1), _ => line } +} function baml.sys.argv() -> string[] [builtin] function baml.sys.close(self: ?) -> null [builtin] -function baml.sys.close(self: ?) -> null [builtin] -function baml.sys.close_stdin(self: ?) -> null [builtin] +function baml.sys.close(self: ?) -> void [builtin] +function baml.sys.close(self: ?) -> void [builtin] function baml.sys.collect_garbage() -> null [builtin] function baml.sys.exec(program: string, args: string[]?, options: baml.sys.ProcessOptions?) -> baml.sys.ShellOutput [builtin] function baml.sys.exit(code: int) -> never [builtin] -function baml.sys.iter(self: ?) -> root.iter.Iterator [expr] { +function baml.sys.flush(self: ?) -> void [builtin] +function baml.sys.iter(self: ?) -> root.iter.Iterator [expr] { { } self } -function baml.sys.kill(self: ?) -> null [builtin] +function baml.sys.kill(self: ?) -> void [builtin] +function baml.sys.lines(self: ?) -> baml.sys.ReadPipeLines [expr] { + { } baml.sys.ReadPipeLines { pipe: self, _pending: b"<0 bytes>" } +} function baml.sys.next(self: ?) -> string | root.iter.Done [expr] { - { } match (self._next()) { line: string => line, null => root.iter.Done { } } + { let line: string | root.iter.Done = root.iter.Done { }; let framing = true; while framing { } match (self._pending.index_of(10)) { index: int => { let bytes = self._pending.slice(0, index); self._pending = self._pending.slice(index Add 1, self._pending.length()); line = _strip_carriage_return(bytes).to_string(); framing = false }, null => { } match (self.pipe.read(65536)) { chunk: uint8array => { self._pending = self._pending.concat(chunk) }, null => { if (self._pending.length() Gt 0) { line = _strip_carriage_return(self._pending).to_string(); self._pending = b"<0 bytes>" }; framing = false } } } } line } function baml.sys.ok(self: ?) -> bool [expr] { { } self.exit_code Eq 0 @@ -2167,11 +2191,12 @@ function baml.sys.ok(self: ?) -> bool [expr] { } function baml.sys.panic(message: string) -> never [builtin] function baml.sys.pid() -> int [builtin] +function baml.sys.read(self: ?, limit: int) -> uint8array? [builtin] function baml.sys.shell(command: string, options: baml.sys.ProcessOptions?) -> baml.sys.ShellOutput [builtin] function baml.sys.sleep(delay: root.time.Duration) -> null [builtin] function baml.sys.start_process(program: string, args: string[]?, options: baml.sys.ProcessOptions?) -> baml.sys.Process [builtin] function baml.sys.wait(self: ?) -> baml.sys.ProcessExit [builtin] -function baml.sys.write_stdin(self: ?, data: string) -> null [builtin] +function baml.sys.write(self: ?, data: uint8array) -> int [builtin] --- /baml/ns_time/duration.baml --- class baml.time.Duration { @@ -2739,6 +2764,7 @@ function baml.from_array(array: int[]) -> uint8array [builtin] function baml.from_base64(base64: string) -> uint8array [builtin] function baml.from_hex(hex: string) -> uint8array [builtin] function baml.includes(self: ?, item: int) -> bool [builtin] +function baml.index_of(self: ?, item: int) -> int? [builtin] function baml.length(self: ?) -> int [builtin] function baml.pop(self: ?) -> int? [builtin] function baml.push(self: ?, item: int) -> int [builtin] diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index 781b5130202..ea2adc4aa09 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -4325,8 +4325,11 @@ fn baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void { let _3: bool let _4: int let _5: int // written - let _6: int + let _6: bool let _7: int + let _8: baml.errors.Io + let _9: int + let _10: int bb0: { goto -> bb1; @@ -4356,13 +4359,24 @@ fn baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void { } bb6: { - _6 = copy _5; - _7 = len(_2); - goto -> bb7; + _7 = copy _5; + _6 = copy _7 == const 0_i64; + branch copy _6 -> [bb9, bb7]; } bb7: { - _2 = call const fn baml.Uint8Array.slice(copy _2, copy _6, copy _7) -> [bb1]; + _9 = copy _5; + _10 = len(_2); + goto -> bb8; + } + + bb8: { + _2 = call const fn baml.Uint8Array.slice(copy _2, copy _9, copy _10) -> [bb1]; + } + + bb9: { + _8 = baml.errors.Io { const "stream closed without writing all data" }; + throw copy _8; } } @@ -8194,10 +8208,10 @@ fn baml.sys.ProcessExit.ok(self: baml.sys.ProcessExit) -> bool { } } -fn baml.sys.ProcessLineStream.root.iter.Iterable.iter(self: baml.sys.ProcessLineStream) -> baml.iter.Iterator { +fn baml.sys.ReadPipeLines.root.iter.Iterable.iter(self: baml.sys.ReadPipeLines) -> baml.iter.Iterator { // Locals: - let _0: baml.iter.Iterator // _0 // return - let _1: baml.sys.ProcessLineStream // self // param + let _0: baml.iter.Iterator // _0 // return + let _1: baml.sys.ReadPipeLines // self // param bb0: { _0 = copy _1; @@ -8209,46 +8223,206 @@ fn baml.sys.ProcessLineStream.root.iter.Iterable.iter(self: baml.sys.ProcessLine } } -fn baml.sys.ProcessLineStream.root.iter.Iterator.next(self: baml.sys.ProcessLineStream) -> string | baml.iter.Done { +fn baml.sys.ReadPipeLines.root.iter.Iterator.next(self: baml.sys.ReadPipeLines) -> string | baml.iter.Done { // Locals: let _0: string | baml.iter.Done // _0 // return - let _1: baml.sys.ProcessLineStream // self // param - let _2: string | null - let _3: string | null - let _4: string // line + let _1: baml.sys.ReadPipeLines // self // param + let _2: string | baml.iter.Done // line + let _3: bool // framing + let _4: bool + let _5: int | null + let _6: (baml.Uint8Array, int) -> int | null throws never + let _7: int | null + let _8: int // index + let _9: uint8array // bytes + let _10: (baml.Uint8Array, int, int) -> uint8array throws never + let _11: int + let _12: (baml.Uint8Array, int, int) -> uint8array throws never + let _13: int + let _14: int + let _15: int + let _16: (baml.Uint8Array) -> int throws never + let _17: uint8array + let _18: uint8array + let _19: uint8array + let _20: null | uint8array + let _21: baml.sys.ReadPipe + let _22: null | uint8array + let _23: uint8array // chunk + let _24: (baml.Uint8Array, uint8array) -> uint8array throws never + let _25: uint8array + let _26: uint8array + let _27: bool + let _28: int + let _29: (baml.Uint8Array) -> int throws never + let _30: uint8array + let _31: uint8array bb0: { - _2 = sys_op const fn baml.sys.ProcessLineStream._next(copy _1) -> bb1; + _2 = baml.iter.Done { }; + _3 = const true; + goto -> bb1; } bb1: { - _3 = copy _2; - _3 = narrow_bind copy _3 as String { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb3, bb2]; + _4 = copy _3; + branch copy _4 -> [bb4, bb2]; } bb2: { - _0 = baml.iter.Done { }; - goto -> bb4; + _0 = copy _2; + goto -> bb3; } bb3: { - _4 = copy _3; - _0 = copy _4; - goto -> bb4; + return; } bb4: { - return; + _6 = copy _1.1; + _5 = call const fn baml.Uint8Array.index_of(copy _6, const 10_i64) -> [bb5]; + } + + bb5: { + _7 = copy _5; + _7 = narrow_bind copy _7 as Int { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb16, bb6]; + } + + bb6: { + _21 = copy _1.0; + _20 = virtual_call read as baml.io.Read(copy _21, const 65536_i64) -> [bb7]; + } + + bb7: { + _22 = copy _20; + _22 = narrow_bind copy _22 as Uint8Array { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb14, bb8]; + } + + bb8: { + _29 = copy _1.1; + _28 = len(_29); + goto -> bb9; + } + + bb9: { + _27 = copy _28 > const 0_i64; + branch copy _27 -> [bb10, bb13]; + } + + bb10: { + _31 = copy _1.1; + _30 = call const fn baml.sys._strip_carriage_return(copy _31) -> [bb11]; + } + + bb11: { + _2 = call const fn baml.Uint8Array.baml.ToString.to_string(copy _30) -> [bb12]; + } + + bb12: { + _1.1 = b"<0 bytes>"; + goto -> bb13; + } + + bb13: { + _3 = const false; + goto -> bb1; + } + + bb14: { + _23 = copy _22; + _24 = copy _1.1; + _25 = copy _23; + _26 = call const fn baml.Uint8Array.concat(copy _24, copy _25) -> [bb15]; + } + + bb15: { + _1.1 = copy _26; + goto -> bb1; + } + + bb16: { + _8 = copy _7; + _10 = copy _1.1; + _11 = copy _8; + _9 = call const fn baml.Uint8Array.slice(copy _10, const 0_i64, copy _11) -> [bb17]; + } + + bb17: { + _12 = copy _1.1; + _14 = copy _8; + _13 = copy _14 + const 1_i64; + _16 = copy _1.1; + _15 = len(_16); + goto -> bb18; + } + + bb18: { + _17 = call const fn baml.Uint8Array.slice(copy _12, copy _13, copy _15) -> [bb19]; + } + + bb19: { + _1.1 = copy _17; + goto -> bb20; + } + + bb20: { + _19 = copy _9; + _18 = call const fn baml.sys._strip_carriage_return(copy _19) -> [bb21]; + } + + bb21: { + _2 = call const fn baml.Uint8Array.baml.ToString.to_string(copy _18) -> [bb22]; + } + + bb22: { + _3 = const false; + goto -> bb1; } } -fn baml.sys.ProcessLineStream._next = builtin(io) +fn baml.sys._strip_carriage_return(line: uint8array) -> uint8array { + // Locals: + let _0: uint8array // _0 // return + let _1: uint8array // line // param + let _2: int | null + let _3: int + let _4: int + let _5: int + let _6: int + + bb0: { + _4 = len(_1); + goto -> bb1; + } + + bb1: { + _3 = copy _4 - const 1_i64; + _2 = call const fn baml.Uint8Array.at(copy _1, copy _3) -> [bb2]; + } + + bb2: { + switch copy _2 [13: bb4, otherwise: bb3]; + } -fn baml.sys.ProcessLineStream.close = builtin(io) + bb3: { + _0 = copy _1; + goto -> bb6; + } -fn baml.sys.Process.write_stdin = builtin(io) + bb4: { + _6 = len(_1); + goto -> bb5; + } -fn baml.sys.Process.close_stdin = builtin(io) + bb5: { + _5 = copy _6 - const 1_i64; + _0 = call const fn baml.Uint8Array.slice(copy _1, const 0_i64, copy _5) -> [bb6]; + } + + bb6: { + return; + } +} fn baml.sys.Process.wait = builtin(io) @@ -8256,6 +8430,33 @@ fn baml.sys.Process.kill = builtin(io) fn baml.sys.Process.close = builtin(io) +fn baml.sys.ReadPipe.close = builtin(io) + +fn baml.sys.ReadPipe.lines(self: baml.sys.ReadPipe) -> baml.sys.ReadPipeLines { + // Locals: + let _0: baml.sys.ReadPipeLines // _0 // return + let _1: baml.sys.ReadPipe // self // param + let _2: uint8array + + bb0: { + _2 = b"<0 bytes>"; + _0 = baml.sys.ReadPipeLines { copy _1, copy _2 }; + goto -> bb1; + } + + bb1: { + return; + } +} + +fn baml.sys.ReadPipe.root.io.Read.read = builtin(io) + +fn baml.sys.WritePipe.close = builtin(io) + +fn baml.sys.WritePipe.root.io.Write.write = builtin(io) + +fn baml.sys.WritePipe.root.io.Write.flush = builtin(io) + fn baml.sys.exec = builtin(io) fn baml.sys.start_process = builtin(io) @@ -11933,6 +12134,8 @@ fn baml.Uint8Array.concat = builtin(vm) fn baml.Uint8Array.includes = builtin(vm) +fn baml.Uint8Array.index_of = builtin(vm) + fn baml.Uint8Array.reverse = builtin(vm) fn baml.Uint8Array.slice = builtin(vm) diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index f6e0372f7d7..60cdd8204ac 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -1087,6 +1087,9 @@ function baml.Uint8Array.from_hex(hex: string) -> uint8array { function baml.Uint8Array.includes(self: baml.Uint8Array, item: int) -> bool { } +function baml.Uint8Array.index_of(self: baml.Uint8Array, item: int) -> int | null { +} + function baml.Uint8Array.length(self: baml.Uint8Array) -> int { } @@ -2927,14 +2930,26 @@ function baml.io.Write.write_all(self: baml.io.Write, data: uint8array) -> void load_const "write" virtual_call nargs=2 ntypeargs=0 store_var written + load_var written + load_const 0 + cmp_int_op == + pop_jump_if_false L3 + jump L4 + + L3: load_var data container_len - store_var _7 + store_var _10 load_var2 2 4 - load_var _7 + load_var _10 call baml.Uint8Array.slice store_var data jump L0 + + L4: + load_const "stream closed without writing all data" + init_instance baml.errors.Io .message + throw } function baml.io.eprint(s: string) -> null { @@ -5618,18 +5633,12 @@ function baml.spawn.options(group: baml.spawn.TaskGroup | null, cancel: baml.spa function baml.sys.Process.close(self: baml.sys.Process) -> null { } -function baml.sys.Process.close_stdin(self: baml.sys.Process) -> null { -} - -function baml.sys.Process.kill(self: baml.sys.Process) -> null { +function baml.sys.Process.kill(self: baml.sys.Process) -> void { } function baml.sys.Process.wait(self: baml.sys.Process) -> baml.sys.ProcessExit { } -function baml.sys.Process.write_stdin(self: baml.sys.Process, data: string) -> null { -} - function baml.sys.ProcessExit.ok(self: baml.sys.ProcessExit) -> bool { load_var self load_field .exit_code @@ -5638,35 +5647,133 @@ function baml.sys.ProcessExit.ok(self: baml.sys.ProcessExit) -> bool { return } -function baml.sys.ProcessLineStream._next(self: baml.sys.ProcessLineStream) -> string | null { +function baml.sys.ReadPipe.close(self: baml.sys.ReadPipe) -> void { +} + +function baml.sys.ReadPipe.lines(self: baml.sys.ReadPipe) -> baml.sys.ReadPipeLines { + load_var self + load_const b"" + call baml.deep_copy + init_instance baml.sys.ReadPipeLines .pipe, ._pending + return } -function baml.sys.ProcessLineStream.close(self: baml.sys.ProcessLineStream) -> null { +function baml.sys.ReadPipe.root.io.Read.read(self: baml.sys.ReadPipe, limit: int) -> uint8array | null { } -function baml.sys.ProcessLineStream.root.iter.Iterable.iter(self: baml.sys.ProcessLineStream) -> baml.iter.Iterator { +function baml.sys.ReadPipeLines.root.iter.Iterable.iter(self: baml.sys.ReadPipeLines) -> baml.iter.Iterator { load_var self return } -function baml.sys.ProcessLineStream.root.iter.Iterator.next(self: baml.sys.ProcessLineStream) -> string | baml.iter.Done { - load_var self - sys_op baml.sys.ProcessLineStream._next - store_var _3 - load_var _3 - narrow_bind string, slot=2 - pop_jump_if_false L0 - jump L1 +function baml.sys.ReadPipeLines.root.iter.Iterator.next(self: baml.sys.ReadPipeLines) -> string | baml.iter.Done { + alloc_instance baml.iter.Done + store_var line + load_const true + store_var framing L0: - alloc_instance baml.iter.Done + load_var framing + pop_jump_if_false L1 jump L2 L1: - load_var _3 + load_var line + return L2: - return + load_var self + load_field ._pending + load_const 10 + call baml.Uint8Array.index_of + store_var _7 + load_var _7 + narrow_bind int, slot=4 + pop_jump_if_false L3 + jump L7 + + L3: + load_var self + load_field .pipe + load_const 65536 + load_type baml.io.Read + load_const "read" + virtual_call nargs=2 ntypeargs=0 + store_var _20 + load_var _20 + store_var _22 + load_var _22 + narrow_bind uint8array, slot=12 + pop_jump_if_false L4 + jump L6 + + L4: + load_var self + load_field ._pending + container_len + store_var _28 + load_var _28 + load_const 0 + cmp_int_op > + pop_jump_if_false L5 + load_var self + load_field ._pending + call baml.sys._strip_carriage_return + call baml.Uint8Array.baml.ToString.to_string + store_var line + load_var self + load_const b"" + call baml.deep_copy + store_field ._pending + + L5: + load_const false + store_var framing + jump L0 + + L6: + load_var self + load_field ._pending + load_var _22 + call baml.Uint8Array.concat + store_var _26 + load_var2 1 13 + store_field ._pending + jump L0 + + L7: + load_var _7 + store_var index + load_var self + load_field ._pending + load_const 0 + load_var index + call baml.Uint8Array.slice + store_var bytes + load_var self + load_field ._pending + store_var _12 + load_var index + load_const 1 + add_int + store_var _13 + load_var self + load_field ._pending + container_len + store_var _15 + load_var2 7 8 + load_var _15 + call baml.Uint8Array.slice + store_var _17 + load_var2 1 10 + store_field ._pending + load_var bytes + call baml.sys._strip_carriage_return + call baml.Uint8Array.baml.ToString.to_string + store_var line + load_const false + store_var framing + jump L0 } function baml.sys.ShellOutput.ok(self: baml.sys.ShellOutput) -> bool { @@ -5677,6 +5784,47 @@ function baml.sys.ShellOutput.ok(self: baml.sys.ShellOutput) -> bool { return } +function baml.sys.WritePipe.close(self: baml.sys.WritePipe) -> void { +} + +function baml.sys.WritePipe.root.io.Write.flush(self: baml.sys.WritePipe) -> void { +} + +function baml.sys.WritePipe.root.io.Write.write(self: baml.sys.WritePipe, data: uint8array) -> int { +} + +function baml.sys._strip_carriage_return(line: uint8array) -> uint8array { + load_var line + container_len + store_var _4 + load_var2 1 2 + load_const 1 + sub_int + call baml.Uint8Array.at + load_const 13 + cmp_int_op == + pop_jump_if_false L0 + jump L1 + + L0: + load_var line + jump L2 + + L1: + load_var line + container_len + store_var _6 + load_var line + load_const 0 + load_var _6 + load_const 1 + sub_int + call baml.Uint8Array.slice + + L2: + return +} + function baml.sys.argv() -> string[] { } diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index 53980302ec9..8b6b1560088 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -22,7 +22,7 @@ namespace baml: type ToJson type ToString class TypeValue { methods: [array, optional, to_baml, kind, as_class, as_enum, as_union, as_literal, as_array, as_map, as_interface, as_primitive, as_function, _validate_renderable, meta, _to_string_impl, implements, implemented_by, to_string] } - class Uint8Array { methods: [length, at, push, pop, concat, includes, reverse, slice, zeroes, from_array, to_array, from_hex, to_hex, from_base64, to_base64, _to_string_impl, sort, to_string] } + class Uint8Array { methods: [length, at, push, pop, concat, includes, index_of, reverse, slice, zeroes, from_array, to_array, from_hex, to_hex, from_base64, to_base64, _to_string_impl, sort, to_string] } function _cleanup_begin function _compare_shim function _float_total_cmp @@ -337,11 +337,14 @@ namespace baml.spawn: class TaskGroup { methods: [new, cancel, set_limit, limit, name, active_count, queued_count] } function options namespace baml.sys: - class Process { methods: [write_stdin, close_stdin, wait, kill, close] } + class Process { methods: [wait, kill, close] } class ProcessExit { methods: [ok] } - class ProcessLineStream { methods: [_next, close, iter, next] } class ProcessOptions { methods: [] } + class ReadPipe { methods: [close, lines, read] } + class ReadPipeLines { methods: [iter, next] } class ShellOutput { methods: [ok] } + class WritePipe { methods: [close, write, flush] } + function _strip_carriage_return function argv function collect_garbage function exec diff --git a/baml_language/crates/baml_tests/tests/shell.rs b/baml_language/crates/baml_tests/tests/shell.rs index 8cc00e5049b..1595ef01cfd 100644 --- a/baml_language/crates/baml_tests/tests/shell.rs +++ b/baml_language/crates/baml_tests/tests/shell.rs @@ -264,7 +264,7 @@ async fn start_process_yields_stdout_before_exit() { ); defer { process.close() } - let first = match (process.stdout.next()) { + let first = match (process.stdout.lines().next()) { let line: string => line, baml.iter.Done => "", }; @@ -291,7 +291,7 @@ async fn start_process_iterates_lines_and_final_unterminated_line() { ); defer { process.close() } - let lines = process.stdout.collect(); + let lines = process.stdout.lines().collect(); let exit = process.wait(); if (!exit.ok()) { return "bad exit"; @@ -313,18 +313,21 @@ async fn start_process_supports_incremental_stdin() { let output = baml_test!( r#" function main() -> string throws baml.errors.Io | baml.errors.Timeout { - let process = baml.sys.start_process( - "cat", - [], - baml.sys.ProcessOptions { keep_stdin_open: true }, - ); + let process = baml.sys.start_process("cat", [], null); defer { process.close() } - process.write_stdin("one\n"); - let one = process.stdout._next() ?? ""; - process.write_stdin("two\n"); - let two = process.stdout._next() ?? ""; - process.close_stdin(); + let out = process.stdout.lines(); + process.stdin.write_all("one\n".to_utf8()); + let one = match (out.next()) { + let line: string => line, + baml.iter.Done => "", + }; + process.stdin.write_all("two\n".to_utf8()); + let two = match (out.next()) { + let line: string => line, + baml.iter.Done => "", + }; + process.stdin.close(); let exit = process.wait(); if (!exit.ok()) { return "bad exit"; @@ -340,29 +343,43 @@ async fn start_process_supports_incremental_stdin() { ); } +// `timeout_ms` bounds `wait()`, not the pipes: reading stdout goes through +// `baml.io.Read`, whose only error class is `Io`, so a blocked read is bounded +// by the cancellation system rather than a deadline baked into the read. #[tokio::test] #[cfg(not(target_os = "windows"))] -async fn start_process_stdout_read_honors_process_timeout() { +async fn start_process_stdout_read_is_cancellable() { let output = baml_test!( r#" - function main() -> bool { + function main() -> string { let process = baml.sys.start_process( "sh", ["-c", "while :; do :; done"], - baml.sys.ProcessOptions { timeout_ms: 25 }, + null, ); defer { process.close() } - process.stdout.next() catch (e) { - let timeout: baml.errors.Timeout => { return true; }, - _ => { return false; }, + let tok = baml.spawn.CancelToken.new(); + let read = spawn with baml.spawn.options(cancel = tok) { + process.stdout.lines().next() + }; + let deadline = spawn { + baml.sys.sleep(baml.time.Duration.from_milliseconds(25n)); + tok.cancel() + }; + (await read) catch (e) { + baml.panics.Cancelled => "cancelled" }; - false + "cancelled" } "# ); - assert_eq!(output.result, Ok(BexExternalValue::Bool(true))); + assert_eq!( + output.result, + Ok(BexExternalValue::String("cancelled".into())), + "a line read from a silent child should be cancelled by the deadline task" + ); } #[tokio::test] diff --git a/baml_language/crates/bex_vm/src/package_baml/uint8array.rs b/baml_language/crates/bex_vm/src/package_baml/uint8array.rs index dce4566797b..9706563593d 100644 --- a/baml_language/crates/bex_vm/src/package_baml/uint8array.rs +++ b/baml_language/crates/bex_vm/src/package_baml/uint8array.rs @@ -41,6 +41,15 @@ impl BamlClassUint8Array for PackageBamlImpl { uint8array.contains(&item) } + #[allow(clippy::cast_possible_wrap)] + fn index_of(uint8array: &[u8], item: i64) -> Option { + let item = u8::try_from(item).ok()?; + uint8array + .iter() + .position(|byte| *byte == item) + .map(|index| index as i64) + } + fn reverse(uint8array: &[u8]) -> Vec { uint8array.iter().copied().rev().collect() } diff --git a/baml_language/crates/bridge_wasm/src/wasm_sys.rs b/baml_language/crates/bridge_wasm/src/wasm_sys.rs index f64d77a8749..18afeb228d7 100644 --- a/baml_language/crates/bridge_wasm/src/wasm_sys.rs +++ b/baml_language/crates/bridge_wasm/src/wasm_sys.rs @@ -104,49 +104,52 @@ fn options_to_js(options: Option<&io::owned::sys::ProcessOptions>) -> JsValue { } } -impl io::IoClassSysProcess for WasmSys { - fn write_stdin( +impl io::IoClassSysReadPipe for WasmSys { + fn read( &self, _heap: &Arc, _call_id: CallId, - _process: io::owned::sys::Process, - _data: String, + _readpipe: io::owned::sys::ReadPipe, + _limit: i64, _ctx: &SysOpContext, - ) -> SysOpOutput<()> { + ) -> SysOpOutput>> { SysOpOutput::err(VmBamlError::Unsupported { message: "Live processes are not supported on this platform".to_string(), }) } - fn close_stdin( + fn close( &self, _heap: &Arc, _call_id: CallId, - _process: io::owned::sys::Process, + _readpipe: io::owned::sys::ReadPipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Live processes are not supported on this platform".to_string(), }) } +} - fn wait( +impl io::IoClassSysWritePipe for WasmSys { + fn write( &self, _heap: &Arc, _call_id: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, + _data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput { SysOpOutput::err(VmBamlError::Unsupported { message: "Live processes are not supported on this platform".to_string(), }) } - fn kill( + fn flush( &self, _heap: &Arc, _call_id: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { @@ -158,21 +161,35 @@ impl io::IoClassSysProcess for WasmSys { &self, _heap: &Arc, _call_id: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { - SysOpOutput::ok(()) + SysOpOutput::err(VmBamlError::Unsupported { + message: "Live processes are not supported on this platform".to_string(), + }) } } -impl io::IoClassSysProcessLineStream for WasmSys { - fn _next( +impl io::IoClassSysProcess for WasmSys { + fn wait( + &self, + _heap: &Arc, + _call_id: CallId, + _process: io::owned::sys::Process, + _ctx: &SysOpContext, + ) -> SysOpOutput { + SysOpOutput::err(VmBamlError::Unsupported { + message: "Live processes are not supported on this platform".to_string(), + }) + } + + fn kill( &self, _heap: &Arc, _call_id: CallId, - _processlinestream: io::owned::sys::ProcessLineStream, + _process: io::owned::sys::Process, _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Live processes are not supported on this platform".to_string(), }) @@ -182,7 +199,7 @@ impl io::IoClassSysProcessLineStream for WasmSys { &self, _heap: &Arc, _call_id: CallId, - _processlinestream: io::owned::sys::ProcessLineStream, + _process: io::owned::sys::Process, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::ok(()) diff --git a/baml_language/crates/sys_native/src/io_impls.rs b/baml_language/crates/sys_native/src/io_impls.rs index c66b927b512..3095220966c 100644 --- a/baml_language/crates/sys_native/src/io_impls.rs +++ b/baml_language/crates/sys_native/src/io_impls.rs @@ -1232,24 +1232,69 @@ impl io::IoClassGlobGlob for NativeSysOps { // ============================================================================ type NativeProcessResult = Result; -type NativeProcessLineResult = Result; struct LiveProcessHandle { kill_tx: tokio::sync::watch::Sender, exit_rx: tokio::sync::watch::Receiver>, - stdin: tokio::sync::Mutex>, deadline: Option, timeout_ms: Option, label: String, } -struct ProcessLineStreamHandle { - lines: tokio::sync::Mutex>, - close_tx: tokio::sync::watch::Sender, - closed: std::sync::atomic::AtomicBool, - deadline: Option, - timeout_ms: Option, +struct ReadPipeHandle { + reader: tokio::sync::Mutex>>, + label: String, +} + +/// The engine-owned write end of a pipe (`baml.sys.WritePipe._pipe`). +struct WritePipeHandle { + writer: tokio::sync::Mutex>>, + label: String, +} + +fn downcast_read_pipe(pipe: &owned::sys::ReadPipe) -> Result, VmBamlError> { + pipe._pipe + .clone() + .downcast::() + .map_err(|_| VmBamlError::DevOther { + message: "Invalid read pipe handle type".into(), + }) +} + +fn downcast_write_pipe(pipe: &owned::sys::WritePipe) -> Result, VmBamlError> { + pipe._pipe + .clone() + .downcast::() + .map_err(|_| VmBamlError::DevOther { + message: "Invalid write pipe handle type".into(), + }) +} + +fn read_pipe( + reader: impl tokio::io::AsyncRead + Send + Unpin + 'static, + label: String, +) -> owned::sys::ReadPipe { + owned::sys::ReadPipe { + _pipe: Arc::new(ReadPipeHandle { + reader: tokio::sync::Mutex::new(Some(Box::new(reader))), + label, + }), + } +} + +/// Frame a reader's bytes into the line stream `ReadPipe.lines()` returns. The +/// reader is moved onto a task that owns it for the rest of its life, which is +/// why `lines()` consumes the pipe. +fn write_pipe( + writer: impl tokio::io::AsyncWrite + Send + Unpin + 'static, label: String, +) -> owned::sys::WritePipe { + owned::sys::WritePipe { + _pipe: Arc::new(WritePipeHandle { + writer: tokio::sync::Mutex::new(Some(Box::new(writer))), + label, + }), + } } fn downcast_process_handle( @@ -1264,18 +1309,6 @@ fn downcast_process_handle( }) } -fn downcast_process_line_stream_handle( - stream: &owned::sys::ProcessLineStream, -) -> Result, VmBamlError> { - stream - ._handle - .clone() - .downcast::() - .map_err(|_| VmBamlError::DevOther { - message: "Invalid process stdout stream handle type".into(), - }) -} - fn process_exit_from_status(status: std::process::ExitStatus) -> owned::sys::ProcessExit { #[cfg(unix)] let signal = { @@ -1312,103 +1345,53 @@ async fn receive_process_exit( } } -fn start_stdout_line_reader( - stdout: tokio::process::ChildStdout, - deadline: Option, - timeout_ms: Option, - label: String, -) -> owned::sys::ProcessLineStream { - let (lines_tx, lines_rx) = tokio::sync::mpsc::channel(32); - let (close_tx, mut close_rx) = tokio::sync::watch::channel(false); - let reader_label = label.clone(); - - tokio::spawn(async move { - use tokio::io::AsyncBufReadExt as _; - - let mut reader = tokio::io::BufReader::new(stdout); - let mut bytes = Vec::new(); - loop { - bytes.clear(); - let read_result = tokio::select! { - biased; - _ = close_rx.changed() => break, - result = reader.read_until(b'\n', &mut bytes) => result, - }; - - match read_result { - Ok(0) => break, - Ok(_) => { - if bytes.last() == Some(&b'\n') { - bytes.pop(); - } - if bytes.last() == Some(&b'\r') { - bytes.pop(); - } - let line = String::from_utf8_lossy(&bytes).into_owned(); - tokio::select! { - biased; - _ = close_rx.changed() => break, - result = lines_tx.send(Ok(line)) => { - if result.is_err() { - break; - } - } - } - } - Err(error) => { - let _ = lines_tx - .send(Err(format!( - "Failed to read stdout from '{reader_label}': {error}" - ))) - .await; - break; - } - } - } - }); - - owned::sys::ProcessLineStream { - _handle: Arc::new(ProcessLineStreamHandle { - lines: tokio::sync::Mutex::new(lines_rx), - close_tx, - closed: std::sync::atomic::AtomicBool::new(false), - deadline, - timeout_ms, - label, - }), - } -} - -impl io::IoClassSysProcessLineStream for NativeSysOps { - fn _next( +impl io::IoClassSysReadPipe for NativeSysOps { + fn read( &self, _heap: &Arc, _call_id: CallId, - processlinestream: owned::sys::ProcessLineStream, + readpipe: owned::sys::ReadPipe, + limit: i64, _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput>> { + use tokio::io::AsyncReadExt as _; + + // A zero-length result means end-of-pipe only when bytes were actually + // requested, so a request for none is an empty chunk (as in `fs::File`). + let limit = match usize::try_from(limit) { + Err(_) | Ok(0) => return SysOpOutput::ok(Some(Vec::new())), + Ok(limit) => limit, + }; + SysOpOutput::async_op(async move { - let handle = downcast_process_line_stream_handle(&processlinestream)?; - if handle.closed.load(std::sync::atomic::Ordering::Acquire) { - return Ok(None); - } - let mut lines = handle.lines.lock().await; - let next_line = if let Some(deadline) = handle.deadline { - match tokio::time::timeout_at(deadline, lines.recv()).await { - Ok(line) => line, - Err(_) => { - return Err(process_timeout_error(&handle.label, handle.timeout_ms).into()); - } - } - } else { - lines.recv().await - }; + let handle = downcast_read_pipe(&readpipe)?; + let mut guard = handle.reader.lock().await; + let reader = guard.as_mut().ok_or_else(|| VmBamlError::Io { + message: format!("Read pipe for '{}' is closed", handle.label), + })?; - match next_line { - Some(Ok(line)) => Ok(Some(line)), - Some(Err(message)) => Err(VmBamlError::Io { message }.into()), - None => Ok(None), + let mut buffer = Vec::new(); + buffer + .try_reserve(limit) + .map_err(|error| VmPanic::AllocFailure { + message: format!("Failed to reserve a {limit} byte read buffer: {error}"), + })?; + buffer.resize(limit, 0); + + let read = reader + .read(&mut buffer) + .await + .map_err(|error| VmBamlError::Io { + message: format!("Failed to read from '{}': {error}", handle.label), + })?; + // The writer's close is sticky — further reads keep returning 0 — + // so EOF needs no bookkeeping, and the handle stays live to keep + // reporting EOF rather than the "closed" error a drop would give. + if read == 0 { + return Ok(None); } + buffer.truncate(read); + Ok(Some(buffer)) }) } @@ -1416,62 +1399,94 @@ impl io::IoClassSysProcessLineStream for NativeSysOps { &self, _heap: &Arc, _call_id: CallId, - processlinestream: owned::sys::ProcessLineStream, + readpipe: owned::sys::ReadPipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { - if let Ok(handle) = downcast_process_line_stream_handle(&processlinestream) { - handle - .closed - .store(true, std::sync::atomic::Ordering::Release); - let _ = handle.close_tx.send(true); - } - SysOpOutput::ok(()) + SysOpOutput::async_op(async move { + let handle = downcast_read_pipe(&readpipe)?; + handle.reader.lock().await.take(); + Ok(()) + }) } } -impl io::IoClassSysProcess for NativeSysOps { - fn write_stdin( +impl io::IoClassSysWritePipe for NativeSysOps { + fn write( &self, _heap: &Arc, _call_id: CallId, - process: owned::sys::Process, - data: String, + writepipe: owned::sys::WritePipe, + data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput<()> { + ) -> SysOpOutput { + use tokio::io::AsyncWriteExt as _; + SysOpOutput::async_op(async move { - use tokio::io::AsyncWriteExt as _; + let handle = downcast_write_pipe(&writepipe)?; + let mut guard = handle.writer.lock().await; + let writer = guard.as_mut().ok_or_else(|| VmBamlError::Io { + message: format!("Write pipe for '{}' is closed", handle.label), + })?; - let handle = downcast_process_handle(&process)?; - let mut stdin = handle.stdin.lock().await; - let pipe = stdin.as_mut().ok_or_else(|| VmBamlError::Io { - message: format!("Stdin for '{}' is not open", handle.label), + // A single write, per the `baml.io.Write` contract: the count is + // what reached the pipe, and `write_all` loops over the remainder. + let written = writer.write(&data).await.map_err(|error| VmBamlError::Io { + message: format!("Failed to write to '{}': {error}", handle.label), })?; - pipe.write_all(data.as_bytes()) - .await - .map_err(|error| VmBamlError::Io { - message: format!("Failed to write stdin to '{}': {error}", handle.label), - })?; - pipe.flush().await.map_err(|error| VmBamlError::Io { - message: format!("Failed to flush stdin for '{}': {error}", handle.label), + Ok(i64::try_from(written) + .unwrap_or_else(|_| unreachable!("a single write cannot exceed i64::MAX"))) + }) + } + + fn flush( + &self, + _heap: &Arc, + _call_id: CallId, + writepipe: owned::sys::WritePipe, + _ctx: &SysOpContext, + ) -> SysOpOutput<()> { + use tokio::io::AsyncWriteExt as _; + + SysOpOutput::async_op(async move { + let handle = downcast_write_pipe(&writepipe)?; + let mut guard = handle.writer.lock().await; + let writer = guard.as_mut().ok_or_else(|| VmBamlError::Io { + message: format!("Write pipe for '{}' is closed", handle.label), + })?; + writer.flush().await.map_err(|error| VmBamlError::Io { + message: format!("Failed to flush '{}': {error}", handle.label), })?; Ok(()) }) } - fn close_stdin( + fn close( &self, _heap: &Arc, _call_id: CallId, - process: owned::sys::Process, + writepipe: owned::sys::WritePipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { + use tokio::io::AsyncWriteExt as _; + SysOpOutput::async_op(async move { - let handle = downcast_process_handle(&process)?; - handle.stdin.lock().await.take(); + let handle = downcast_write_pipe(&writepipe)?; + // Flush before dropping: the reader at the far end sees EOF as + // soon as the descriptor closes, so anything still buffered here + // would be lost rather than delivered. + let mut writer = handle.writer.lock().await; + if let Some(writer) = writer.as_mut() { + writer.flush().await.map_err(|error| VmBamlError::Io { + message: format!("Failed to flush '{}' before close: {error}", handle.label), + })?; + } + writer.take(); Ok(()) }) } +} +impl io::IoClassSysProcess for NativeSysOps { fn wait( &self, _heap: &Arc, @@ -1523,16 +1538,23 @@ impl io::IoClassSysProcess for NativeSysOps { process: owned::sys::Process, _ctx: &SysOpContext, ) -> SysOpOutput<()> { - if let Ok(handle) = downcast_process_handle(&process) { - let _ = handle.kill_tx.send(true); - } - if let Ok(handle) = downcast_process_line_stream_handle(&process.stdout) { - handle - .closed - .store(true, std::sync::atomic::Ordering::Release); - let _ = handle.close_tx.send(true); - } - SysOpOutput::ok(()) + // Declared `throws never`, so every step here is best-effort: closing + // an already-closed pipe or an exited child is a no-op, and a bad + // handle has nowhere to report. + SysOpOutput::async_op(async move { + if let Ok(handle) = downcast_process_handle(&process) { + let _ = handle.kill_tx.send(true); + } + if let Ok(handle) = downcast_write_pipe(&process.stdin) { + handle.writer.lock().await.take(); + } + for pipe in [&process.stdout, &process.stderr] { + if let Ok(handle) = downcast_read_pipe(pipe) { + handle.reader.lock().await.take(); + } + } + Ok(()) + }) } } @@ -1680,40 +1702,26 @@ impl io::IoNamespaceSys for NativeSysOps { .map(|(key, value)| (key.as_str(), value.as_str())), ); } - if options.stdin.is_some() || options.keep_stdin_open == Some(true) { - cmd.stdin(Stdio::piped()); - } } - cmd.stdout(Stdio::piped()) - .stderr(Stdio::inherit()) + // `Process` exposes all three streams as pipes, so all three are + // piped unconditionally. Stderr is no longer inherited: the caller + // owns it and must drain it, or the child blocks once the pipe + // buffer fills. + cmd.stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) .kill_on_drop(true); let mut child = cmd.spawn().map_err(|error| VmBamlError::Io { message: format!("Failed to spawn '{program}': {error}"), })?; - let stdout = child.stdout.take().ok_or_else(|| VmBamlError::Io { - message: format!("Failed to capture stdout from '{program}'"), - })?; - - let keep_stdin_open = options - .as_ref() - .and_then(|options| options.keep_stdin_open) - .unwrap_or(false); - let mut stdin = child.stdin.take(); - if let Some(stdin_data) = options.as_ref().and_then(|options| options.stdin.as_ref()) { - if let Some(stdin) = stdin.as_mut() { - stdin - .write_all(stdin_data.as_bytes()) - .await - .map_err(|error| VmBamlError::Io { - message: format!("Failed to write stdin to '{program}': {error}"), - })?; - } - } - if !keep_stdin_open { - stdin = None; - } + let missing_pipe = |stream: &str| VmBamlError::Io { + message: format!("Failed to capture {stream} from '{program}'"), + }; + let child_stdin = child.stdin.take().ok_or_else(|| missing_pipe("stdin"))?; + let child_stdout = child.stdout.take().ok_or_else(|| missing_pipe("stdout"))?; + let child_stderr = child.stderr.take().ok_or_else(|| missing_pipe("stderr"))?; let timeout_ms = options .as_ref() @@ -1724,7 +1732,28 @@ impl io::IoNamespaceSys for NativeSysOps { milliseconds.cast_unsigned(), )) }); - let stdout = start_stdout_line_reader(stdout, deadline, timeout_ms, program.clone()); + + let stdin = write_pipe(child_stdin, format!("{program} stdin")); + let stdout = read_pipe(child_stdout, format!("{program} stdout")); + let stderr = read_pipe(child_stderr, format!("{program} stderr")); + + // `options.stdin` supplies the child's COMPLETE input, so the pipe + // is closed after it lands — a child that reads to EOF would + // otherwise hang. Incremental writers leave it unset and drive + // `process.stdin` themselves. + if let Some(stdin_data) = options.as_ref().and_then(|options| options.stdin.as_ref()) { + let handle = downcast_write_pipe(&stdin)?; + let mut writer = handle.writer.lock().await; + if let Some(writer) = writer.as_mut() { + writer + .write_all(stdin_data.as_bytes()) + .await + .map_err(|error| VmBamlError::Io { + message: format!("Failed to write stdin to '{program}': {error}"), + })?; + } + writer.take(); + } let (kill_tx, mut kill_rx) = tokio::sync::watch::channel(false); let (exit_tx, exit_rx) = tokio::sync::watch::channel(None); @@ -1744,11 +1773,12 @@ impl io::IoNamespaceSys for NativeSysOps { }); Ok(owned::sys::Process { + stdin, stdout, + stderr, _handle: Arc::new(LiveProcessHandle { kill_tx, exit_rx, - stdin: tokio::sync::Mutex::new(stdin), deadline, timeout_ms, label: program, diff --git a/baml_language/crates/sys_ops/src/lib.rs b/baml_language/crates/sys_ops/src/lib.rs index 7030cd5e70b..6a08b784c55 100644 --- a/baml_language/crates/sys_ops/src/lib.rs +++ b/baml_language/crates/sys_ops/src/lib.rs @@ -1553,49 +1553,52 @@ impl io::IoNamespaceIo for DefaultIoOps { } } -impl io::IoClassSysProcess for DefaultIoOps { - fn write_stdin( +impl io::IoClassSysReadPipe for DefaultIoOps { + fn read( &self, _h: &Arc, _c: CallId, - _process: io::owned::sys::Process, - _data: String, + _readpipe: io::owned::sys::ReadPipe, + _limit: i64, _ctx: &SysOpContext, - ) -> SysOpOutput<()> { + ) -> SysOpOutput>> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) } - fn close_stdin( + fn close( &self, _h: &Arc, _c: CallId, - _process: io::owned::sys::Process, + _readpipe: io::owned::sys::ReadPipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) } +} - fn wait( +impl io::IoClassSysWritePipe for DefaultIoOps { + fn write( &self, _h: &Arc, _c: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, + _data: Vec, _ctx: &SysOpContext, - ) -> SysOpOutput { + ) -> SysOpOutput { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) } - fn kill( + fn flush( &self, _h: &Arc, _c: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { @@ -1607,21 +1610,35 @@ impl io::IoClassSysProcess for DefaultIoOps { &self, _h: &Arc, _c: CallId, - _process: io::owned::sys::Process, + _writepipe: io::owned::sys::WritePipe, _ctx: &SysOpContext, ) -> SysOpOutput<()> { - SysOpOutput::ok(()) + SysOpOutput::err(VmBamlError::Unsupported { + message: "Operation not supported on this platform".to_string(), + }) } } -impl io::IoClassSysProcessLineStream for DefaultIoOps { - fn _next( +impl io::IoClassSysProcess for DefaultIoOps { + fn wait( &self, _h: &Arc, _c: CallId, - _processlinestream: io::owned::sys::ProcessLineStream, + _process: io::owned::sys::Process, _ctx: &SysOpContext, - ) -> SysOpOutput> { + ) -> SysOpOutput { + SysOpOutput::err(VmBamlError::Unsupported { + message: "Operation not supported on this platform".to_string(), + }) + } + + fn kill( + &self, + _h: &Arc, + _c: CallId, + _process: io::owned::sys::Process, + _ctx: &SysOpContext, + ) -> SysOpOutput<()> { SysOpOutput::err(VmBamlError::Unsupported { message: "Operation not supported on this platform".to_string(), }) @@ -1631,7 +1648,7 @@ impl io::IoClassSysProcessLineStream for DefaultIoOps { &self, _h: &Arc, _c: CallId, - _processlinestream: io::owned::sys::ProcessLineStream, + _process: io::owned::sys::Process, _ctx: &SysOpContext, ) -> SysOpOutput<()> { SysOpOutput::ok(()) From 9dc57b49bd344c8d1f79f31e1cc1d96a36029605 Mon Sep 17 00:00:00 2001 From: 2kai2kai2 Date: Mon, 17 Aug 2026 18:46:23 -0700 Subject: [PATCH 5/5] Coderabbit fixes --- .../baml_std/baml/ns_future/future.baml | 41 ++++ .../baml_std/baml/ns_io/read.baml | 6 +- .../baml_std/baml/ns_sys/sys.baml | 28 ++- .../baml_std/claude_code/ns_internal/cli.baml | 19 +- ...tests__render_builtin_package_listing.snap | 34 +-- .../ns_with_timeout/with_timeout.baml | 55 +++++ .../baml_tests/snapshots/baml_src/_root.snap | 3 + .../snapshots/baml_src/with_timeout.snap | 102 +++++++++ ...tests__compiles____ai_std____04_5_mir.snap | 2 +- ...sts__compiles____ai_std____06_codegen.snap | 3 +- ...ests__compiles____baml_std____03_ppir.snap | 12 +- ...sts__compiles____baml_std____04_5_mir.snap | 193 ++++++++++++++++-- ...s__compiles____baml_std____06_codegen.snap | 119 ++++++++++- ...__phase5__snapshot_baml_package_items.snap | 2 + .../crates/baml_tests/tests/shell.rs | 123 ++++++++++- .../crates/bex_engine/tests/collect_tests.rs | 2 +- .../crates/sys_native/src/io_impls.rs | 126 +++++++++--- .../sdk_tests/harness_setup/src/csharp.rs | 29 ++- 18 files changed, 814 insertions(+), 85 deletions(-) create mode 100644 baml_language/crates/baml_tests/baml_src/ns_with_timeout/with_timeout.baml create mode 100644 baml_language/crates/baml_tests/snapshots/baml_src/with_timeout.snap diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_future/future.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_future/future.baml index a2039d1ecff..1ed0983a1c8 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_future/future.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_future/future.baml @@ -238,3 +238,44 @@ function any( winners[0] } } + +/// Runs `body` under a deadline, throwing `baml.errors.Timeout` if `limit` +/// elapses first. +/// +/// The work runs under a cancel token that a sleeping task fires, so a body +/// parked in a sys-op (a socket read, a child's stdout) is unparked rather +/// than left running — this is the general form of a deadline in BAML, since +/// `read` and friends take no timeout of their own. +function with_timeout( + limit: baml.time.Duration, + body: () -> T throws E, +) -> T throws E | baml.errors.Timeout { + let token = baml.spawn.CancelToken.new(); + let work = spawn with baml.spawn.options(cancel = token) { + body() + }; + let deadline = spawn { + baml.sys.sleep(limit); + token.cancel() + }; + let out = (await work) catch (e) { + // The token fires only from the timer above, so a cancelled body is + // an expired deadline — anything the body itself threw is `E` and + // propagates untouched. + baml.panics.Cancelled => { + let limit_ms = limit.to_milliseconds(); + // `duration_ms` is an `int`, so a limit too large to fit is + // reported by message alone rather than failing the throw itself. + let reported = limit_ms.to_int() catch (conversion) { + baml.errors.InvalidArgument => null, + }; + throw baml.errors.Timeout { + message: `operation timed out after ${limit_ms}ms`, + duration_ms: reported, + } + } + }; + // The body won; stop the timer rather than leaving it to fire later. + deadline.cancel(); + out +} diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml index d11b6a0a722..5d4fdc09458 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_io/read.baml @@ -8,9 +8,13 @@ interface Read { function read(self, limit: int) -> uint8array? throws root.errors.Io /// Reads all remaining bytes from the source until EOF is reached. + /// + /// Drains in fixed-size chunks rather than asking for everything at once: + /// an implementor is free to size a buffer from `limit`, so a limit of + /// `int.max_value()` is a request to allocate more memory than exists. function read_to_end(self) -> uint8array throws root.errors.Io { let buf = b""; - while let chunk: uint8array = self.read(int.max_value()) { + while let chunk: uint8array = self.read(65536) { buf = buf.concat(chunk); } buf diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml index 892211f3733..9f7c445eaad 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_sys/sys.baml @@ -13,6 +13,24 @@ class ProcessOptions { /// No longer has any effect: `start_process` always hands back a writable /// `Process.stdin`, and EOF is delivered by closing that pipe. keep_stdin_open: bool?, + /// Where the child's stderr goes. `null` means `StderrMode.Inherit`, and + /// only `StderrMode.Pipe` populates `Process.stderr`. + stderr: StderrMode?, +} + +/// Where a child process's standard error goes. +enum StderrMode { + /// The child writes to this process's own stderr. Nothing can block on an + /// unread pipe, and the child's diagnostics stay visible — which is why + /// this is the default. + Inherit, + /// The child's stderr becomes `Process.stderr`, a pipe the caller owns. + /// The OS buffer holds only a few tens of kilobytes, and the child blocks + /// once it fills, so a caller that asks for the pipe must drain it — + /// concurrently with stdout, not after it. + Pipe, + /// The child's stderr is discarded. + Discard, } /// The result of running an external process with `exec` or `shell`. @@ -119,14 +137,16 @@ function _strip_carriage_return(line: uint8array) -> uint8array throws never { /// A live child process created with `start_process`. /// -/// All three streams are pipes the caller owns and consumes incrementally. -/// Stderr is no longer inherited from the parent, so a child that writes more -/// than the pipe buffer holds blocks until `stderr` is drained. +/// `stdin` and `stdout` are always pipes the caller owns and consumes +/// incrementally. `stderr` is one only when `ProcessOptions.stderr` asked for +/// it; by default the child writes straight to this process's stderr. class Process { _handle: $rust_type, stdin: WritePipe, stdout: ReadPipe, - stderr: ReadPipe, + /// The child's stderr, present only under `StderrMode.Pipe`. Draining it + /// is then the caller's job: an ignored pipe stops the child. + stderr: ReadPipe?, /// Wait for the child to exit. function wait(self) -> ProcessExit throws root.errors.Io | root.errors.Timeout { diff --git a/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml b/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml index 4300ff7541d..b4475de5ff5 100644 --- a/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml +++ b/baml_language/crates/baml_builtins2/baml_std/claude_code/ns_internal/cli.baml @@ -303,7 +303,24 @@ function invoke(c: root.ClaudeCodeClient, input: ai.ModelTurnInput) -> ai.ModelT }; // events stream LIVE: each JSONL line logs as it arrives, and the last // relevant line is the result. Stderr inherits the parent process. - let result = _read_result(p); + // + // `ProcessOptions.timeout_ms` bounds `wait()` only — reading stdout goes + // through `baml.io.Read`, which carries no deadline — so the drain runs + // under its own, or a silent CLI parks this call forever. + let result = baml.future.with_timeout( + baml.time.Duration.from_milliseconds(c.timeout_ms), + () -> { + _read_result(p) + }, + ) catch (e) { + baml.errors.Timeout => { + throw ai.errors.NetworkFailure { + provider: "claude-code", + detail: `the Claude Code CLI produced no result within ${c.timeout_ms}ms`, + raw_body: null, + } + }, + }; let exit = p.wait() catch_all (e) { _ => { throw ai.errors.NetworkFailure { diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index c0e366d7934..557b5e9c627 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -135,6 +135,7 @@ class baml.future.AllFailed /baml/ns_future/futur function baml.future.__await_any /baml/ns_future/future.baml:145 function baml.future.race /baml/ns_future/future.baml:153 function baml.future.any /baml/ns_future/future.baml:169 +function baml.future.with_timeout /baml/ns_future/future.baml:249 class baml.glob.ScanOptions /baml/ns_glob/glob.baml:2 class baml.glob.Glob /baml/ns_glob/glob.baml:18 function baml.glob.new /baml/ns_glob/glob.baml:34 @@ -304,22 +305,23 @@ class baml.spawn.TaskGroup /baml/ns_spawn/spawn. class baml.spawn.CancelToken /baml/ns_spawn/spawn.baml:85 function baml.spawn.options /baml/ns_spawn/spawn.baml:123 class baml.sys.ProcessOptions /baml/ns_sys/sys.baml:2 -class baml.sys.ShellOutput /baml/ns_sys/sys.baml:19 -class baml.sys.ProcessExit /baml/ns_sys/sys.baml:31 -class baml.sys.ReadPipeLines /baml/ns_sys/sys.baml:52 -function baml.sys._strip_carriage_return /baml/ns_sys/sys.baml:113 -class baml.sys.Process /baml/ns_sys/sys.baml:125 -class baml.sys.ReadPipe /baml/ns_sys/sys.baml:153 -class baml.sys.WritePipe /baml/ns_sys/sys.baml:175 -function baml.sys.exec /baml/ns_sys/sys.baml:195 -function baml.sys.start_process /baml/ns_sys/sys.baml:207 -function baml.sys.shell /baml/ns_sys/sys.baml:216 -function baml.sys.sleep /baml/ns_sys/sys.baml:224 -function baml.sys.collect_garbage /baml/ns_sys/sys.baml:231 -function baml.sys.panic /baml/ns_sys/sys.baml:237 -function baml.sys.exit /baml/ns_sys/sys.baml:243 -function baml.sys.argv /baml/ns_sys/sys.baml:249 -function baml.sys.pid /baml/ns_sys/sys.baml:258 +enum baml.sys.StderrMode /baml/ns_sys/sys.baml:22 +class baml.sys.ShellOutput /baml/ns_sys/sys.baml:37 +class baml.sys.ProcessExit /baml/ns_sys/sys.baml:49 +class baml.sys.ReadPipeLines /baml/ns_sys/sys.baml:70 +function baml.sys._strip_carriage_return /baml/ns_sys/sys.baml:131 +class baml.sys.Process /baml/ns_sys/sys.baml:143 +class baml.sys.ReadPipe /baml/ns_sys/sys.baml:173 +class baml.sys.WritePipe /baml/ns_sys/sys.baml:195 +function baml.sys.exec /baml/ns_sys/sys.baml:215 +function baml.sys.start_process /baml/ns_sys/sys.baml:227 +function baml.sys.shell /baml/ns_sys/sys.baml:236 +function baml.sys.sleep /baml/ns_sys/sys.baml:244 +function baml.sys.collect_garbage /baml/ns_sys/sys.baml:251 +function baml.sys.panic /baml/ns_sys/sys.baml:257 +function baml.sys.exit /baml/ns_sys/sys.baml:263 +function baml.sys.argv /baml/ns_sys/sys.baml:269 +function baml.sys.pid /baml/ns_sys/sys.baml:278 class baml.time.Duration /baml/ns_time/duration.baml:4 class baml.time.Instant /baml/ns_time/instant.baml:2 class baml.time.PlainDate /baml/ns_time/plaindate.baml:5 diff --git a/baml_language/crates/baml_tests/baml_src/ns_with_timeout/with_timeout.baml b/baml_language/crates/baml_tests/baml_src/ns_with_timeout/with_timeout.baml new file mode 100644 index 00000000000..738d03a7554 --- /dev/null +++ b/baml_language/crates/baml_tests/baml_src/ns_with_timeout/with_timeout.baml @@ -0,0 +1,55 @@ +// Tests for `baml.future.with_timeout` — the deadline combinator that bounds +// any blocking body, since `baml.io.Read.read` and friends take no timeout of +// their own. +// +// Both cases are deterministic: the sleeps differ by orders of magnitude, so +// neither outcome depends on scheduling luck. + +// A body that finishes well inside the limit yields its value. +function with_timeout_returns_the_value_fn() -> int { + baml.future.with_timeout( + baml.time.Duration.from_seconds(30), + () -> { + 42 + }, + ) +} + +test "with_timeout_returns_the_value" { + assert.equal(with_timeout_returns_the_value_fn(), 42) +} + +// A body still parked when the limit elapses is cancelled and reported as +// `baml.errors.Timeout`; the sleeping body would otherwise run for a minute. +function with_timeout_throws_on_expiry_fn() -> string { + baml.future.with_timeout( + baml.time.Duration.from_milliseconds(25), + () -> { + baml.sys.sleep(baml.time.Duration.from_seconds(60)); + "finished" + }, + ) catch (e) { + baml.errors.Timeout => "timed out", + } +} + +test "with_timeout_throws_on_expiry" { + assert.equal(with_timeout_throws_on_expiry_fn(), "timed out") +} + +// The body's own error is not a timeout: it propagates with its own type. +function with_timeout_propagates_body_errors_fn() -> string { + baml.future.with_timeout( + baml.time.Duration.from_seconds(30), + () -> { + throw baml.errors.Io { message: "from the body" } + }, + ) catch (e) { + baml.errors.Timeout => "timed out", + baml.errors.Io => "io", + } +} + +test "with_timeout_propagates_body_errors" { + assert.equal(with_timeout_propagates_body_errors_fn(), "io") +} diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/_root.snap b/baml_language/crates/baml_tests/snapshots/baml_src/_root.snap index c9c5644a72d..c7bcb52d462 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/_root.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/_root.snap @@ -431,6 +431,9 @@ function $init_test(registry: unknown) -> null { load_var ?1 call ? pop 1 + load_var ?1 + call ? + pop 1 load_const ? return } diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/with_timeout.snap b/baml_language/crates/baml_tests/snapshots/baml_src/with_timeout.snap new file mode 100644 index 00000000000..54dd3364039 --- /dev/null +++ b/baml_language/crates/baml_tests/snapshots/baml_src/with_timeout.snap @@ -0,0 +1,102 @@ +--- +source: crates/baml_tests/tests/baml_src.rs +--- +function with_timeout.$init_test_ns_with_timeout_with_timeout(registry: testing.TestCollector) -> null { + load_var registry + load_const "root.with_timeout" + load_const "with_timeout_returns_the_value" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_var registry + load_const "root.with_timeout" + load_const "with_timeout_throws_on_expiry" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_var registry + load_const "root.with_timeout" + load_const "with_timeout_propagates_body_errors" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test_at + pop 1 + load_const null + return +} + +function with_timeout.with_timeout_propagates_body_errors_fn() -> string { + load_const 30 + call baml.time.Duration.from_seconds + store_var _2 + load_type never + load_type baml.errors.Io + load_var _2 + make_closure ., 0 + call baml.future.with_timeout + jump L4 + load_var e + is_type baml.errors.Timeout + pop_jump_if_false L0 + jump L3 + + L0: + load_var e + is_type baml.errors.Io + pop_jump_if_false L1 + jump L2 + + L1: + load_var e + rethrow + + L2: + load_const "io" + jump L4 + + L3: + load_const "timed out" + + L4: + return +} + +function with_timeout.with_timeout_returns_the_value_fn() -> int { + load_const 30 + call baml.time.Duration.from_seconds + store_var _1 + load_type int + load_type never + load_var _1 + make_closure ., 0 + call baml.future.with_timeout + return +} + +function with_timeout.with_timeout_throws_on_expiry_fn() -> string { + load_const 25 + call baml.time.Duration.from_milliseconds + store_var _2 + load_type string + load_type baml.errors.Io + load_var _2 + make_closure ., 0 + call baml.future.with_timeout + jump L2 + load_var e + is_type baml.errors.Timeout + pop_jump_if_false L0 + jump L1 + + L0: + load_var e + rethrow + + L1: + load_const "timed out" + + L2: + return +} diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap index 02ab755f75a..18797c84d1f 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____04_5_mir.snap @@ -4353,7 +4353,7 @@ fn ai.mcp.McpConnection.connect(name: string, command: string, args: string[], t } bb2: { - _8 = baml.sys.ProcessOptions { const null, const null, copy _4, const null, const null }; + _8 = baml.sys.ProcessOptions { const null, const null, copy _4, const null, const null, const null }; _6 = sys_op const fn baml.sys.start_process(copy _2, copy _3, copy _8) -> bb3 unwind bb9; } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap index f2177c42a82..0eaffbfd0bc 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__ai_std__/baml_tests__compiles____ai_std____06_codegen.snap @@ -5020,7 +5020,8 @@ function ai.mcp.McpConnection.connect(name: string, command: string, args: strin load_var timeout_ms load_const null load_const null - init_instance baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open + load_const null + init_instance baml.sys.ProcessOptions .cwd, .env, .timeout_ms, .stdin, .keep_stdin_open, .stderr sys_op baml.sys.start_process store_var p jump L1 diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap index 21b29bcf736..6d84e3df5e9 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_ppir.snap @@ -864,6 +864,9 @@ function baml.future.race(futures: baml.future.Future[]) -> baml.future.Fu { } spawn { () -> { { let i = baml.future.__await_any(futures); futures.map((f) -> { { } f.cancel() }) } await futures[i] } } } function baml.future.state(self: ?) -> baml.future.FutureState [builtin] +function baml.future.with_timeout(limit: baml.time.Duration, body: () -> T throws E) -> T [expr] { + { let token = baml.spawn.CancelToken.new(); let work = spawn { () -> { { } body() } }; let deadline = spawn { () -> { { baml.sys.sleep(limit) } token.cancel() } }; let out = await work catch (e) { baml.panics.Cancelled => { let limit_ms = limit.to_milliseconds(); let reported = limit_ms.to_int() catch (conversion) { baml.errors.InvalidArgument => null }; throw baml.errors.Timeout { message: `...`, duration_ms: reported } } }; deadline.cancel() } out +} --- captures --- lambda () in all_complete: captures [futures] @@ -871,6 +874,8 @@ lambda () in all: captures [futures] lambda (f) in ?: captures [futures] lambda () in race: captures [futures] lambda () in any: captures [futures] +lambda () in with_timeout: captures [body] +lambda () in with_timeout: captures [limit, token] --- /baml/ns_glob/glob.baml --- class baml.glob.Glob { @@ -1009,7 +1014,7 @@ function baml.io.println(s: string) -> null [builtin] --- /baml/ns_io/read.baml --- function baml.io.read(self: ?, limit: int) -> uint8array? [missing] function baml.io.read_to_end(self: ?) -> uint8array [expr] { - { let buf = b"<0 bytes>"; while let chunk: uint8array = self.read(int.max_value()) { buf = buf.concat(chunk) } } buf + { let buf = b"<0 bytes>"; while let chunk: uint8array = self.read(65536) { buf = buf.concat(chunk) } } buf } function baml.io.read_to_string(self: ?) -> string [expr] { { let buf = self.read_to_end() } string.from_utf8(buf) catch (_) { _ => throw root.errors.ParseError { message: "invalid utf-8" } } @@ -2102,7 +2107,7 @@ class baml.sys.Process { _handle: $rust_type stdin: baml.sys.WritePipe stdout: baml.sys.ReadPipe - stderr: baml.sys.ReadPipe + stderr: baml.sys.ReadPipe? } class baml.sys.Process$stream { _handle: $rust_type @@ -2124,6 +2129,7 @@ class baml.sys.ProcessOptions { timeout_ms: int? stdin: string? keep_stdin_open: bool? + stderr: baml.sys.StderrMode? } class baml.sys.ProcessOptions$stream { cwd: string | null @@ -2131,6 +2137,7 @@ class baml.sys.ProcessOptions$stream { timeout_ms: int | null stdin: string | null keep_stdin_open: bool | null + stderr: baml.sys.StderrMode | null } class baml.sys.ReadPipe { _pipe: $rust_type @@ -2162,6 +2169,7 @@ class baml.sys.WritePipe { class baml.sys.WritePipe$stream { _pipe: $rust_type } +enum baml.sys.StderrMode {Inherit, Pipe, Discard} function baml.sys._strip_carriage_return(line: uint8array) -> uint8array [expr] { { } match (line.at(line.length() Sub 1)) { 13 => line.slice(0, line.length() Sub 1), _ => line } } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index ea2adc4aa09..6448e067225 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -3907,6 +3907,170 @@ fn ., 1)>(g: future) -> bool { } } +fn baml.future.with_timeout(limit: baml.time.Duration, body: () -> T throws E) -> T { + // Locals: + let _0: T // _0 // return + let _1: baml.time.Duration // limit // param [captured] + let _2: () -> T throws E // body // param [captured] + let _3: baml.spawn.CancelToken // token [captured] + let _4: future // work + let _5: null + let _6: null + let _7: (baml.spawn.SpawnParams) -> baml.spawn.SpawnParams throws never + let _8: baml.spawn.CancelToken + let _9: type + let _10: type + let _11: null + let _12: future + let _13: future // deadline + let _14: null + let _15: future + let _16: T // out + let _17: unknown // e + let _18: null + let _19: bool + let _20: bigint // limit_ms + let _21: int | null // reported + let _22: unknown // conversion + let _23: bool + let _24: baml.errors.Timeout + let _25: string + let _26: string + let _27: string + let _28: bigint + let _29: type + let _30: int | null + let _31: bool + + bb0: { + _3 = call const fn baml.spawn.CancelToken.new() -> [bb1]; + } + + bb1: { + _5 = make_closure lambda[0]<2 type_args>(copy _2); + _6 = baml.spawn.SpawnParams { copy _5, const null, const null, const null, const false }; + _8 = copy _3; + _9 = load_type(#0); + _10 = load_type(#1); + _7 = call const fn baml.spawn.options(const , copy _8, const ) -> [bb2]; + } + + bb2: { + _11 = call copy _7(copy _6) -> [bb3]; + } + + bb3: { + _12 = spawn<#0, #1> copy _5 name=const null config=copy _11 -> bb4; + } + + bb4: { + _4 = copy _12; + _14 = make_closure lambda[1]<2 type_args>(copy _1, copy _3); + _15 = spawn copy _14 name=const null -> bb5; + } + + bb5: { + _13 = copy _15; + _18 = copy _4; + _16 = await _18 -> [bb6, unwind: bb9]; + } + + bb6: { + _31 = call const fn baml.future.Future.cancel(copy _13) -> [bb7]; + } + + bb7: { + _0 = copy _16; + goto -> bb8; + } + + bb8: { + return; + } + + bb9: { + _19 = is_type(copy _17, baml.panics.Cancelled); + branch copy _19 -> [bb11, bb10]; + } + + bb10: { + rethrow copy _17; + } + + bb11: { + _20 = call const fn baml.time.Duration.to_milliseconds(copy _1) -> [bb12]; + } + + bb12: { + _21 = call const fn baml.Bigint.to_int(copy _20) -> [bb16, unwind: bb13]; + } + + bb13: { + _23 = is_type(copy _22, baml.errors.InvalidArgument); + branch copy _23 -> [bb15, bb14]; + } + + bb14: { + rethrow copy _22; + } + + bb15: { + _21 = const null; + goto -> bb16; + } + + bb16: { + _28 = copy _20; + _29 = load_type(bigint); + _27 = call const fn baml.String.from(copy _28) -> [bb17]; + } + + bb17: { + _26 = const "operation timed out after " + copy _27; + _25 = copy _26 + const "ms"; + _30 = copy _21; + _24 = baml.errors.Timeout { copy _25, copy _30 }; + throw copy _24; + } +} + +// lambda[0] +fn .() -> T { + // Locals: + let _0: T // _0 // return + let _1: () -> T throws E + + bb0: { + _1 = copy capture[0]; + _0 = call copy _1() -> [bb1]; + } + + bb1: { + return; + } +} + +// lambda[1] +fn .() -> int { + // Locals: + let _0: int // _0 // return + let _1: null + let _2: baml.time.Duration + + bb0: { + _2 = copy capture[0]; + _1 = sys_op const fn baml.sys.sleep(copy _2) -> bb1; + } + + bb1: { + _0 = call const fn baml.spawn.CancelToken.cancel(copy capture[1]) -> [bb2]; + } + + bb2: { + return; + } +} + fn baml.glob.Glob.scan = builtin(io) fn baml.glob.Glob.matches = builtin(io) @@ -4224,10 +4388,9 @@ fn baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { let _1: baml.io.Read // self // param let _2: uint8array // buf let _3: null | uint8array - let _4: int - let _5: null | uint8array - let _6: uint8array // chunk - let _7: uint8array + let _4: null | uint8array + let _5: uint8array // chunk + let _6: uint8array bb0: { _2 = b"<0 bytes>"; @@ -4235,32 +4398,28 @@ fn baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { } bb1: { - _4 = call const fn baml.Int.max_value() -> [bb2]; + _3 = virtual_call read as baml.io.Read(copy _1, const 65536_i64) -> [bb2]; } bb2: { - _3 = virtual_call read as baml.io.Read(copy _1, copy _4) -> [bb3]; + _4 = copy _3; + _4 = narrow_bind copy _4 as Uint8Array { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb5, bb3]; } bb3: { - _5 = copy _3; - _5 = narrow_bind copy _5 as Uint8Array { attr: TyAttr { sap_parse_without_null: Unset, sap_pending_never: Unset, sap_in_progress_never: Unset } } -> [bb6, bb4]; - } - - bb4: { _0 = copy _2; - goto -> bb5; + goto -> bb4; } - bb5: { + bb4: { return; } - bb6: { - fresh_cell(_6); + bb5: { + fresh_cell(_5); + _5 = copy _4; _6 = copy _5; - _7 = copy _6; - _2 = call const fn baml.Uint8Array.concat(copy _2, copy _7) -> [bb1]; + _2 = call const fn baml.Uint8Array.concat(copy _2, copy _6) -> [bb1]; } } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index 60cdd8204ac..81eb71db5ff 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -2639,6 +2639,112 @@ function baml.future.race(futures: future<#0, #1>[]) -> future<#0, #1> { return } +function baml.future.with_timeout(limit: baml.time.Duration, body: () -> #0 throws #1) -> #0 { + load_var ?1 + make_cell + store_var ?1 + load_var ?2 + make_cell + store_var ?2 + load_var ?3 + make_cell + store_var ?3 + call baml.spawn.CancelToken.new + store_deref ?3 + load_type #0 + load_type #1 + load_var body + make_closure ., captures=1, ntypeargs=2 + store_var _5 + load_type #0 + load_type #1 + load_const + load_deref ?3 + load_const + call baml.spawn.options + store_var _7 + load_var _5 + load_const null + load_const null + load_const null + load_const false + init_instance baml.spawn.SpawnParams .body, .name, .group, .cancel, .detach + load_var _7 + call_indirect + store_var _11 + load_var _5 + load_const null + load_var _11 + load_type #0 + load_type #1 + spawn + store_var _12 + load_type #0 + load_type #1 + load_var2 1 3 + make_closure ., captures=2, ntypeargs=2 + load_const null + load_const null + load_type int + load_type baml.errors.Io + spawn + store_var _15 + load_var _12 + await + store_var out + jump L5 + load_var e + is_type baml.panics.Cancelled + pop_jump_if_false L0 + jump L1 + + L0: + load_var e + rethrow + + L1: + load_deref ?1 + call baml.time.Duration.to_milliseconds + store_var limit_ms + load_var limit_ms + call baml.Bigint.to_int + store_var reported + jump L4 + load_var conversion + is_type baml.errors.InvalidArgument + pop_jump_if_false L2 + jump L3 + + L2: + load_var conversion + rethrow + + L3: + load_const null + store_var reported + + L4: + load_type bigint + load_var limit_ms + call baml.String.from + store_var _27 + load_const "operation timed out after " + load_var _27 + bin_op + + load_const "ms" + bin_op + + load_var reported + init_instance baml.errors.Timeout .message, .duration_ms + throw + + L5: + load_var _15 + call baml.future.Future.cancel + pop 1 + load_var out + return +} + function baml.glob.Glob.matches(self: baml.glob.Glob, path: string) -> bool { } @@ -2865,17 +2971,16 @@ function baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { store_var buf L0: - call baml.Int.max_value - store_var _4 - load_var2 1 4 + load_var self + load_const 65536 load_type baml.io.Read load_const "read" virtual_call nargs=2 ntypeargs=0 store_var _3 load_var _3 - store_var _5 - load_var _5 - narrow_bind uint8array, slot=5 + store_var _4 + load_var _4 + narrow_bind uint8array, slot=4 pop_jump_if_false L1 jump L2 @@ -2884,7 +2989,7 @@ function baml.io.Read.read_to_end(self: baml.io.Read) -> uint8array { return L2: - load_var2 2 5 + load_var2 2 4 call baml.Uint8Array.concat store_var buf jump L0 diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index 8b6b1560088..f32059852ce 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -143,6 +143,7 @@ namespace baml.future: function all_complete function any function race + function with_timeout namespace baml.glob: class Glob { methods: [scan, matches] } class ScanOptions { methods: [] } @@ -343,6 +344,7 @@ namespace baml.sys: class ReadPipe { methods: [close, lines, read] } class ReadPipeLines { methods: [iter, next] } class ShellOutput { methods: [ok] } + enum StderrMode class WritePipe { methods: [close, write, flush] } function _strip_carriage_return function argv diff --git a/baml_language/crates/baml_tests/tests/shell.rs b/baml_language/crates/baml_tests/tests/shell.rs index 1595ef01cfd..6d222a75be6 100644 --- a/baml_language/crates/baml_tests/tests/shell.rs +++ b/baml_language/crates/baml_tests/tests/shell.rs @@ -367,10 +367,17 @@ async fn start_process_stdout_read_is_cancellable() { baml.sys.sleep(baml.time.Duration.from_milliseconds(25n)); tok.cancel() }; - (await read) catch (e) { + // The cancel arm and a real line are both strings, so the + // assertion below only holds if the read was actually + // cancelled: a line would return itself, and a completed + // stream returns "eof". + let outcome = (await read) catch (e) { baml.panics.Cancelled => "cancelled" }; - "cancelled" + match (outcome) { + let line: string => line, + baml.iter.Done => "eof", + } } "# ); @@ -460,3 +467,115 @@ async fn shell_stderr_bytes() { panic!("expected Uint8Array, got {:?}", output.result); } } + +// === StderrMode === + +#[tokio::test] +#[cfg(not(target_os = "windows"))] +async fn start_process_stderr_pipe_is_readable() { + let output = baml_test!( + r#" + function main() -> string throws baml.errors.Io | baml.errors.Timeout { + let process = baml.sys.start_process( + "sh", + ["-c", "printf 'boom\n' >&2"], + baml.sys.ProcessOptions { stderr: baml.sys.StderrMode.Pipe }, + ); + defer { process.close() } + + match (process.stderr) { + null => "no pipe", + let err: baml.sys.ReadPipe => { + match (err.lines().next()) { + let line: string => line, + baml.iter.Done => "eof", + } + }, + } + } + "# + ); + + assert_eq!( + output.result, + Ok(BexExternalValue::String("boom".to_string().into())) + ); +} + +// Inherit is the default, so a caller that never asks for the pipe cannot +// wedge a child on an unread stderr — `Process.stderr` is simply absent. +#[tokio::test] +#[cfg(not(target_os = "windows"))] +async fn start_process_stderr_defaults_to_inherit() { + let output = baml_test!( + r#" + function main() -> bool throws baml.errors.Io | baml.errors.Timeout { + let process = baml.sys.start_process("sh", ["-c", "printf 'x' >&2"], null); + defer { process.close() } + + let exit = process.wait(); + process.stderr == null && exit.ok() + } + "# + ); + + assert_eq!(output.result, Ok(BexExternalValue::Bool(true))); +} + +#[tokio::test] +#[cfg(not(target_os = "windows"))] +async fn start_process_stderr_discard_leaves_no_pipe() { + let output = baml_test!( + r#" + function main() -> bool throws baml.errors.Io | baml.errors.Timeout { + let process = baml.sys.start_process( + "sh", + ["-c", "printf 'x' >&2"], + baml.sys.ProcessOptions { stderr: baml.sys.StderrMode.Discard }, + ); + defer { process.close() } + + let exit = process.wait(); + process.stderr == null && exit.ok() + } + "# + ); + + assert_eq!(output.result, Ok(BexExternalValue::Bool(true))); +} + +// A child that floods stderr past the OS pipe buffer must still finish when +// the caller drains the pipe concurrently with stdout — the deadlock this +// mode is designed to make possible. +#[tokio::test] +#[cfg(not(target_os = "windows"))] +async fn start_process_stderr_pipe_survives_a_flood_when_drained() { + let output = baml_test!( + r#" + function main() -> bool throws baml.errors.Io | baml.errors.Timeout { + let process = baml.sys.start_process( + "sh", + ["-c", "i=0; while [ $i -lt 4000 ]; do printf 'noise-noise-noise-noise\n' >&2; i=$((i+1)); done; printf 'done\n'"], + baml.sys.ProcessOptions { stderr: baml.sys.StderrMode.Pipe }, + ); + defer { process.close() } + + let drain = spawn { + match (process.stderr) { + null => 0, + let err: baml.sys.ReadPipe => err.lines().collect().length(), + } + }; + let out = match (process.stdout.lines().next()) { + let line: string => line, + baml.iter.Done => "eof", + }; + let noise = await drain; + let exit = process.wait(); + out == "done" && noise == 4000 && exit.ok() + } + "# + ); + + assert_eq!(output.result, Ok(BexExternalValue::Bool(true))); +} diff --git a/baml_language/crates/bex_engine/tests/collect_tests.rs b/baml_language/crates/bex_engine/tests/collect_tests.rs index 5526f3205c9..2f26b1cd6bc 100644 --- a/baml_language/crates/bex_engine/tests/collect_tests.rs +++ b/baml_language/crates/bex_engine/tests/collect_tests.rs @@ -465,7 +465,7 @@ async fn collect_tests_sequential_runs_children_in_source_order() { baml.fs.write(path, ""); test "one" { let f = baml.fs.open(path, "a"); - f.write("1"); + f.write("1".to_utf8()); f.close(); } test "two" { diff --git a/baml_language/crates/sys_native/src/io_impls.rs b/baml_language/crates/sys_native/src/io_impls.rs index 3095220966c..7e3bc20cfa7 100644 --- a/baml_language/crates/sys_native/src/io_impls.rs +++ b/baml_language/crates/sys_native/src/io_impls.rs @@ -11,6 +11,13 @@ use sys_ops::io::{ self, CallId, SysOpContext, SysOpOutput, VmBamlError, VmPanic, VmRustFnError, owned, }; +/// Ceiling on the buffer one `read` allocates, whatever limit the caller +/// names. `baml.io.Read.read` promises *at most* `limit` bytes, so answering a +/// larger request with a short read is within contract — and it keeps a limit +/// that is really "everything" (`read_to_end` asks for a big number by +/// design) from becoming an allocation nothing can satisfy. +const MAX_READ_CHUNK: usize = 64 * 1024; + // Process-level shared BufReader for stdin, preventing data loss when // BufReader over-reads into its internal buffer across multiple io.input() calls. static STDIN_READER: OnceLock>> = @@ -1241,6 +1248,9 @@ struct LiveProcessHandle { label: String, } +/// The engine-owned read end of a pipe (`baml.sys.ReadPipe._pipe`). Boxed +/// rather than typed as `ChildStdout` so one handle serves every reader a +/// child exposes (stdout and stderr today). struct ReadPipeHandle { reader: tokio::sync::Mutex>>, label: String, @@ -1252,6 +1262,35 @@ struct WritePipeHandle { label: String, } +/// `ProcessOptions.stderr` as a `Stdio`, plus whether the caller wants the +/// pipe handed back. Enum variants cross the sys-op boundary as +/// `BexExternalValue::Variant`, and an absent option means `Inherit` — the +/// default that cannot wedge a child on an unread pipe. +fn stderr_stdio( + mode: Option<&BexExternalValue>, +) -> Result<(std::process::Stdio, bool), VmBamlError> { + use std::process::Stdio; + + let Some(mode) = mode else { + return Ok((Stdio::inherit(), false)); + }; + let BexExternalValue::Variant { variant_name, .. } = mode else { + return Err(VmBamlError::InvalidArgument { + message: format!("Invalid stderr mode: {}", mode.type_name()), + }); + }; + match variant_name.as_str() { + "Inherit" => Ok((Stdio::inherit(), false)), + "Pipe" => Ok((Stdio::piped(), true)), + "Discard" => Ok((Stdio::null(), false)), + other => Err(VmBamlError::InvalidArgument { + message: format!( + "Unsupported stderr mode '{other}': expected Inherit, Pipe, or Discard" + ), + }), + } +} + fn downcast_read_pipe(pipe: &owned::sys::ReadPipe) -> Result, VmBamlError> { pipe._pipe .clone() @@ -1282,9 +1321,7 @@ fn read_pipe( } } -/// Frame a reader's bytes into the line stream `ReadPipe.lines()` returns. The -/// reader is moved onto a task that owns it for the rest of its life, which is -/// why `lines()` consumes the pipe. +/// Wrap the engine-owned write end of a pipe as a `baml.sys.WritePipe`. fn write_pipe( writer: impl tokio::io::AsyncWrite + Send + Unpin + 'static, label: String, @@ -1360,7 +1397,7 @@ impl io::IoClassSysReadPipe for NativeSysOps { // requested, so a request for none is an empty chunk (as in `fs::File`). let limit = match usize::try_from(limit) { Err(_) | Ok(0) => return SysOpOutput::ok(Some(Vec::new())), - Ok(limit) => limit, + Ok(limit) => limit.min(MAX_READ_CHUNK), }; SysOpOutput::async_op(async move { @@ -1548,7 +1585,10 @@ impl io::IoClassSysProcess for NativeSysOps { if let Ok(handle) = downcast_write_pipe(&process.stdin) { handle.writer.lock().await.take(); } - for pipe in [&process.stdout, &process.stderr] { + for pipe in [Some(&process.stdout), process.stderr.as_ref()] + .into_iter() + .flatten() + { if let Ok(handle) = downcast_read_pipe(pipe) { handle.reader.lock().await.take(); } @@ -1704,13 +1744,14 @@ impl io::IoNamespaceSys for NativeSysOps { } } - // `Process` exposes all three streams as pipes, so all three are - // piped unconditionally. Stderr is no longer inherited: the caller - // owns it and must drain it, or the child blocks once the pipe - // buffer fills. + // stdin/stdout are always pipes — `Process` exposes both. stderr + // follows `ProcessOptions.stderr`, defaulting to inherit so an + // undrained pipe cannot stop the child. + let (stderr_stdio, stderr_piped) = + stderr_stdio(options.as_ref().and_then(|options| options.stderr.as_ref()))?; cmd.stdin(Stdio::piped()) .stdout(Stdio::piped()) - .stderr(Stdio::piped()) + .stderr(stderr_stdio) .kill_on_drop(true); let mut child = cmd.spawn().map_err(|error| VmBamlError::Io { @@ -1721,7 +1762,10 @@ impl io::IoNamespaceSys for NativeSysOps { }; let child_stdin = child.stdin.take().ok_or_else(|| missing_pipe("stdin"))?; let child_stdout = child.stdout.take().ok_or_else(|| missing_pipe("stdout"))?; - let child_stderr = child.stderr.take().ok_or_else(|| missing_pipe("stderr"))?; + let child_stderr = match stderr_piped { + true => Some(child.stderr.take().ok_or_else(|| missing_pipe("stderr"))?), + false => None, + }; let timeout_ms = options .as_ref() @@ -1735,26 +1779,13 @@ impl io::IoNamespaceSys for NativeSysOps { let stdin = write_pipe(child_stdin, format!("{program} stdin")); let stdout = read_pipe(child_stdout, format!("{program} stdout")); - let stderr = read_pipe(child_stderr, format!("{program} stderr")); - - // `options.stdin` supplies the child's COMPLETE input, so the pipe - // is closed after it lands — a child that reads to EOF would - // otherwise hang. Incremental writers leave it unset and drive - // `process.stdin` themselves. - if let Some(stdin_data) = options.as_ref().and_then(|options| options.stdin.as_ref()) { - let handle = downcast_write_pipe(&stdin)?; - let mut writer = handle.writer.lock().await; - if let Some(writer) = writer.as_mut() { - writer - .write_all(stdin_data.as_bytes()) - .await - .map_err(|error| VmBamlError::Io { - message: format!("Failed to write stdin to '{program}': {error}"), - })?; - } - writer.take(); - } + let stderr = child_stderr + .map(|child_stderr| read_pipe(child_stderr, format!("{program} stderr"))); + // The monitor comes up before anything can block, so the stdin + // write below has a kill path: without it, a child that never + // drains its stdin would strand `start_process` with no way to + // reach the process it just spawned. let (kill_tx, mut kill_rx) = tokio::sync::watch::channel(false); let (exit_tx, exit_rx) = tokio::sync::watch::channel(None); let monitor_label = program.clone(); @@ -1772,6 +1803,37 @@ impl io::IoNamespaceSys for NativeSysOps { let _ = exit_tx.send(Some(exit)); }); + // `options.stdin` supplies the child's COMPLETE input, so the pipe + // is closed after it lands — a child that reads to EOF would + // otherwise hang. Incremental writers leave it unset and drive + // `process.stdin` themselves. + // + // Input larger than the OS pipe buffer only completes as the child + // reads it, so this waits on the child. `timeout_ms` bounds that + // wait exactly as it bounds `wait()`; with no timeout the caller + // asked to block indefinitely. + if let Some(stdin_data) = options.as_ref().and_then(|options| options.stdin.as_ref()) { + let handle = downcast_write_pipe(&stdin)?; + let mut writer = handle.writer.lock().await; + if let Some(writer) = writer.as_mut() { + let write = writer.write_all(stdin_data.as_bytes()); + let written = + match deadline { + Some(deadline) => tokio::time::timeout_at(deadline, write) + .await + .map_err(|_elapsed| { + let _ = kill_tx.send(true); + process_timeout_error(&program, timeout_ms) + })?, + None => write.await, + }; + written.map_err(|error| VmBamlError::Io { + message: format!("Failed to write stdin to '{program}': {error}"), + })?; + } + writer.take(); + } + Ok(owned::sys::Process { stdin, stdout, @@ -1979,7 +2041,9 @@ impl io::IoClassNetTcpStream for NativeSysOps { Err(_) | Ok(0) => return SysOpOutput::Ready(Ok(Some(Vec::new()))), Ok(amount) => amount, }; - let amount = usize::try_from(amount).unwrap_or(usize::MAX); // does nothing on 64bit+ + let amount = usize::try_from(amount) + .unwrap_or(usize::MAX) // does nothing on 64bit+ + .min(MAX_READ_CHUNK); SysOpOutput::async_op(async move { let handle = downcast_tcpstream(&stream)?; diff --git a/baml_language/sdk_tests/harness_setup/src/csharp.rs b/baml_language/sdk_tests/harness_setup/src/csharp.rs index af8464f2f3b..6b3e26d6c06 100644 --- a/baml_language/sdk_tests/harness_setup/src/csharp.rs +++ b/baml_language/sdk_tests/harness_setup/src/csharp.rs @@ -289,7 +289,14 @@ fn verify_phase12_surface(fixture: &std::path::Path) { // is projected at all. The one `Write` that survives is the class's own // `write(string | uint8array)`; a second one would mean the interface method // was projected under the same name. - for absent in [" Read(", " ReadAsync(", " Flush(", " FlushAsync("] { + for absent in [ + " Read(", + " ReadAsync(", + " ReadBytes(", + " ReadBytesAsync(", + " Flush(", + " FlushAsync(", + ] { assert!( !file.contains(absent), "generated File resource surface exposed interface-block member `{absent}`" @@ -301,6 +308,26 @@ fn verify_phase12_surface(fixture: &std::path::Path) { "expected exactly one File.Write (the class method, not baml.io.Write's)" ); + // `TcpStream` keeps its ENTIRE byte surface in `implements` blocks, so + // unlike `File` it should project no read/write member at all. Dropping + // these names from the expected-members list below only stops asserting + // they exist; this is what catches them coming back. + let tcp_stream = fs::read_to_string(generated.join("Net").join("TcpStream.g.cs")) + .expect("failed to read generated typed TcpStream resource surface"); + for absent in [ + " Read(", + " ReadAsync(", + " Write(", + " WriteAsync(", + " Flush(", + " FlushAsync(", + ] { + assert!( + !tcp_stream.contains(absent), + "generated TcpStream resource surface exposed interface-block member `{absent}`" + ); + } + let resource_surfaces = [ ( "Fs/File.g.cs",