host callable test coverage opt args

Author: sxlijin

baml_language/sdk_tests/crates/python_pydantic2/function_calls/customizable/test_host_callables.py

@@ -19,10 +19,14 @@
 
 import baml_sdk  # noqa: F401  — initializes the BAML runtime
 from baml_sdk.baml import BamlError
+from baml_sdk.baml.errors import AccessError
 from baml_sdk.host_callable_tests import (
     Person,
     ValidationError,
     call_int_callback,
+    call_optional_callback_omitted,
+    call_optional_callback_supplied,
+    call_optional_int_callback_supplied,
     call_repeatedly,
     call_with_callback,
     call_with_class_callback,
@@ -339,3 +343,61 @@ def cb(_x: int) -> str:
 
     result = call_with_throwing(callback=cb, x=1)
     assert result == "caught:RuntimeError"
+
+
+# ---------------------------------------------------------------------------
+# Optional args × host callables (the combination).
+#
+# Optional args (test_optional_args.py) and host callables (the cases above)
+# were each covered in isolation but never together: a host callable whose
+# *own* type carries an optional parameter (`(x: int, y?: int) -> ...`).
+# Defaults aren't allowed inside a callable type — only the `?` optional
+# marker — so the host's own language-level default is the only possible
+# source of a value when BAML omits the arg.
+# ---------------------------------------------------------------------------
+
+
+def test_optional_arg_callable_supplied_passes_value_positionally():
+    """When BAML supplies the callable's optional arg (`callback(x, y = 9)`),
+    the engine resolves the named arg into the positional arg list, so the
+    Python callback receives both values positionally — overriding its own
+    default. Exercises the optional-args surface across the host boundary."""
+    seen: list[tuple[int, int]] = []
+
+    def cb(x: int, y: int = -1) -> str:
+        seen.append((x, y))
+        return f"{x}:{y}"
+
+    result = call_optional_callback_supplied(callback=cb, x=5)
+    assert result == "5:9"
+    assert seen == [(5, 9)]
+
+
+def test_optional_arg_callable_supplied_int_return():
+    """Same supplied-optional path with a non-string (`int`) return value —
+    covers the result-encode branch for an optional-arg host callable."""
+
+    def cb(x: int, y: int = 7) -> int:
+        return x * 10 + y
+
+    assert call_optional_int_callback_supplied(callback=cb, x=5) == 150
+
+
+def test_optional_arg_callable_omitted_raises_access_error():
+    """Omitting the callable's optional arg at the BAML call site
+    (`callback(x)`) currently fails. Unlike a BAML→BAML call — where the
+    engine resolves an omitted optional natively — the omitted-arg sentinel
+    cannot be converted to an owned value for the host wire, so the engine
+    raises `baml.errors.AccessError` *before* the callback ever runs. Pins
+    the current limitation: a host callable's optional arg cannot be omitted,
+    so the host's own default never gets a chance to apply."""
+    invoked: list[tuple[int, int]] = []
+
+    def cb(x: int, y: int = 0) -> str:
+        invoked.append((x, y))
+        return f"{x}:{y}"
+
+    with pytest.raises(BamlError) as exc_info:
+        call_optional_callback_omitted(callback=cb, x=5)
+    assert isinstance(exc_info.value.value, AccessError)
+    assert invoked == []  # the engine fails before dispatching to the host

baml_language/sdk_tests/crates/typescript_node/function_calls/customizable/host_callables.test.ts

@@ -1,8 +1,13 @@
 import "./baml_sdk/index.js";
+import { BamlError } from "@boundaryml/baml-core-node";
 import { describe, expect, it } from "vitest";
+import { AccessError } from "./baml_sdk/baml/errors/index.js";
 import {
   Person,
   call_int_callback_async,
+  call_optional_callback_omitted_async,
+  call_optional_callback_supplied_async,
+  call_optional_int_callback_supplied_async,
   call_repeatedly_async,
   call_with_callback,
   call_with_callback_async,
@@ -153,3 +158,67 @@ describe("function_calls — generated SDK sync guard for host callables", () =>
     );
   });
 });
