llmist 1.1.0 → 1.2.0

package/dist/testing/index.cjs

@@ -1446,6 +1446,364 @@ var init_hook_validators = __esm({
   }
 });
 
+// src/gadgets/schema-introspector.ts
+function getDef(schema) {
+  return schema._def;
+}
+function getTypeName(schema) {
+  const def = getDef(schema);
+  return def?.type ?? def?.typeName;
+}
+function getShape(schema) {
+  const def = getDef(schema);
+  if (typeof def?.shape === "function") {
+    return def.shape();
+  }
+  return def?.shape;
+}
+var SchemaIntrospector;
+var init_schema_introspector = __esm({
+  "src/gadgets/schema-introspector.ts"() {
+    "use strict";
+    SchemaIntrospector = class {
+      schema;
+      cache = /* @__PURE__ */ new Map();
+      constructor(schema) {
+        this.schema = schema;
+      }
+      /**
+       * Get the expected type at a JSON pointer path.
+       *
+       * @param pointer - JSON pointer path without leading / (e.g., "config/timeout", "items/0")
+       * @returns Type hint for coercion decision
+       */
+      getTypeAtPath(pointer) {
+        const cached = this.cache.get(pointer);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const result = this.resolveTypeAtPath(pointer);
+        this.cache.set(pointer, result);
+        return result;
+      }
+      /**
+       * Internal method to resolve type at path without caching.
+       */
+      resolveTypeAtPath(pointer) {
+        if (!pointer) {
+          return this.getBaseType(this.schema);
+        }
+        const segments = pointer.split("/");
+        let current = this.schema;
+        for (const segment of segments) {
+          current = this.unwrapSchema(current);
+          const typeName = getTypeName(current);
+          if (typeName === "object" || typeName === "ZodObject") {
+            const shape = getShape(current);
+            if (!shape || !(segment in shape)) {
+              return "unknown";
+            }
+            current = shape[segment];
+          } else if (typeName === "array" || typeName === "ZodArray") {
+            if (!/^\d+$/.test(segment)) {
+              return "unknown";
+            }
+            const def = getDef(current);
+            const elementType = def?.element ?? def?.type;
+            if (!elementType) {
+              return "unknown";
+            }
+            current = elementType;
+          } else if (typeName === "tuple" || typeName === "ZodTuple") {
+            if (!/^\d+$/.test(segment)) {
+              return "unknown";
+            }
+            const index = parseInt(segment, 10);
+            const def = getDef(current);
+            const items = def?.items;
+            if (!items || index >= items.length) {
+              return "unknown";
+            }
+            current = items[index];
+          } else if (typeName === "record" || typeName === "ZodRecord") {
+            const def = getDef(current);
+            const valueType = def?.valueType;
+            if (!valueType) {
+              return "unknown";
+            }
+            current = valueType;
+          } else {
+            return "unknown";
+          }
+        }
+        return this.getBaseType(current);
+      }
+      /**
+       * Unwrap schema modifiers (optional, default, nullable, branded, etc.)
+       * to get to the underlying type.
+       */
+      unwrapSchema(schema) {
+        let current = schema;
+        let iterations = 0;
+        const maxIterations = 20;
+        while (iterations < maxIterations) {
+          const typeName = getTypeName(current);
+          const wrapperTypes = [
+            "optional",
+            "nullable",
+            "default",
+            "catch",
+            "branded",
+            "readonly",
+            "pipeline",
+            "ZodOptional",
+            "ZodNullable",
+            "ZodDefault",
+            "ZodCatch",
+            "ZodBranded",
+            "ZodReadonly",
+            "ZodPipeline"
+          ];
+          if (typeName && wrapperTypes.includes(typeName)) {
+            const def = getDef(current);
+            const inner = def?.innerType ?? def?.in ?? def?.type;
+            if (!inner || inner === current) break;
+            current = inner;
+            iterations++;
+            continue;
+          }
+          break;
+        }
+        return current;
+      }
+      /**
+       * Get the primitive type hint from an unwrapped schema.
+       */
+      getBaseType(schema) {
+        const unwrapped = this.unwrapSchema(schema);
+        const typeName = getTypeName(unwrapped);
+        switch (typeName) {
+          // Primitive types
+          case "string":
+          case "ZodString":
+            return "string";
+          case "number":
+          case "ZodNumber":
+          case "bigint":
+          case "ZodBigInt":
+            return "number";
+          case "boolean":
+          case "ZodBoolean":
+            return "boolean";
+          // Literal types - check the literal value type
+          case "literal":
+          case "ZodLiteral": {
+            const def = getDef(unwrapped);
+            const values = def?.values;
+            const value = values?.[0] ?? def?.value;
+            if (typeof value === "string") return "string";
+            if (typeof value === "number" || typeof value === "bigint")
+              return "number";
+            if (typeof value === "boolean") return "boolean";
+            return "unknown";
+          }
+          // Enum - always string keys
+          case "enum":
+          case "ZodEnum":
+          case "nativeEnum":
+          case "ZodNativeEnum":
+            return "string";
+          // Union - return 'unknown' to let auto-coercion decide
+          // Since multiple types are valid, we can't definitively say what the LLM intended
+          // Auto-coercion will handle common cases (numbers, booleans) appropriately
+          case "union":
+          case "ZodUnion":
+            return "unknown";
+          // Discriminated union - complex, return unknown
+          case "discriminatedUnion":
+          case "ZodDiscriminatedUnion":
+            return "unknown";
+          // Intersection - check both sides
+          case "intersection":
+          case "ZodIntersection": {
+            const def = getDef(unwrapped);
+            const left = def?.left;
+            const right = def?.right;
+            if (!left || !right) return "unknown";
+            const leftType = this.getBaseType(left);
+            const rightType = this.getBaseType(right);
+            if (leftType === rightType) return leftType;
+            if (leftType === "string" || rightType === "string") return "string";
+            return "unknown";
+          }
+          // Effects/transforms - return unknown to let Zod handle it
+          case "effects":
+          case "ZodEffects":
+            return "unknown";
+          // Lazy - can't resolve without evaluating
+          case "lazy":
+          case "ZodLazy":
+            return "unknown";
+          // Complex types - return unknown
+          case "object":
+          case "ZodObject":
+          case "array":
+          case "ZodArray":
+          case "tuple":
+          case "ZodTuple":
+          case "record":
+          case "ZodRecord":
+          case "map":
+          case "ZodMap":
+          case "set":
+          case "ZodSet":
+          case "function":
+          case "ZodFunction":
+          case "promise":
+          case "ZodPromise":
+          case "date":
+          case "ZodDate":
+            return "unknown";
+          // Unknown/any/never/void/undefined/null
+          case "unknown":
+          case "ZodUnknown":
+          case "any":
+          case "ZodAny":
+          case "never":
+          case "ZodNever":
+          case "void":
+          case "ZodVoid":
+          case "undefined":
+          case "ZodUndefined":
+          case "null":
+          case "ZodNull":
+            return "unknown";
+          default:
+            return "unknown";
+        }
+      }
+    };
+  }
+});
+
+// src/gadgets/block-params.ts
+function parseBlockParams(content, options) {
+  const argPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
+  const result = {};
+  const seenPointers = /* @__PURE__ */ new Set();
+  const introspector = options?.schema ? new SchemaIntrospector(options.schema) : void 0;
+  const parts = content.split(argPrefix);
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    const newlineIndex = part.indexOf("\n");
+    if (newlineIndex === -1) {
+      const pointer2 = part.trim();
+      if (pointer2) {
+        if (seenPointers.has(pointer2)) {
+          throw new Error(`Duplicate pointer: ${pointer2}`);
+        }
+        seenPointers.add(pointer2);
+        setByPointer(result, pointer2, "", introspector);
+      }
+      continue;
+    }
+    const pointer = part.substring(0, newlineIndex).trim();
+    let value = part.substring(newlineIndex + 1);
+    if (value.endsWith("\n")) {
+      value = value.slice(0, -1);
+    }
+    if (!pointer) {
+      continue;
+    }
+    if (seenPointers.has(pointer)) {
+      throw new Error(`Duplicate pointer: ${pointer}`);
+    }
+    seenPointers.add(pointer);
+    setByPointer(result, pointer, value, introspector);
+  }
+  return result;
+}
+function coerceValue(value, expectedType) {
+  if (value.includes("\n")) {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (expectedType === "string") {
+    return value;
+  }
+  if (expectedType === "boolean") {
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    return value;
+  }
+  if (expectedType === "number") {
+    const num = Number(trimmed);
+    if (!isNaN(num) && isFinite(num) && trimmed !== "") {
+      return num;
+    }
+    return value;
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed !== "" && /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+  return value;
+}
+function setByPointer(obj, pointer, value, introspector) {
+  const segments = pointer.split("/");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const nextSegment = segments[i + 1];
+    const nextIsArrayIndex = /^\d+$/.test(nextSegment);
+    if (Array.isArray(current)) {
+      const index = parseInt(segment, 10);
+      if (isNaN(index) || index < 0) {
+        throw new Error(`Invalid array index: ${segment}`);
+      }
+      if (index > current.length) {
+        throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
+      }
+      if (current[index] === void 0) {
+        current[index] = nextIsArrayIndex ? [] : {};
+      }
+      current = current[index];
+    } else {
+      const rec = current;
+      if (rec[segment] === void 0) {
+        rec[segment] = nextIsArrayIndex ? [] : {};
+      }
+      current = rec[segment];
+    }
+  }
+  const lastSegment = segments[segments.length - 1];
+  const expectedType = introspector?.getTypeAtPath(pointer);
+  const coercedValue = coerceValue(value, expectedType);
+  if (Array.isArray(current)) {
+    const index = parseInt(lastSegment, 10);
+    if (isNaN(index) || index < 0) {
+      throw new Error(`Invalid array index: ${lastSegment}`);
+    }
+    if (index > current.length) {
+      throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
+    }
+    current[index] = coercedValue;
+  } else {
+    current[lastSegment] = coercedValue;
+  }
+}
+var init_block_params = __esm({
+  "src/gadgets/block-params.ts"() {
+    "use strict";
+    init_constants();
+    init_schema_introspector();
+  }
+});
+
 // src/gadgets/error-formatter.ts
 var GadgetErrorFormatter;
 var init_error_formatter = __esm({
@@ -1557,325 +1915,7 @@ var init_exceptions = __esm({
         this.gadgetName = gadgetName;
         this.timeoutMs = timeoutMs;
       }
-    };
-  }
-});
-
-// src/gadgets/executor.ts
-var GadgetExecutor;
-var init_executor = __esm({
-  "src/gadgets/executor.ts"() {
-    "use strict";
-    init_logger();
-    init_error_formatter();
-    init_exceptions();
-    GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
-        this.registry = registry;
-        this.onHumanInputRequired = onHumanInputRequired;
-        this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
-        this.logger = logger ?? createLogger({ name: "llmist:executor" });
-        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
-      }
-      logger;
-      errorFormatter;
-      /**
-       * Creates a promise that rejects with a TimeoutException after the specified timeout.
-       */
-      createTimeoutPromise(gadgetName, timeoutMs) {
-        return new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new TimeoutException(gadgetName, timeoutMs));
-          }, timeoutMs);
-        });
-      }
-      // Execute a gadget call asynchronously
-      async execute(call) {
-        const startTime = Date.now();
-        this.logger.debug("Executing gadget", {
-          gadgetName: call.gadgetName,
-          invocationId: call.invocationId,
-          parameters: call.parameters
-        });
-        const rawParameters = call.parameters ?? {};
-        let validatedParameters = rawParameters;
-        try {
-          const gadget = this.registry.get(call.gadgetName);
-          if (!gadget) {
-            this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
-            const availableGadgets = this.registry.getNames();
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              error: this.errorFormatter.formatRegistryError(call.gadgetName, availableGadgets),
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (call.parseError || !call.parameters) {
-            this.logger.error("Gadget parameter parse error", {
-              gadgetName: call.gadgetName,
-              parseError: call.parseError,
-              rawParameters: call.parametersRaw
-            });
-            const parseErrorMessage = call.parseError ?? "Failed to parse parameters";
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: {},
-              error: this.errorFormatter.formatParseError(call.gadgetName, parseErrorMessage, gadget),
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (gadget.parameterSchema) {
-            const validationResult = gadget.parameterSchema.safeParse(rawParameters);
-            if (!validationResult.success) {
-              const validationError = this.errorFormatter.formatValidationError(
-                call.gadgetName,
-                validationResult.error,
-                gadget
-              );
-              this.logger.error("Gadget parameter validation failed", {
-                gadgetName: call.gadgetName,
-                issueCount: validationResult.error.issues.length
-              });
-              return {
-                gadgetName: call.gadgetName,
-                invocationId: call.invocationId,
-                parameters: rawParameters,
-                error: validationError,
-                executionTimeMs: Date.now() - startTime
-              };
-            }
-            validatedParameters = validationResult.data;
-          }
-          const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
-          let result;
-          if (timeoutMs && timeoutMs > 0) {
-            this.logger.debug("Executing gadget with timeout", {
-              gadgetName: call.gadgetName,
-              timeoutMs
-            });
-            result = await Promise.race([
-              Promise.resolve(gadget.execute(validatedParameters)),
-              this.createTimeoutPromise(call.gadgetName, timeoutMs)
-            ]);
-          } else {
-            result = await Promise.resolve(gadget.execute(validatedParameters));
-          }
-          const executionTimeMs = Date.now() - startTime;
-          this.logger.info("Gadget executed successfully", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            executionTimeMs
-          });
-          this.logger.debug("Gadget result", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            result,
-            executionTimeMs
-          });
-          return {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            result,
-            executionTimeMs
-          };
-        } catch (error) {
-          if (error instanceof BreakLoopException) {
-            this.logger.info("Gadget requested loop termination", {
-              gadgetName: call.gadgetName,
-              message: error.message
-            });
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: validatedParameters,
-              result: error.message,
-              breaksLoop: true,
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (error instanceof TimeoutException) {
-            this.logger.error("Gadget execution timed out", {
-              gadgetName: call.gadgetName,
-              timeoutMs: error.timeoutMs,
-              executionTimeMs: Date.now() - startTime
-            });
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: validatedParameters,
-              error: error.message,
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (error instanceof HumanInputException) {
-            this.logger.info("Gadget requested human input", {
-              gadgetName: call.gadgetName,
-              question: error.question
-            });
-            if (this.onHumanInputRequired) {
-              try {
-                const answer = await this.onHumanInputRequired(error.question);
-                this.logger.debug("Human input received", {
-                  gadgetName: call.gadgetName,
-                  answerLength: answer.length
-                });
-                return {
-                  gadgetName: call.gadgetName,
-                  invocationId: call.invocationId,
-                  parameters: validatedParameters,
-                  result: answer,
-                  executionTimeMs: Date.now() - startTime
-                };
-              } catch (inputError) {
-                this.logger.error("Human input callback error", {
-                  gadgetName: call.gadgetName,
-                  error: inputError instanceof Error ? inputError.message : String(inputError)
-                });
-                return {
-                  gadgetName: call.gadgetName,
-                  invocationId: call.invocationId,
-                  parameters: validatedParameters,
-                  error: inputError instanceof Error ? inputError.message : String(inputError),
-                  executionTimeMs: Date.now() - startTime
-                };
-              }
-            }
-            this.logger.warn("Human input required but no callback provided", {
-              gadgetName: call.gadgetName
-            });
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: validatedParameters,
-              error: "Human input required but not available (stdin is not interactive)",
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          const executionTimeMs = Date.now() - startTime;
-          this.logger.error("Gadget execution failed", {
-            gadgetName: call.gadgetName,
-            error: error instanceof Error ? error.message : String(error),
-            executionTimeMs
-          });
-          return {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            error: error instanceof Error ? error.message : String(error),
-            executionTimeMs
-          };
-        }
-      }
-      // Execute multiple gadget calls in parallel
-      async executeAll(calls) {
-        return Promise.all(calls.map((call) => this.execute(call)));
-      }
-    };
-  }
-});
-
-// src/gadgets/block-params.ts
-function parseBlockParams(content, options) {
-  const argPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
-  const result = {};
-  const seenPointers = /* @__PURE__ */ new Set();
-  const parts = content.split(argPrefix);
-  for (let i = 1; i < parts.length; i++) {
-    const part = parts[i];
-    const newlineIndex = part.indexOf("\n");
-    if (newlineIndex === -1) {
-      const pointer2 = part.trim();
-      if (pointer2) {
-        if (seenPointers.has(pointer2)) {
-          throw new Error(`Duplicate pointer: ${pointer2}`);
-        }
-        seenPointers.add(pointer2);
-        setByPointer(result, pointer2, "");
-      }
-      continue;
-    }
-    const pointer = part.substring(0, newlineIndex).trim();
-    let value = part.substring(newlineIndex + 1);
-    if (value.endsWith("\n")) {
-      value = value.slice(0, -1);
-    }
-    if (!pointer) {
-      continue;
-    }
-    if (seenPointers.has(pointer)) {
-      throw new Error(`Duplicate pointer: ${pointer}`);
-    }
-    seenPointers.add(pointer);
-    setByPointer(result, pointer, value);
-  }
-  return result;
-}
-function coerceValue(value) {
-  if (value.includes("\n")) {
-    return value;
-  }
-  const trimmed = value.trim();
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (trimmed !== "" && /^-?\d+(\.\d+)?$/.test(trimmed)) {
-    const num = Number(trimmed);
-    if (!isNaN(num) && isFinite(num)) {
-      return num;
-    }
-  }
-  return value;
-}
-function setByPointer(obj, pointer, value) {
-  const segments = pointer.split("/");
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    const nextSegment = segments[i + 1];
-    const nextIsArrayIndex = /^\d+$/.test(nextSegment);
-    if (Array.isArray(current)) {
-      const index = parseInt(segment, 10);
-      if (isNaN(index) || index < 0) {
-        throw new Error(`Invalid array index: ${segment}`);
-      }
-      if (index > current.length) {
-        throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
-      }
-      if (current[index] === void 0) {
-        current[index] = nextIsArrayIndex ? [] : {};
-      }
-      current = current[index];
-    } else {
-      const rec = current;
-      if (rec[segment] === void 0) {
-        rec[segment] = nextIsArrayIndex ? [] : {};
-      }
-      current = rec[segment];
-    }
-  }
-  const lastSegment = segments[segments.length - 1];
-  const coercedValue = coerceValue(value);
-  if (Array.isArray(current)) {
-    const index = parseInt(lastSegment, 10);
-    if (isNaN(index) || index < 0) {
-      throw new Error(`Invalid array index: ${lastSegment}`);
-    }
-    if (index > current.length) {
-      throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
-    }
-    current[index] = coercedValue;
-  } else {
-    current[lastSegment] = coercedValue;
-  }
-}
-var init_block_params = __esm({
-  "src/gadgets/block-params.ts"() {
-    "use strict";
-    init_constants();
+    };
   }
 });
 
