hypha-debugger 0.1.2 → 0.1.3

package/dist/debugger.d.ts

@@ -65,7 +65,15 @@ export declare class HyphaDebugger {
     private createGetSkillMd;
     /** Build the instruction block for the overlay panel. */
     private buildInstructionBlock;
-    /** Wrap a service function with logging and kwargs-to-positional-args support. */
+    /**
+     * Wrap a service function with logging and correct parameter names.
+     *
+     * Uses new Function() to create a wrapper whose parameter names match
+     * the __schema__ property names. This is critical for production builds
+     * where Babel/Terser minifies parameter names — hypha-rpc's
+     * getParamNames() parses Function.toString() to map kwargs to positional
+     * args, so the wrapper must have the real (unminified) parameter names.
+     */
     private wrapFn;
     private summarizeArgs;
 }

package/dist/hypha-debugger.js

@@ -13847,50 +13847,52 @@
           lines.push(``, `# 1. Get interactive elements (smart DOM analysis with indexed elements):`, `curl "$SERVICE_URL/get_browser_state"${auth}`, ``, `# 2. Click element by index (e.g. click [3]):`, `curl -X POST "$SERVICE_URL/click_element_by_index"${auth} -H "Content-Type: application/json" -d '{"index": 3}'`, ``, `# 3. Type into an input by index:`, `curl -X POST "$SERVICE_URL/input_text"${auth} -H "Content-Type: application/json" -d '{"index": 5, "text": "hello"}'`, ``, `# Take a screenshot:`, `curl "$SERVICE_URL/take_screenshot"${auth}`, ``, `# Execute JavaScript remotely:`, `curl -X POST "$SERVICE_URL/execute_script"${auth} -H "Content-Type: application/json" -d '{"code": "document.title"}'`, ``, `# Full API docs:`, `curl "$SERVICE_URL/get_skill_md"${auth}`);
           return lines.join("\n");
       }
-      /** Wrap a service function with logging and kwargs-to-positional-args support. */
+      /**
+       * Wrap a service function with logging and correct parameter names.
+       *
+       * Uses new Function() to create a wrapper whose parameter names match
+       * the __schema__ property names. This is critical for production builds
+       * where Babel/Terser minifies parameter names — hypha-rpc's
+       * getParamNames() parses Function.toString() to map kwargs to positional
+       * args, so the wrapper must have the real (unminified) parameter names.
+       */
       wrapFn(fn, name) {
-          const wrapped = async (...args) => {
-              // Hypha's HTTP API calls with keyword arguments (**kwargs),
-              // which arrive on the JS side as a single object argument.
-              // Destructure into positional args based on schema properties.
-              if (args.length === 1 &&
-                  args[0] &&
-                  typeof args[0] === "object" &&
-                  !Array.isArray(args[0]) &&
-                  fn.__schema__?.parameters?.properties) {
-                  const kwargs = args[0];
-                  const props = fn.__schema__.parameters.properties;
-                  const paramNames = Object.keys(props);
-                  // Check if any kwargs key matches a schema property name
-                  const hasMatchingKey = paramNames.some((p) => p in kwargs);
-                  if (hasMatchingKey) {
-                      args = paramNames.map((p) => kwargs[p]);
-                      while (args.length > 0 && args[args.length - 1] === undefined) {
-                          args.pop();
-                      }
-                  }
-              }
-              this.overlay?.addLog(`${name}(${this.summarizeArgs(args)})`, "call");
+          const schema = fn.__schema__;
+          const paramNames = schema?.parameters?.properties
+              ? Object.keys(schema.parameters.properties)
+              : [];
+          const self = this;
+          const callAndLog = async (args) => {
+              self.overlay?.addLog(`${name}(${self.summarizeArgs(args)})`, "call");
               try {
                   const result = await fn(...args);
                   const hasError = result && typeof result === "object" && "error" in result;
                   if (hasError) {
-                      this.overlay?.addLog(`${name}: ${result.error}`, "error");
+                      self.overlay?.addLog(`${name}: ${result.error}`, "error");
                   }
                   else {
-                      this.overlay?.addLog(`${name} -> OK`, "result");
+                      self.overlay?.addLog(`${name} -> OK`, "result");
                   }
                   return result;
               }
               catch (err) {
-                  this.overlay?.addLog(`${name}: ${err.message}`, "error");
+                  self.overlay?.addLog(`${name}: ${err.message}`, "error");
                   throw err;
               }
           };
-          if (fn.__schema__) {
-              wrapped.__schema__ = fn.__schema__;
+          let wrapper;
+          if (paramNames.length === 0) {
+              wrapper = async (...args) => callAndLog(args);
           }
-          return wrapped;
+          else {
+              // Create a function with explicit, unminified parameter names so
+              // hypha-rpc can parse them from Function.toString().
+              const paramList = paramNames.join(", ");
+              wrapper = new Function("callAndLog", `return async function(${paramList}) { return callAndLog([${paramList}]); }`)(callAndLog);
+          }
+          if (schema)
+              wrapper.__schema__ = schema;
+          return wrapper;
       }
       summarizeArgs(args) {
           if (args.length === 0)