agency-lang 0.7.6 → 0.7.7

package/dist/lib/runtime/prompt.d.ts

@@ -1,5 +1,6 @@
 import * as smoltalk from "smoltalk";
 import { UserContentInput } from "smoltalk";
+import { type FuncParam } from "./agencyFunction.js";
 import type { RetryPolicy, RetryConfig, LLMRetryReason } from "./llmRetry.js";
 import type { NormalizedLLMError } from "./llmClient.js";
 import type { SourceLocationOpts } from "./state/checkpointStore.js";
@@ -26,6 +27,17 @@ export declare function redactMessagesForLog(messages: MessageThread): smoltalk.
 /** A prompt with attachment payloads redacted, preserving its string-or-array
  *  shape, for statelog / hook data. */
 export declare function redactPromptForLog(p: string | UserContentInput): string | UserContentInput;
+/** LLMs routinely emit an explicit `null` for an optional tool argument
+ *  they chose not to set (e.g. `bash(command, cwd: null, timeout: null)`).
+ *  Agency default-parameter values only fill `undefined`, so a `null` would
+ *  sail past the default into the function body — `bash(cwd: null)` reaches
+ *  `applyAgentCwd` → `path.resolve(base, null)` and throws. Drop any argument
+ *  whose value is `null` when its parameter declares a default, so the call
+ *  behaves exactly as if the LLM had omitted the key (the default applies).
+ *  Params without a default keep their value untouched: a required arg passed
+ *  `null` still surfaces its normal type error for the model to correct, and
+ *  an intentionally-nullable param is left alone. */
+declare function dropNullDefaultedArgs(args: Record<string, any> | null | undefined, params: readonly FuncParam[]): Record<string, any>;
 /** Coerce an arbitrary tool result to the string the LLM would see.
  *  Strings pass through; everything else is JSON-stringified, with a
  *  `String()` fallback for values JSON can't represent (e.g. circular). */
@@ -92,6 +104,7 @@ export declare const _internal: {
     assertUniqueToolNames: typeof assertUniqueToolNames;
     armCallTimeout: typeof armCallTimeout;
     runWithRetry: typeof runWithRetry;
+    dropNullDefaultedArgs: typeof dropNullDefaultedArgs;
 };
 export declare function runPrompt(args: {
     prompt: string | UserContentInput;

package/dist/lib/runtime/prompt.js

@@ -77,6 +77,25 @@ async function dispatchLLMRequest({ ctx, promptConfig, prompt, stream, stateStac
         toolCalls: response.value.toolCalls || [],
     };
 }
+/** LLMs routinely emit an explicit `null` for an optional tool argument
+ *  they chose not to set (e.g. `bash(command, cwd: null, timeout: null)`).
+ *  Agency default-parameter values only fill `undefined`, so a `null` would
+ *  sail past the default into the function body — `bash(cwd: null)` reaches
+ *  `applyAgentCwd` → `path.resolve(base, null)` and throws. Drop any argument
+ *  whose value is `null` when its parameter declares a default, so the call
+ *  behaves exactly as if the LLM had omitted the key (the default applies).
+ *  Params without a default keep their value untouched: a required arg passed
+ *  `null` still surfaces its normal type error for the model to correct, and
+ *  an intentionally-nullable param is left alone. */
+function dropNullDefaultedArgs(args, params) {
+    const out = { ...args };
+    for (const param of params) {
+        if (param.hasDefault && out[param.name] === null) {
+            delete out[param.name];
+        }
+    }
+    return out;
+}
 /** Default cap on characters of a single tool result fed back to the
  *  LLM. A recursive `ls`/`grep` can return megabytes; without a cap one
  *  tool call can blow the context window. The FULL result is still
@@ -273,6 +292,7 @@ export const _internal = {
     assertUniqueToolNames,
     armCallTimeout,
     runWithRetry,
+    dropNullDefaultedArgs,
 };
 async function _runPrompt({ ctx, messages, tools, prompt, responseFormat, clientConfig, stateStack, retryPolicy, }) {
     if (ctx.isCancelled(stateStack)) {
@@ -908,7 +928,7 @@ export async function runPrompt(args) {
                 // uniformly by completedSteps inside b.step (start/invoke/end
                 // each get marked done on success and skipped on resume).
                 const branchStack = stack.getOrCreateBranch(branchKey).stack;
-                const namedArgs = { ...toolCall.arguments };
+                const namedArgs = dropNullDefaultedArgs(toolCall.arguments, handler.params);
                 await b.step(`round.${round}.tool.${callSlug}.start`, async () => {
                     // Pass `branchStack` so scoped callbacks registered inside
                     // the branch's frame chain are discovered by

package/dist/lib/runtime/prompt.test.js

@@ -246,3 +246,41 @@ describe("runWithRetry", () => {
         await expect(_internal.runWithRetry(dispatch, policy, parent.signal, noHooks, normalize)).rejects.toSatisfy((e) => readCause(e)?.kind === "userInterrupt");
     });
 });
+describe("dropNullDefaultedArgs", () => {
+    const P = (name, hasDefault) => ({
+        name,
+        hasDefault,
+        defaultValue: undefined,
+        variadic: false,
+    });
+    it("drops a null argument when the param has a default (LLM omitted it)", () => {
+        // Mirrors the real bug: bash(command, cwd: null) — cwd has a default of "".
+        const params = [P("command", false), P("cwd", true), P("timeout", true)];
+        const out = _internal.dropNullDefaultedArgs({ command: "ls", cwd: null, timeout: null }, params);
+        expect(out).toEqual({ command: "ls" });
+        expect("cwd" in out).toBe(false);
+        expect("timeout" in out).toBe(false);
+    });
+    it("keeps a null argument when the param has NO default", () => {
+        // A required (or intentionally-nullable) param keeps its value so the
+        // normal type error still surfaces for the model to correct.
+        const params = [P("target", false)];
+        expect(_internal.dropNullDefaultedArgs({ target: null }, params))
+            .toEqual({ target: null });
+    });
+    it("leaves non-null values untouched, including falsy ones", () => {
+        const params = [P("cwd", true), P("count", true), P("flag", true)];
+        const out = _internal.dropNullDefaultedArgs({ cwd: "/app", count: 0, flag: false }, params);
+        expect(out).toEqual({ cwd: "/app", count: 0, flag: false });
+    });
+    it("handles null/undefined argument objects", () => {
+        expect(_internal.dropNullDefaultedArgs(null, [P("cwd", true)])).toEqual({});
+        expect(_internal.dropNullDefaultedArgs(undefined, [P("cwd", true)])).toEqual({});
+    });
+    it("does not drop keys absent from the param list", () => {
+        // An arg with no matching param (e.g. an LLM hallucinated key) is left
+        // as-is; only declared defaulted params are considered.
+        const out = _internal.dropNullDefaultedArgs({ extra: null }, [P("cwd", true)]);
+        expect(out).toEqual({ extra: null });
+    });
+});

package/dist/lib/stdlib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.7.6";
+export declare const VERSION = "0.7.7";

package/dist/lib/stdlib/version.js

@@ -1 +1 @@
-export const VERSION = "0.7.6";
+export const VERSION = "0.7.7";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "The Agency language",
   "main": "lib/index.js",
   "bin": {