@@ -2056,6 +2096,283 @@ var init_parser = __esm({
   }
 });
 
+// src/gadgets/executor.ts
+var GadgetExecutor;
+var init_executor = __esm({
+  "src/gadgets/executor.ts"() {
+    "use strict";
+    init_constants();
+    init_logger();
+    init_block_params();
+    init_error_formatter();
+    init_exceptions();
+    init_parser();
+    GadgetExecutor = class {
+      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
+        this.registry = registry;
+        this.onHumanInputRequired = onHumanInputRequired;
+        this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
+        this.logger = logger ?? createLogger({ name: "llmist:executor" });
+        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
+        this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
+      }
+      logger;
+      errorFormatter;
+      argPrefix;
+      /**
+       * Creates a promise that rejects with a TimeoutException after the specified timeout.
+       */
+      createTimeoutPromise(gadgetName, timeoutMs) {
+        return new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new TimeoutException(gadgetName, timeoutMs));
+          }, timeoutMs);
+        });
+      }
+      // Execute a gadget call asynchronously
+      async execute(call) {
+        const startTime = Date.now();
+        this.logger.debug("Executing gadget", {
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          parameters: call.parameters
+        });
+        const rawParameters = call.parameters ?? {};
+        let validatedParameters = rawParameters;
+        try {
+          const gadget = this.registry.get(call.gadgetName);
+          if (!gadget) {
+            this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
+            const availableGadgets = this.registry.getNames();
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              error: this.errorFormatter.formatRegistryError(call.gadgetName, availableGadgets),
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (call.parseError || !call.parameters) {
+            this.logger.error("Gadget parameter parse error", {
+              gadgetName: call.gadgetName,
+              parseError: call.parseError,
+              rawParameters: call.parametersRaw
+            });
+            const parseErrorMessage = call.parseError ?? "Failed to parse parameters";
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: {},
+              error: this.errorFormatter.formatParseError(call.gadgetName, parseErrorMessage, gadget),
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          let schemaAwareParameters = rawParameters;
+          const hasBlockFormat = call.parametersRaw?.includes(this.argPrefix);
+          if (gadget.parameterSchema && hasBlockFormat) {
+            try {
+              const cleanedRaw = stripMarkdownFences(call.parametersRaw);
+              const initialParse = parseBlockParams(cleanedRaw, { argPrefix: this.argPrefix });
+              const parametersWereModified = !this.deepEquals(rawParameters, initialParse);
+              if (parametersWereModified) {
+                this.logger.debug("Parameters modified by interceptor, skipping re-parse", {
+                  gadgetName: call.gadgetName
+                });
+                schemaAwareParameters = rawParameters;
+              } else {
+                schemaAwareParameters = parseBlockParams(cleanedRaw, {
+                  argPrefix: this.argPrefix,
+                  schema: gadget.parameterSchema
+                });
+                this.logger.debug("Re-parsed parameters with schema", {
+                  gadgetName: call.gadgetName,
+                  original: rawParameters,
+                  schemaAware: schemaAwareParameters
+                });
+              }
+            } catch (error) {
+              this.logger.warn("Schema-aware re-parsing failed, using original parameters", {
+                gadgetName: call.gadgetName,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              schemaAwareParameters = rawParameters;
+            }
+          }
+          if (gadget.parameterSchema) {
+            const validationResult = gadget.parameterSchema.safeParse(schemaAwareParameters);
+            if (!validationResult.success) {
+              const validationError = this.errorFormatter.formatValidationError(
+                call.gadgetName,
+                validationResult.error,
+                gadget
+              );
+              this.logger.error("Gadget parameter validation failed", {
+                gadgetName: call.gadgetName,
+                issueCount: validationResult.error.issues.length
+              });
+              return {
+                gadgetName: call.gadgetName,
+                invocationId: call.invocationId,
+                parameters: schemaAwareParameters,
+                error: validationError,
+                executionTimeMs: Date.now() - startTime
+              };
+            }
+            validatedParameters = validationResult.data;
+          } else {
+            validatedParameters = schemaAwareParameters;
+          }
+          const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
+          let result;
+          if (timeoutMs && timeoutMs > 0) {
+            this.logger.debug("Executing gadget with timeout", {
+              gadgetName: call.gadgetName,
+              timeoutMs
+            });
+            result = await Promise.race([
+              Promise.resolve(gadget.execute(validatedParameters)),
+              this.createTimeoutPromise(call.gadgetName, timeoutMs)
+            ]);
+          } else {
+            result = await Promise.resolve(gadget.execute(validatedParameters));
+          }
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.info("Gadget executed successfully", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            executionTimeMs
+          });
+          this.logger.debug("Gadget result", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
+          };
+        } catch (error) {
+          if (error instanceof BreakLoopException) {
+            this.logger.info("Gadget requested loop termination", {
+              gadgetName: call.gadgetName,
+              message: error.message
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              result: error.message,
+              breaksLoop: true,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (error instanceof TimeoutException) {
+            this.logger.error("Gadget execution timed out", {
+              gadgetName: call.gadgetName,
+              timeoutMs: error.timeoutMs,
+              executionTimeMs: Date.now() - startTime
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: error.message,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (error instanceof HumanInputException) {
+            this.logger.info("Gadget requested human input", {
+              gadgetName: call.gadgetName,
+              question: error.question
+            });
+            if (this.onHumanInputRequired) {
+              try {
+                const answer = await this.onHumanInputRequired(error.question);
+                this.logger.debug("Human input received", {
+                  gadgetName: call.gadgetName,
+                  answerLength: answer.length
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  result: answer,
+                  executionTimeMs: Date.now() - startTime
+                };
+              } catch (inputError) {
+                this.logger.error("Human input callback error", {
+                  gadgetName: call.gadgetName,
+                  error: inputError instanceof Error ? inputError.message : String(inputError)
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  error: inputError instanceof Error ? inputError.message : String(inputError),
+                  executionTimeMs: Date.now() - startTime
+                };
+              }
+            }
+            this.logger.warn("Human input required but no callback provided", {
+              gadgetName: call.gadgetName
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: "Human input required but not available (stdin is not interactive)",
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.error("Gadget execution failed", {
+            gadgetName: call.gadgetName,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          };
+        }
+      }
+      // Execute multiple gadget calls in parallel
+      async executeAll(calls) {
+        return Promise.all(calls.map((call) => this.execute(call)));
+      }
+      /**
+       * Deep equality check for objects/arrays.
+       * Used to detect if parameters were modified by an interceptor.
+       */
+      deepEquals(a, b) {
+        if (a === b) return true;
+        if (a === null || b === null) return a === b;
+        if (typeof a !== typeof b) return false;
+        if (typeof a !== "object") return a === b;
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+        if (Array.isArray(a) && Array.isArray(b)) {
+          if (a.length !== b.length) return false;
+          return a.every((val, i) => this.deepEquals(val, b[i]));
+        }
+        const aObj = a;
+        const bObj = b;
+        const aKeys = Object.keys(aObj);
+        const bKeys = Object.keys(bObj);
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every((key) => this.deepEquals(aObj[key], bObj[key]));
+      }
+    };
+  }
+});
+
 // src/agent/stream-processor.ts
 var StreamProcessor;
 var init_stream_processor = __esm({
@@ -2093,7 +2410,8 @@ var init_stream_processor = __esm({
           options.registry,
           options.onHumanInputRequired,
           this.logger.getSubLogger({ name: "executor" }),
-          options.defaultGadgetTimeoutMs
+          options.defaultGadgetTimeoutMs,
+          { argPrefix: options.gadgetArgPrefix }
         );
       }
       /**