+
+// Optional args × host callables (the combination): a host callable whose
+// own type carries an optional parameter (`(x: int, y?: int) -> ...`).
+// Optional args (optional_args.test.ts) and host callables (above) were each
+// covered alone but never together. Defaults aren't allowed inside a callable
+// type — only the `?` optional marker — so the host's own default is the only
+// possible source of a value when BAML omits the arg.
+describe("function_calls — optional-arg host callables (the combination)", () => {
+  // NOTE: a named/optional callable type (`(x: int, y?: int) -> T`) codegens
+  // to the loose `(...args: unknown[]) => T` signature in TS — unlike an
+  // unnamed positional type (`(int) -> string`), which yields a precise
+  // `(arg0: number) => string`. The callbacks below take `...args: unknown[]`
+  // to match that generated contract.
+  it("passes a supplied optional arg through positionally", async () => {
+    // BAML resolves `callback(x, y = 9)` into the callable's positional arg
+    // list, so the host receives both values positionally — overriding its
+    // own default.
+    const seen: unknown[][] = [];
+    const cb = (...args: unknown[]) => {
+      seen.push(args);
+      const [x, y] = args;
+      return `${x}:${y}`;
+    };
+
+    await expect(call_optional_callback_supplied_async(cb, 5)).resolves.toBe(
+      "5:9",
+    );
+    expect(seen).toEqual([[5, 9]]);
+  });
+
+  it("round-trips a supplied optional arg with an int return", async () => {
+    const cb = (...args: unknown[]) =>
+      (args[0] as number) * 10 + (args[1] as number);
+
+    await expect(
+      call_optional_int_callback_supplied_async(cb, 5),
+    ).resolves.toBe(150);
+  });
+
+  it("rejects an omitted optional arg with an AccessError before dispatch", async () => {
+    // Unlike a BAML→BAML call — where the engine resolves an omitted optional
+    // natively — the omitted-arg sentinel cannot cross the host serialization
+    // boundary, so the engine raises `baml.errors.AccessError` *before* the
+    // callback ever runs. Pins the current limitation: a host callable's
+    // optional arg cannot be omitted at the call site.
+    const invoked: unknown[][] = [];
+    const cb = (...args: unknown[]) => {
+      invoked.push(args);
+      const [x, y] = args;
+      return `${x}:${y}`;
+    };
+
+    let caught: unknown;
+    try {
+      await call_optional_callback_omitted_async(cb, 5);
+      expect.unreachable("expected an AccessError to be thrown");
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).toBeInstanceOf(BamlError);
+    expect((caught as BamlError).value).toBeInstanceOf(AccessError);
+    expect(invoked).toEqual([]); // the engine fails before dispatching
+  });
+});

baml_language/sdk_tests/fixtures/function_calls/baml_src/ns_host_callable_tests/main.baml

@@ -30,6 +30,42 @@ function call_with_class_callback(callback: (Person) -> string, p: Person) -> st
     callback(p)
 }
 
+// ─── Optional args × host callables (the combination) ───────────────────────
+//
+// These exercise the intersection of two surfaces that were each covered
+// in isolation but never together: a host callable whose *own* type
+// carries an optional parameter (`y?: int`). Defaults are not permitted
+// inside a callable type — only the `?` optional marker is — so the host's
+// own language-level default is the only source of a value when BAML omits
+// the arg.
+
+// Optional arg SUPPLIED by name across the host boundary. BAML resolves
+// `y = 9` into the callable's positional arg list, so the host receives
+// both args positionally (`callable.call1` in bridge_python's
+// host_value.rs). The happy path for an optional-arg host callable.
+function call_optional_callback_supplied(callback: (x: int, y?: int) -> string, x: int) -> string {
+    callback(x, y = 9)
+}
+
+// Same optional-arg callable shape with a non-string (`int`) return —
+// covers the result-encode path for an optional-arg host callable.
+function call_optional_int_callback_supplied(callback: (x: int, y?: int) -> int, x: int) -> int {
+    callback(x, y = 100)
+}
+
+// Optional arg OMITTED across the host boundary. Unlike a BAML→BAML call —
+// where the engine resolves an omitted optional natively (see the
+// `optional_dropping_adapter` case in ns_optional_function_parameters) —
+// the omitted-arg sentinel (`ValueKind::OmittedArg`) cannot be converted
+// to an owned `BexExternalValue` for the wire, so building the host-call
+// arg list raises `baml.errors.AccessError("omitted argument")` *before*
+// the host callable ever runs. This pins the current limitation: a host
+// callable cannot have an optional arg omitted at the call site, so the
+// host's own default never gets a chance to apply.
+function call_optional_callback_omitted(callback: (x: int, y?: int) -> string, x: int) -> string {
+    callback(x)
+}
+
 // Loop that invokes the callback N times — exercises N round-trips
 // through SysOp::BamlHostCallHostValue.
 function call_repeatedly(callback: (int) -> string, n: int) -> string[] {